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
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. 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
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
3Mộ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
4Phầ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
5Chỉ 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
6Mả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ọnOptionalGiá 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:
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 đếnconst 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.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
- Các thay đổi đối với các chỉ mục đã được truy cập không khiến
3 được gọi lại trên chú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
- 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
3, giá trị của nó được chuyển choconst 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.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
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
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