Hướng dẫn what is the difference between some and includes in javascript? - sự khác biệt giữa một số và bao gồm trong javascript là gì?

JavaScript Array là một cấu trúc dữ liệu mạnh mẽ trong các công nghệ web. Các phương pháp như .map(), .filter(), .includes(),and .reduce() giúp khắc phục rất nhiều vấn đề phải đối mặt hàng ngày (kiểm tra bài viết trước của tôi về 3 phương pháp này). Tuy nhiên, có hai phương pháp tương tự nhưng khác nhau là một phần trong kho vũ khí của bạn. Trong bài viết này, chúng tôi sẽ xem xét các phương pháp ____1010and

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
1 để phân biệt chúng, để hiểu các ứng dụng và ứng dụng khác nhau.array is a powerful data structure in web technologies. Methods such as .map(), .filter(), .includes(),and .reduce() helps a lot to overcome issues facing day to day (Checkout my previous article on these 3 methods). However, there are two similar but different methods that are part of your arsenal. In this article we will look in to the methods
function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
0and
function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
1to differentiate them, to understand there different usages and applications.

Miền vấn đề

Chúng tôi có một mảng số đơn giản. Chúng ta cần kiểm tra xem số

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
2AlReady có tồn tại trong danh sách không:

Không có gì đặc biệt ở đây, ngoại trừ việc sử dụng ECMAScript5 (ES5) có thể được thay thế bằng một

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
3or A
function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
4Loop. Tuy nhiên, chúng tôi có thể đơn giản hóa rất nhiều mã bằng cách sử dụng một tính năng được giới thiệu trong ECMAScript7 (ES7).ECMAScript 5(ES5) that can be replaced by a
function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
3or a
function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
4loop. However, we can greatly simplify the code by using a feature introduced in ECMAScript 7(ES7).

Phương thức .includes ()

Trong ES7, phương pháp đã được giới thiệu

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
0. Chúng ta hãy xem mã trước đó và sau đó tái cấu trúc nó để sử dụng trong hàm mới:

Tái cấu trúc đang thay đổi cấu trúc của mã mà không thay đổi hành vi cuối cùng của nó.

Phương thức ____1010returns

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
7Inly nếu phần tử tồn tại bên trong mảng. Lean Lever, yeah? Nhưng, sự đơn giản này có thể dẫn đến một lỗi nhà phát triển.

Kêt quả bât ngơ

Hãy để lặp lại ví dụ tìm kiếm trước đó với

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
0, nhưng lần này là tìm kiếm một mảng các đối tượng đại diện cho album:objects representing albums:

Nhiều như hàm

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
9 được làm trong ví dụ trước, dường như không thể tìm thấy album của chúng tôi. Lý do cho hành vi tinh nghịch này là gì?

So sánh giữa các loại

Trong nội bộ,

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
9Makes một so sánh thông qua
[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
1. Tuy nhiên, so sánh với công việc
[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
1or
[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
3Orly như mong đợi (so sánh giá trị) với các loại:

  • Boolean
  • Vô giá trị
  • Chưa xác định
  • Con số
  • Sợi dây
  • Biểu tượng (ES2015)

Khi chúng tôi so sánh các biến tham chiếu loại

[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
4, trình thông dịch sẽ kiểm tra xem chúng có chỉ vào cùng một đối tượng trong bộ nhớ hay không. Hãy xem ví dụ đơn giản này:

Tuy nhiên, kết quả sẽ đúng nếu chúng ta làm điều gì đó như thế này:

Trong bối cảnh này, chúng ta có thể ____1010return

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
7As theo sau:

Nhiều như giải pháp này hoạt động, không có ý nghĩa gì khi sử dụng nó khi tìm kiếm một đối tượng mà chúng ta không biết vị trí của nó, chứ đừng nói đến nếu nó tồn tại. Trong tình huống này, chúng ta có thể chuyển sang phương pháp

[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
7ES5 cũ.

Sử dụng phương thức .some ()

Hãy cùng xem xét ví dụ trước bằng phương pháp

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
1:

Hàm

[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
7Iterates qua mỗi phần tử của mảng bằng cách áp dụng logic so sánh. Nó sẽ hủy bỏ việc lặp lại ngay lập tức ngay khi tìm thấy mục đầu tiên trả về
function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
7 kết hợp so sánh. Lợi nhuận sẽ là
function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
7 nếu có bất kỳ yếu tố nào thỏa mãn logic.

Tiêu chí được sử dụng để so sánh

const fruits = ["apple", "banana", "mango", "guava"];

function checkAvailability(arr, val) {
  return arr.some((arrVal) => val === arrVal);
}

checkAvailability(fruits, "kela"); // false
checkAvailability(fruits, "banana"); // true
2of đối tượng. Bởi vì tài sản lưu trữ một số, so sánh với
[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
3or
[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
1 sử dụng giá trị nguyên thủy chứ không phải tham chiếu.

Chúng ta vẫn có thể so sánh tất cả các thuộc tính của đối tượng với thủ thuật sau:

Thông qua

const fruits = ["apple", "banana", "mango", "guava"];

function checkAvailability(arr, val) {
  return arr.some((arrVal) => val === arrVal);
}

checkAvailability(fruits, "kela"); // false
checkAvailability(fruits, "banana"); // true
5Convers đối tượng JavaScript thành một chuỗi không có gì khác hơn là biểu diễn văn bản của đối tượng. Là một đại diện thông qua một
const fruits = ["apple", "banana", "mango", "guava"];

function checkAvailability(arr, val) {
  return arr.some((arrVal) => val === arrVal);
}

checkAvailability(fruits, "kela"); // false
checkAvailability(fruits, "banana"); // true
6, chúng ta có thể sử dụng
[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
1or
[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
3, đó là so sánh sẽ sử dụng biểu diễn chuỗi.

Một trong những lợi thế lớn của

[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
7 họ có thể xác định logic so sánh tinh tế hơn.

Sự kết luận

Các tính năng hiện đại không phải lúc nào cũng giải quyết các vấn đề hàng ngày mà các nhà phát triển phải đối mặt. Điều quan trọng là phải biết vấn đề và tài nguyên được sử dụng để giải quyết nó vì vậy chúng tôi không có bất ngờ hoặc hành vi tinh nghịch như trên.problem and also the resource used to solve it so we have no surprises or mischievous behaviors as above.

Đó là bạn? Bạn đã bao giờ ngạc nhiên bởi

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
0? Bạn đã bao giờ sử dụng nó
[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
7 để giải quyết vấn đề chưa? Để lại bình luận của bạn dưới đây.

Phương pháp

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 kiểm tra xem ít nhất một phần tử trong mảng có vượt qua thử nghiệm được thực hiện bởi hàm được cung cấp hay không. Nó trả về đúng nếu, trong mảng, nó tìm thấy một phần tử mà hàm được cung cấp trả về đúng; nếu không thì nó trả về sai. Nó không sửa đổi mảng.
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2
method tests whether at least one element in the array passes the test implemented by the provided function. It returns true if, in the array, it finds an element for which the provided function returns true; otherwise it returns false. It doesn't modify the array.

Thử nó

Cú pháp

// Arrow function
some((element) => { /* … */ })
some((element, index) => { /* … */ })
some((element, index, array) => { /* … */ })

// Callback function
some(callbackFn)
some(callbackFn, thisArg)

// Inline callback function
some(function (element) { /* … */ })
some(function (element, index) { /* … */ })
some(function (element, index, array) { /* … */ })
some(function (element, index, array) { /* … */ }, thisArg)

Thông số

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
3

Một hàm để thực thi cho mỗi phần tử trong mảng. Nó sẽ trả về một sự thật để chỉ ra phần tử vượt qua bài kiểm tra và giá trị giả mạo khác.

Hàm được gọi với các đối số sau:

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
4

Phần tử hiện tại được xử lý trong mảng.

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
5

Chỉ số của phần tử hiện tại được xử lý trong mảng.

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
6

Mảng

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 đã được kêu gọi.

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
8 Tùy chọnOptional

Giá trị để sử dụng là

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
9 khi thực hiện
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
3. Xem phương pháp lặp.

Giá trị trả về

console.log([1, , 3].some((x) => x === undefined)); // false
console.log([1, , 1].some((x) => x !== 1)); // false
console.log([1, undefined, 1].some((x) => x !== 1)); // true
1 nếu hàm gọi lại trả về giá trị sự thật cho ít nhất một phần tử trong mảng. Nếu không,
console.log([1, , 3].some((x) => x === undefined)); // false
console.log([1, , 1].some((x) => x !== 1)); // false
console.log([1, undefined, 1].some((x) => x !== 1)); // true
2.

Sự mô tả

Phương pháp

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 là một phương pháp lặp. Nó gọi hàm
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
3 được cung cấp một lần cho mỗi phần tử trong một mảng, cho đến khi
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
3 trả về giá trị sự thật. Nếu một phần tử như vậy được tìm thấy,
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 ngay lập tức trả về
console.log([1, , 3].some((x) => x === undefined)); // false
console.log([1, , 1].some((x) => x !== 1)); // false
console.log([1, undefined, 1].some((x) => x !== 1)); // true
1 và ngừng lặp lại qua mảng. Mặt khác, nếu
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
3 trả về giá trị giả cho tất cả các yếu tố,
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 trả về
console.log([1, , 3].some((x) => x === undefined)); // false
console.log([1, , 1].some((x) => x !== 1)); // false
console.log([1, undefined, 1].some((x) => x !== 1)); // true
2.

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 hoạt động như bộ định lượng "tồn tại" trong toán học. Cụ thể, đối với một mảng trống, nó trả về
console.log([1, , 3].some((x) => x === undefined)); // false
console.log([1, , 1].some((x) => x !== 1)); // false
console.log([1, undefined, 1].some((x) => x !== 1)); // true
2 cho mọi điều kiện.

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
3 chỉ được gọi cho các chỉ mục mảng đã gán các giá trị. Nó không được gọi cho các khe trống trong các mảng thưa thớt.

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 không làm biến đổi mảng mà nó được gọi, nhưng chức năng được cung cấp như
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
3 có thể. Tuy nhiên, lưu ý rằng độ dài của mảng được lưu trước khi gọi đầu tiên của
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
3. Vì vậy:

  • const TRUTHY_VALUES = [true, "true", 1];
    
    function getBoolean(value) {
      if (typeof value === "string") {
        value = value.toLowerCase().trim();
      }
    
      return TRUTHY_VALUES.some((t) => t === value);
    }
    
    getBoolean(false); // false
    getBoolean("false"); // false
    getBoolean(1); // true
    getBoolean("true"); // true
    
    3 sẽ không truy cập bất kỳ yếu tố nào được thêm vào ngoài độ dài ban đầu của mảng khi cuộc gọi đến
    const TRUTHY_VALUES = [true, "true", 1];
    
    function getBoolean(value) {
      if (typeof value === "string") {
        value = value.toLowerCase().trim();
      }
    
      return TRUTHY_VALUES.some((t) => t === value);
    }
    
    getBoolean(false); // false
    getBoolean("false"); // false
    getBoolean(1); // true
    getBoolean("true"); // true
    
    2 bắt đầu.
  • Các thay đổi đối với các chỉ mục đã được truy cập không khiến
    const TRUTHY_VALUES = [true, "true", 1];
    
    function getBoolean(value) {
      if (typeof value === "string") {
        value = value.toLowerCase().trim();
      }
    
      return TRUTHY_VALUES.some((t) => t === value);
    }
    
    getBoolean(false); // false
    getBoolean("false"); // false
    getBoolean(1); // true
    getBoolean("true"); // true
    
    3 được gọi lại trên chúng.
  • Nếu một phần tử hiện có, chưa được liên kết của mảng được thay đổi bởi
    const TRUTHY_VALUES = [true, "true", 1];
    
    function getBoolean(value) {
      if (typeof value === "string") {
        value = value.toLowerCase().trim();
      }
    
      return TRUTHY_VALUES.some((t) => t === value);
    }
    
    getBoolean(false); // false
    getBoolean("false"); // false
    getBoolean(1); // true
    getBoolean("true"); // true
    
    3, giá trị của nó được chuyển cho
    const TRUTHY_VALUES = [true, "true", 1];
    
    function getBoolean(value) {
      if (typeof value === "string") {
        value = value.toLowerCase().trim();
      }
    
      return TRUTHY_VALUES.some((t) => t === value);
    }
    
    getBoolean(false); // false
    getBoolean("false"); // false
    getBoolean(1); // true
    getBoolean("true"); // true
    
    3 sẽ là giá trị tại thời điểm phần tử đó được truy cập. Các yếu tố bị xóa không được truy cập.

Phương pháp

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 là chung chung. Nó chỉ mong đợi giá trị
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
9 sẽ có thuộc tính .map()4 và các thuộc tính được khóa.

Ví dụ

Giá trị kiểm tra của các phần tử mảng

Ví dụ sau đây kiểm tra xem bất kỳ phần tử nào trong mảng lớn hơn 10.

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true

Kiểm tra các phần tử mảng bằng các hàm mũi tên

Các hàm mũi tên cung cấp một cú pháp ngắn hơn cho cùng một bài kiểm tra.

[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true

Kiểm tra xem một giá trị có tồn tại trong một mảng không

Để bắt chước hàm của phương thức .map()5, hàm tùy chỉnh này trả về

console.log([1, , 3].some((x) => x === undefined)); // false
console.log([1, , 1].some((x) => x !== 1)); // false
console.log([1, undefined, 1].some((x) => x !== 1)); // true
1 nếu phần tử tồn tại trong mảng:

const fruits = ["apple", "banana", "mango", "guava"];

function checkAvailability(arr, val) {
  return arr.some((arrVal) => val === arrVal);
}

checkAvailability(fruits, "kela"); // false
checkAvailability(fruits, "banana"); // true

Chuyển đổi bất kỳ giá trị nào thành Boolean

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true

Sử dụng một số () trên các mảng thưa thớt

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 sẽ không chạy vị ngữ của nó trên các khe trống.

console.log([1, , 3].some((x) => x === undefined)); // false
console.log([1, , 1].some((x) => x !== 1)); // false
console.log([1, undefined, 1].some((x) => x !== 1)); // true

Gọi một số () trên các đối tượng không phải

Phương thức

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
2 đọc thuộc tính .map()4 của
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
9 và sau đó truy cập vào mỗi chỉ mục số nguyên cho đến khi đạt được kết thúc hoặc
const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
3 trả về
console.log([1, , 3].some((x) => x === undefined)); // false
console.log([1, , 1].some((x) => x !== 1)); // false
console.log([1, undefined, 1].some((x) => x !== 1)); // true
1.

const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
};
console.log(Array.prototype.some.call(arrayLike, (x) => typeof x === "number"));
// false

Thông số kỹ thuật

Sự chỉ rõ
Thông số kỹ thuật ngôn ngữ Ecmascript # sec-array.prototype.some
# sec-array.prototype.some

Tính tương thích của trình duyệt web

Bảng BCD chỉ tải trong trình duyệt

Xem thêm

Sự khác biệt giữa chứa và bao gồm trong JavaScript là gì?

Sự khác biệt giữa bao gồm () và chứa () bao gồm và chứa cả hai phương thức tìm kiếm cho một chuỗi con trong một chuỗi hoặc tìm các phần tử trong một mảng. Bao gồm () là một phương thức có trong JavaScript, trong khi đó chứa () không có trong JavaScript. Nó được sử dụng trong các ngôn ngữ khác như Java.The includes() is a method present in JavaScript, whereas contains() is not present in JavaScript. It is used in other languages such as Java.

Sự khác biệt giữa một số và mỗi trong JavaScript là gì?

Một số () phương pháp trong JavaScript được sử dụng để kiểm tra xem ít nhất một trong các phần tử của mảng có thỏa mãn điều kiện đã cho hay không. Sự khác biệt duy nhất là phương thức một số () sẽ trả về đúng nếu bất kỳ vị ngữ nào là đúng trong khi mỗi () phương thức sẽ trả về true nếu tất cả các vị từ là đúng.some() method will return true if any predicate is true while every() method will return true if all predicates are true.

Sự khác biệt giữa bộ lọc và một số trong JavaScript là gì?

Phương thức .Some trả về một boolean (true/false), trong khi .Filter trả về một mảng các phần tử đáp ứng một số điều kiện. some method returns a boolean (true/false), while the . filter returns an array of elements which meet some condition.

Sử dụng những gì thay vì bao gồm trong JavaScript?

Indexof () Hàm mảng#indexof () là một giải pháp thay thế phổ biến để bao gồm ().Hàm indexof () trả về chỉ mục đầu tiên trong mảng mà nó tìm thấy valuetofind, hoặc -1 nếu không. The Array#indexOf() function is a common alternative to includes() . The indexOf() function returns the first index in the array at which it found valueToFind , or -1 otherwise.