Cách ngắn gọn và hiệu quả nhất để tìm hiểu xem một mảng JavaScript có chứa giá trị không là gì?

Đây là cách duy nhất tôi biết để làm điều đó:

function contains(a, obj) {
    for (var i = 0; i < a.length; i++) {
        if (a[i] === obj) {
            return true;
        }
    }
    return false;
}

Có cách nào tốt hơn và ngắn gọn hơn để thực hiện điều này?

Điều này liên quan rất chặt chẽ với câu hỏi Stack Overflow Cách tốt nhất để tìm một mục trong Mảng JavaScript? trong đó giải quyết việc tìm kiếm các đối tượng trong một mảng bằng cách sử dụng indexOf.

Các trình duyệt hiện đại Array#includes, thực hiện chính xác điều đó và được mọi người ủng hộ ngoại trừ IE:

console.log(['joe', 'jane', 'mary'].includes('jane')); //true

Bạn cũng có thể sử dụng Array#indexOf, ít trực tiếp hơn, nhưng không yêu cầu polyfill cho các trình duyệt lỗi thời.

Nhiều khung cũng cung cấp các phương thức tương tự:

• jQuery: $.inArray(value, array, [fromIndex])
• Underscore.js: _.contains(array, value)(cũng được đặt bí danh là _.includevà _.includes)
• Bộ công cụ Dojo: dojo.indexOf(array, value, [fromIndex, findLast])
• Nguyên mẫu: array.indexOf(value)
• MooTools: array.indexOf(value)
• MochiKit: findValue(array, value)
• MS Ajax: array.indexOf(value)
• Gia hạn Ext.Array.contains(array, value)
• Tạm dừng: _.includes(array, value, [from])(là _.containstrước 4.0.0)
• Ramda: R.includes(value, array)

Lưu ý rằng một số khung công tác thực hiện điều này như là một hàm, trong khi các khung khác thêm hàm vào nguyên mẫu mảng.

Cập nhật từ năm 2019: Câu trả lời này là từ năm 2008 (11 tuổi!) Và không liên quan đến việc sử dụng JS hiện đại. Cải thiện hiệu suất được hứa hẹn dựa trên điểm chuẩn được thực hiện trong các trình duyệt thời đó. Nó có thể không liên quan đến bối cảnh thực thi JS hiện đại. Nếu bạn cần một giải pháp dễ dàng, hãy tìm câu trả lời khác. Nếu bạn cần hiệu suất tốt nhất, điểm chuẩn cho chính mình trong các môi trường thực thi có liên quan.

Như những người khác đã nói, việc lặp qua mảng có lẽ là cách tốt nhất, nhưng đã được chứng minh rằng một whilevòng lặp giảm là cách nhanh nhất để lặp lại trong JavaScript. Vì vậy, bạn có thể muốn viết lại mã của mình như sau:

function contains(a, obj) {
    var i = a.length;
    while (i--) {
       if (a[i] === obj) {
           return true;
       }
    }
    return false;
}

Tất nhiên, bạn cũng có thể mở rộng nguyên mẫu Array:

Array.prototype.contains = function(obj) {
    var i = this.length;
    while (i--) {
        if (this[i] === obj) {
            return true;
        }
    }
    return false;
}

Và bây giờ bạn có thể chỉ cần sử dụng như sau:

alert([1, 2, 3].contains(2)); // => true
alert([1, 2, 3].contains('2')); // => false

indexOf có thể, nhưng đó là "phần mở rộng JavaScript cho tiêu chuẩn ECMA-262; vì vậy nó có thể không có mặt trong các triển khai khác của tiêu chuẩn."

Thí dụ:

[1, 2, 3].indexOf(1) => 0
["foo", "bar", "baz"].indexOf("bar") => 1
[1, 2, 3].indexOf(4) => -1

AFAICS Microsoft không cung cấp một số loại thay thế cho điều này, nhưng bạn có thể thêm chức năng tương tự vào các mảng trong Internet Explorer (và các trình duyệt khác không hỗ trợ indexOf) nếu bạn muốn, như một tìm kiếm nhanh của Google tiết lộ (ví dụ: cái này ).

ECMAScript 7 giới thiệu Array.prototype.includes.

Nó có thể được sử dụng như thế này:

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false

Nó cũng chấp nhận một đối số thứ hai tùy chọn fromIndex:

[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

Không giống như indexOf, sử dụng So sánh bình đẳng nghiêm ngặt , includesso sánh bằng thuật toán đẳng thức SameValueZero . Điều đó có nghĩa là bạn có thể phát hiện nếu một mảng bao gồm NaN:

[1, 2, NaN].includes(NaN); // true

Cũng không giống như indexOf, includeskhông bỏ qua các chỉ số bị thiếu:

new Array(5).includes(undefined); // true

Hiện tại nó vẫn chỉ là một bản nháp nhưng có thể được hoàn thiện để làm cho nó hoạt động trên tất cả các trình duyệt.

Các câu trả lời hàng đầu giả định các kiểu nguyên thủy nhưng nếu bạn muốn tìm hiểu xem một mảng có chứa một đối tượng có một số đặc điểm hay không, Array.prototype.some () là một giải pháp rất thanh lịch:

const items = [ {a: '1'}, {a: '2'}, {a: '3'} ]

items.some(item => item.a === '3')  // returns true
items.some(item => item.a === '4')  // returns false

Điều thú vị ở đây là phép lặp bị hủy bỏ một khi phần tử được tìm thấy để các chu kỳ lặp không cần thiết được bỏ qua.

Ngoài ra, nó phù hợp độc đáo trong một iftuyên bố vì nó trả về một boolean:

if (items.some(item => item.a === '3')) {
  // do something
}

* Như Jamess đã chỉ ra trong bình luận, tại thời điểm trả lời này, tháng 9 năm 2018, Array.prototype.some()được hỗ trợ đầy đủ: bảng hỗ trợ caniuse.com

Giả sử bạn đã xác định một mảng như vậy:

const array = [1, 2, 3, 4]

Dưới đây là ba cách để kiểm tra xem có một 3trong đó. Tất cả đều trở về truehoặc false.

Phương thức Mảng bản địa (kể từ ES2016) ( bảng tương thích )

array.includes(3) // true

Là phương thức Mảng tùy chỉnh (trước ES2016)

// Prefixing the method with '_' to avoid name clashes
Object.defineProperty(Array.prototype, '_includes', { value: function (v) { return this.indexOf(v) !== -1 }})
array._includes(3) // true

Chức năng đơn giản

const includes = (a, v) => a.indexOf(v) !== -1
includes(array, 3) // true

Đây là một triển khai tương thích JavaScript 1.6 của Array.indexOf:

if (!Array.indexOf) {
    Array.indexOf = [].indexOf ?
        function(arr, obj, from) {
            return arr.indexOf(obj, from);
        } :
        function(arr, obj, from) { // (for IE6)
            var l = arr.length,
                i = from ? parseInt((1 * from) + (from < 0 ? l : 0), 10) : 0;
            i = i < 0 ? 0 : i;
            for (; i < l; i++) {
                if (i in arr && arr[i] === obj) {
                    return i;
                }
            }
            return -1;
        };
}

Sử dụng:

function isInArray(array, search)
{
    return array.indexOf(search) >= 0;
}

// Usage
if(isInArray(my_array, "my_value"))
{
    //...
}

Mở rộng Arrayđối tượng JavaScript là một ý tưởng thực sự tồi tệ vì bạn giới thiệu các thuộc tính mới (phương thức tùy chỉnh của bạn) vào for-incác vòng lặp có thể phá vỡ các tập lệnh hiện có. Một vài năm trước, các tác giả của thư viện Prototype đã phải thiết kế lại việc triển khai thư viện của họ để loại bỏ loại điều này.

Nếu bạn không cần lo lắng về khả năng tương thích với các JavaScript khác đang chạy trên trang của mình, hãy sử dụng nó, nếu không, tôi khuyên bạn nên sử dụng giải pháp chức năng tự do khó xử lý hơn nhưng an toàn hơn.

Lót:

function contains(arr, x) {
    return arr.filter(function(elem) { return elem == x }).length > 0;
}

Suy nghĩ ra khỏi hộp trong một giây, nếu bạn thực hiện cuộc gọi này nhiều lần, sẽ hiệu quả hơn rất nhiều khi sử dụng một mảng kết hợp Bản đồ để thực hiện tra cứu bằng hàm băm.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map

Tôi sử dụng như sau:

Array.prototype.contains = function (v) {
    return this.indexOf(v) > -1;
}

var a = [ 'foo', 'bar' ];

a.contains('foo'); // true
a.contains('fox'); // false

function contains(a, obj) {
    return a.some(function(element){return element == obj;})
}

Array.prototype.some () đã được thêm vào tiêu chuẩn ECMA-262 trong phiên bản thứ 5

Hy vọng hai chiều indexOf/ lastIndexOfthay thế nhanh hơn

2015

Mặc dù phương thức mới bao gồm rất hay, nhưng về cơ bản thì sự hỗ trợ là bằng không.

Lâu lắm rồi tôi mới nghĩ ra cách thay thế các hàm indexOf / lastIndexOf chậm.

Một cách biểu diễn đã được tìm thấy, nhìn vào các câu trả lời hàng đầu. Từ những người tôi đã chọn containschức năng được đăng bởi @Damir Zekic, đây là chức năng nhanh nhất. Nhưng nó cũng nói rằng các điểm chuẩn là từ năm 2008 và do đó đã lỗi thời.

Tôi cũng thích whilehơn for, nhưng không phải là một lý do cụ thể, tôi đã kết thúc việc viết hàm với một vòng lặp for. Nó cũng có thể được thực hiện với mộtwhile -- .

Tôi đã tò mò nếu việc lặp lại chậm hơn nhiều nếu tôi kiểm tra cả hai mặt của mảng trong khi thực hiện nó. Rõ ràng là không, và do đó, chức năng này nhanh hơn khoảng hai lần so với các chức năng được bình chọn hàng đầu. Rõ ràng nó cũng nhanh hơn bản địa. Điều này trong một môi trường thế giới thực, nơi bạn không bao giờ biết liệu giá trị bạn đang tìm kiếm là ở đầu hay cuối mảng.

Khi bạn biết rằng bạn vừa đẩy một mảng có giá trị, sử dụng lastIndexOf có thể vẫn là giải pháp tốt nhất, nhưng nếu bạn phải đi qua các mảng lớn và kết quả có thể ở khắp mọi nơi, đây có thể là một giải pháp vững chắc để làm mọi thứ nhanh hơn.

Chỉ mục hai chiềuOf / last IndexOf

function bidirectionalIndexOf(a, b, c, d, e){
  for(c=a.length,d=c*1; c--; ){
    if(a[c]==b) return c; //or this[c]===b
    if(a[e=d-1-c]==b) return e; //or a[e=d-1-c]===b
  }
  return -1
}

//Usage
bidirectionalIndexOf(array,'value');

Kiểm tra hiệu suất

http://jsperf.com/bidirectionalindexof

Khi kiểm tra tôi đã tạo ra một mảng với 100k mục.

Ba truy vấn: ở đầu, ở giữa & ở cuối mảng.

Tôi hy vọng bạn cũng tìm thấy điều này thú vị và kiểm tra hiệu suất.

Lưu ý: Như bạn có thể thấy tôi đã sửa đổi một chút containschức năng để phản ánh đầu ra indexOf & lastIndexOf (về cơ bản là truevới indexvà falsevới -1). Điều đó không nên làm hại nó.

Các biến thể nguyên mẫu mảng

Object.defineProperty(Array.prototype,'bidirectionalIndexOf',{value:function(b,c,d,e){
  for(c=this.length,d=c*1; c--; ){
    if(this[c]==b) return c; //or this[c]===b
    if(this[e=d-1-c] == b) return e; //or this[e=d-1-c]===b
  }
  return -1
},writable:false, enumerable:false});

// Usage
array.bidirectionalIndexOf('value');

Hàm này cũng có thể dễ dàng được sửa đổi để trả về true hoặc false hoặc thậm chí là đối tượng, chuỗi hoặc bất cứ thứ gì.

Và đây là whilebiến thể:

function bidirectionalIndexOf(a, b, c, d){
  c=a.length; d=c-1;
  while(c--){
    if(b===a[c]) return c;
    if(b===a[d-c]) return d-c;
  }
  return c
}

// Usage
bidirectionalIndexOf(array,'value');

Sao có thể như thế được?

Tôi nghĩ rằng phép tính đơn giản để lấy chỉ số phản ánh trong một mảng đơn giản đến mức nhanh hơn hai lần so với thực hiện một vòng lặp thực tế.

Dưới đây là một ví dụ phức tạp khi thực hiện ba kiểm tra mỗi lần lặp, nhưng điều này chỉ có thể với một phép tính dài hơn gây ra sự chậm lại của mã.

http://jsperf.com/bidirectionalindexof/2

Hiệu suất

Hôm nay 2020.01.07 Tôi thực hiện các thử nghiệm trên MacOs HighSierra 10.13.6 trên Chrome v78.0.0, Safari v13.0.4 và Firefox v71.0.0 cho 15 giải pháp được chọn. Kết luận

• giải pháp dựa trên JSON, Setvà đáng ngạc nhiên find(K, N, O) là chậm nhất trên tất cả các trình duyệt
• es6 includes(F) chỉ nhanh trên chrome
• các giải pháp dựa trên for(C, D) và indexOf(G, H) khá nhanh trên tất cả các trình duyệt trên các mảng nhỏ và lớn, vì vậy có lẽ chúng là lựa chọn tốt nhất cho giải pháp hiệu quả
• các giải pháp trong đó chỉ số giảm trong vòng lặp, (B) có thể chậm hơn vì cách bộ đệm CPU hoạt động .
• Tôi cũng chạy thử nghiệm cho mảng lớn khi phần tử được tìm kiếm ở vị trí 66% chiều dài mảng và các giải pháp dựa trên for(C, D, E) cho kết quả tương tự (~ 630 ops / giây - nhưng E trên safari và firefox là 10- Chậm hơn 20% so với C và D)

Các kết quả

Chi tiết

Tôi thực hiện 2 trường hợp kiểm tra: cho mảng có 10 phần tử và mảng có 1 phần tử. Trong cả hai trường hợp, chúng tôi đặt phần tử tìm kiếm ở giữa mảng.

let log = (name,f) => console.log(`${name}: 3-${f(arr,'s10')}  's7'-${f(arr,'s7')}  6-${f(arr,6)} 's3'-${f(arr,'s3')}`)

let arr = [1,2,3,4,5,'s6','s7','s8','s9','s10'];
//arr = new Array(1000000).fill(123); arr[500000]=7;

function A(a, val) {
    var i = -1;
    var n = a.length;
    while (i++<n) {
       if (a[i] === val) {
           return true;
       }
    }
    return false;
}

function B(a, val) {
    var i = a.length;
    while (i--) {
       if (a[i] === val) {
           return true;
       }
    }
    return false;
}

function C(a, val) {
    for (var i = 0; i < a.length; i++) {
        if (a[i] === val) return true;
    }
    return false;
}

function D(a,val)
{
    var len = a.length;
    for(var i = 0 ; i < len;i++)
    {
        if(a[i] === val) return true;
    }
    return false;
} 

function E(a, val){  
  var n = a.length-1;
  var t = n/2;
  for (var i = 0; i <= t; i++) {
        if (a[i] === val || a[n-i] === val) return true;
  }
  return false;
}

function F(a,val) {
	return a.includes(val);
}

function G(a,val) {
	return a.indexOf(val)>=0;
}

function H(a,val) {
	return !!~a.indexOf(val);
}

function I(a, val) {
  return a.findIndex(x=> x==val)>=0;
}

function J(a,val) {
	return a.some(x=> x===val);
}

function K(a, val) {
  const s = JSON.stringify(val);
  return a.some(x => JSON.stringify(x) === s);
}

function L(a,val) {
	return !a.every(x=> x!==val);
}

function M(a, val) {
  return !!a.find(x=> x==val);
}

function N(a,val) {
	return a.filter(x=>x===val).length > 0;
}

function O(a, val) {
  return new Set(a).has(val);
}

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);
log('O',O);

This shippet only presents functions used in performance tests - it not perform tests itself!

Mảng nhỏ - 10 phần tử

Bạn có thể thực hiện các bài kiểm tra trong máy của mình TẠI ĐÂY

Mảng lớn - 1.000.000 phần tử

Bạn có thể thực hiện các bài kiểm tra trong máy của mình TẠI ĐÂY

Nếu bạn đang sử dụng JavaScript 1.6 trở lên (Firefox 1.5 trở lên), bạn có thể sử dụng Array.indexOf . Mặt khác, tôi nghĩ rằng bạn sẽ kết thúc với một cái gì đó tương tự như mã ban đầu của bạn.

function inArray(elem,array)
{
    var len = array.length;
    for(var i = 0 ; i < len;i++)
    {
        if(array[i] == elem){return i;}
    }
    return -1;
} 

Trả về chỉ mục mảng nếu tìm thấy hoặc -1 nếu không tìm thấy

Chúng tôi sử dụng đoạn mã này (hoạt động với các đối tượng, mảng, chuỗi):

/*
 * @function
 * @name Object.prototype.inArray
 * @description Extend Object prototype within inArray function
 *
 * @param {mix}    needle       - Search-able needle
 * @param {bool}   searchInKey  - Search needle in keys?
 *
 */
Object.defineProperty(Object.prototype, 'inArray',{
    value: function(needle, searchInKey){

        var object = this;

        if( Object.prototype.toString.call(needle) === '[object Object]' || 
            Object.prototype.toString.call(needle) === '[object Array]'){
            needle = JSON.stringify(needle);
        }

        return Object.keys(object).some(function(key){

            var value = object[key];

            if( Object.prototype.toString.call(value) === '[object Object]' || 
                Object.prototype.toString.call(value) === '[object Array]'){
                value = JSON.stringify(value);
            }

            if(searchInKey){
                if(value === needle || key === needle){
                return true;
                }
            }else{
                if(value === needle){
                    return true;
                }
            }
        });
    },
    writable: true,
    configurable: true,
    enumerable: false
});

Sử dụng:

var a = {one: "first", two: "second", foo: {three: "third"}};
a.inArray("first");          //true
a.inArray("foo");            //false
a.inArray("foo", true);      //true - search by keys
a.inArray({three: "third"}); //true

var b = ["one", "two", "three", "four", {foo: 'val'}];
b.inArray("one");         //true
b.inArray('foo');         //false
b.inArray({foo: 'val'})   //true
b.inArray("{foo: 'val'}") //false

var c = "String";
c.inArray("S");        //true
c.inArray("s");        //false
c.inArray("2", true);  //true
c.inArray("20", true); //false

Nếu bạn đang kiểm tra nhiều lần sự tồn tại của một đối tượng trong một mảng, bạn có thể nên xem xét

1. Giữ mảng được sắp xếp mọi lúc bằng cách thực hiện sắp xếp chèn trong mảng của bạn (đặt các đối tượng mới vào đúng vị trí)
2. Thực hiện cập nhật các đối tượng như loại bỏ + thao tác chèn được sắp xếp và
3. Sử dụng một tra cứu tìm kiếm nhị phân trong của bạn contains(a, obj).

Giải pháp hoạt động trong tất cả các trình duyệt hiện đại:

function contains(arr, obj) {
  const stringifiedObj = JSON.stringify(obj); // Cache our object to not call `JSON.stringify` on every iteration
  return arr.some(item => JSON.stringify(item) === stringifiedObj);
}

Sử dụng:

contains([{a: 1}, {a: 2}], {a: 1}); // true

Giải pháp IE6 +:

function contains(arr, obj) {
  var stringifiedObj = JSON.stringify(obj)
  return arr.some(function (item) {
    return JSON.stringify(item) === stringifiedObj;
  });
}

// .some polyfill, not needed for IE9+
if (!('some' in Array.prototype)) {
  Array.prototype.some = function (tester, that /*opt*/) {
    for (var i = 0, n = this.length; i < n; i++) {
      if (i in this && tester.call(that, this[i], i, this)) return true;
    } return false;
  };
}

Sử dụng:

contains([{a: 1}, {a: 2}], {a: 1}); // true

Tại sao phải sử dụng JSON.stringify?

Array.indexOfvà Array.includes(cũng như hầu hết các câu trả lời ở đây) chỉ so sánh theo tham chiếu chứ không phải theo giá trị.

[{a: 1}, {a: 2}].includes({a: 1});
// false, because {a: 1} is a new object

Tặng kem

ES6 một lớp không được tối ưu hóa:

[{a: 1}, {a: 2}].some(item => JSON.stringify(item) === JSON.stringify({a: 1));
// true

Lưu ý: So sánh các đối tượng theo giá trị sẽ hoạt động tốt hơn nếu các khóa theo cùng một thứ tự, vì vậy để an toàn, bạn có thể sắp xếp các khóa trước với gói như thế này: https://www.npmjs.com/package/sort-keys

Cập nhật containschức năng với một tối ưu hóa hoàn hảo. Cảm ơn itinance đã chỉ ra nó.

Sử dụng lodash là một số chức năng.

Nó ngắn gọn, chính xác và có hỗ trợ đa nền tảng tuyệt vời.

Câu trả lời được chấp nhận thậm chí không đáp ứng yêu cầu.

Yêu cầu: Đề xuất cách ngắn gọn và hiệu quả nhất để tìm hiểu xem mảng JavaScript có chứa đối tượng không.

Trả lời được chấp nhận:

$.inArray({'b': 2}, [{'a': 1}, {'b': 2}])
> -1

Đề nghị của tôi:

_.some([{'a': 1}, {'b': 2}], {'b': 2})
> true

Ghi chú:

$ .inArray hoạt động tốt để xác định xem giá trị vô hướng có tồn tại trong một mảng vô hướng không ...

$.inArray(2, [1,2])
> 1

... nhưng câu hỏi rõ ràng yêu cầu một cách hiệu quả để xác định xem một đối tượng có được chứa trong một mảng hay không.

Để xử lý cả vô hướng và đối tượng, bạn có thể làm điều này:

(_.isObject(item)) ? _.some(ary, item) : (_.indexOf(ary, item) > -1)

ECMAScript 6 có một đề xuất thanh lịch về tìm kiếm.

Phương thức find thực hiện chức năng gọi lại một lần cho mỗi phần tử có trong mảng cho đến khi nó tìm thấy một trong đó gọi lại trả về một giá trị thực. Nếu một phần tử như vậy được tìm thấy, tìm ngay lập tức trả về giá trị của phần tử đó. Nếu không, tìm trả về không xác định. gọi lại chỉ được gọi cho các chỉ mục của mảng đã gán giá trị; nó không được gọi cho các chỉ mục đã bị xóa hoặc chưa bao giờ được gán giá trị.

Đây là tài liệu MDN về điều đó.

Các chức năng tìm thấy hoạt động như thế này.

function isPrime(element, index, array) {
    var start = 2;
    while (start <= Math.sqrt(element)) {
        if (element % start++ < 1) return false;
    }
    return (element > 1);
}

console.log( [4, 6, 8, 12].find(isPrime) ); // Undefined, not found
console.log( [4, 5, 8, 12].find(isPrime) ); // 5

Bạn có thể sử dụng điều này trong ECMAScript 5 trở xuống bằng cách xác định hàm .

if (!Array.prototype.find) {
  Object.defineProperty(Array.prototype, 'find', {
    enumerable: false,
    configurable: true,
    writable: true,
    value: function(predicate) {
      if (this == null) {
        throw new TypeError('Array.prototype.find called on null or undefined');
      }
      if (typeof predicate !== 'function') {
        throw new TypeError('predicate must be a function');
      }
      var list = Object(this);
      var length = list.length >>> 0;
      var thisArg = arguments[1];
      var value;

      for (var i = 0; i < length; i++) {
        if (i in list) {
          value = list[i];
          if (predicate.call(thisArg, value, i, list)) {
            return value;
          }
        }
      }
      return undefined;
    }
  });
}

Mặc dù array.indexOf(x)!=-1là cách ngắn gọn nhất để làm điều này (và đã được hỗ trợ bởi các trình duyệt không phải Internet Explorer trong hơn thập kỷ ...), nhưng đó không phải là O (1), mà là O (N), rất tệ. Nếu mảng của bạn sẽ không thay đổi, bạn có thể chuyển đổi mảng của mình thành hashtable, sau đó thực hiện table[x]!==undefinedhoặc ===undefined:

Array.prototype.toTable = function() {
    var t = {};
    this.forEach(function(x){t[x]=true});
    return t;
}

Bản giới thiệu:

var toRemove = [2,4].toTable();
[1,2,3,4,5].filter(function(x){return toRemove[x]===undefined})

(Thật không may, trong khi bạn có thể tạo Array.prototype.contains để "đóng băng" một mảng và lưu trữ hashtable trong this._cache trong hai dòng, điều này sẽ cho kết quả sai nếu bạn chọn chỉnh sửa mảng của mình sau. JavaScript không đủ móc vào cho phép bạn giữ trạng thái này, không giống như Python chẳng hạn.)

Người ta có thể sử dụng Set có phương thức "has ()":

function contains(arr, obj) {
      var proxy = new Set(arr);
      if (proxy.has(obj))
        return true;
      else
        return false;
    }

    var arr = ['Happy', 'New', 'Year'];
    console.log(contains(arr, 'Happy'));

Sử dụng:

var myArray = ['yellow', 'orange', 'red'] ;

alert(!!~myArray.indexOf('red')); //true

Bản giới thiệu

Để biết chính xác những gì tilde ~làm tại thời điểm này, hãy tham khảo câu hỏi này Dấu ngã làm gì khi nó đứng trước một biểu thức? .

OK, bạn chỉ có thể tối ưu hóa mã của mình để có kết quả!

Có nhiều cách để làm điều này sạch hơn và tốt hơn, nhưng tôi chỉ muốn lấy mẫu của bạn và áp dụng cho việc sử dụng đó JSON.stringify, chỉ đơn giản là làm một cái gì đó như thế này trong trường hợp của bạn:

function contains(a, obj) {
    for (var i = 0; i < a.length; i++) {
        if (JSON.stringify(a[i]) === JSON.stringify(obj)) {
            return true;
        }
    }
    return false;
}

Không có nghĩa là tốt nhất, nhưng tôi chỉ sáng tạo và thêm vào tiết mục.

Không dùng cái này

Object.defineProperty(Array.prototype, 'exists', {
  value: function(element, index) {

    var index = index || 0

    return index === this.length ? -1 : this[index] === element ? index : this.exists(element, ++index)
  }
})


// Outputs 1
console.log(['one', 'two'].exists('two'));

// Outputs -1
console.log(['one', 'two'].exists('three'));

console.log(['one', 'two', 'three', 'four'].exists('four'));

Ngạc nhiên vì câu hỏi này vẫn chưa có cú pháp mới nhất được thêm vào, thêm 2 xu của tôi.

Giả sử chúng ta có mảng đối tượng ArrayObj và chúng ta muốn tìm kiếm obj trong đó.

Array.prototype. indexOf -> (trả về chỉ mục hoặc -1 ) thường được sử dụng để tìm chỉ mục của phần tử trong mảng. Điều này cũng có thể được sử dụng để tìm kiếm đối tượng nhưng chỉ hoạt động nếu bạn chuyển tham chiếu đến cùng một đối tượng.

let obj = { name: 'Sumer', age: 36 };
let arrObj = [obj, { name: 'Kishor', age: 46 }, { name: 'Rupen', age: 26 }];


console.log(arrObj.indexOf(obj));// 0
console.log(arrObj.indexOf({ name: 'Sumer', age: 36 })); //-1

console.log([1, 3, 5, 2].indexOf(2)); //3

Array.prototype. bao gồm -> (trả về đúng hay sai )

console.log(arrObj.includes(obj));  //true
console.log(arrObj.includes({ name: 'Sumer', age: 36 })); //false

console.log([1, 3, 5, 2].includes(2)); //true

Array.prototype. find -> (nhận cuộc gọi lại, trả về giá trị / đối tượng đầu tiên trả về true trong CB).

console.log(arrObj.find(e => e.age > 40));  //{ name: 'Kishor', age: 46 }
console.log(arrObj.find(e => e.age > 40)); //{ name: 'Kishor', age: 46 }

console.log([1, 3, 5, 2].find(e => e > 2)); //3

Array.prototype. find Index -> (nhận cuộc gọi lại, trả về chỉ mục của giá trị / đối tượng đầu tiên trả về true trong CB).

console.log(arrObj.findIndex(e => e.age > 40));  //1
console.log(arrObj.findIndex(e => e.age > 40)); //1

console.log([1, 3, 5, 2].findIndex(e => e > 2)); //1

Vì find và find Index có một cuộc gọi lại, chúng tôi có thể tìm nạp bất kỳ đối tượng nào (ngay cả khi chúng tôi không có tham chiếu) từ mảng bằng cách đặt sáng tạo điều kiện thực.

Giải pháp đơn giản cho yêu cầu này là sử dụng find()

Nếu bạn đang có một loạt các đối tượng như dưới đây,

var users = [{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "admin"},
{id: "105", name: "user"}];

Sau đó, bạn có thể kiểm tra xem đối tượng có giá trị của bạn đã có hay chưa

let data = users.find(object => object['id'] === '104');

nếu dữ liệu là null thì không có admin, nếu không nó sẽ trả về đối tượng hiện có như bên dưới.

{id: "104", name: "admin"}

Sau đó, bạn có thể tìm chỉ mục của đối tượng đó trong mảng và thay thế đối tượng bằng mã bên dưới.

let indexToUpdate = users.indexOf(data);
let newObject = {id: "104", name: "customer"};
users[indexToUpdate] = newObject;//your new object
console.log(users);

bạn sẽ nhận được giá trị như dưới đây

[{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "customer"},
{id: "105", name: "user"}];

hy vọng điều này sẽ giúp bất cứ ai.