Apa cara paling ringkas dan efisien untuk mengetahui apakah array JavaScript berisi nilai?

Ini adalah satu-satunya cara saya tahu untuk melakukannya:

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

Apakah ada cara yang lebih baik dan lebih ringkas untuk mencapai ini?

Ini sangat terkait dengan pertanyaan Stack Overflow Cara terbaik untuk menemukan item dalam JavaScript Array? yang membahas menemukan objek dalam array menggunakan indexOf.

Peramban modern memiliki Array#includes, yang melakukan hal itu dan didukung secara luas oleh semua orang kecuali IE:

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

Anda juga dapat menggunakan Array#indexOf, yang kurang langsung, tetapi tidak memerlukan polyfill untuk browser yang sudah ketinggalan zaman.

Banyak kerangka kerja juga menawarkan metode serupa:

• jQuery: $.inArray(value, array, [fromIndex])
• Underscore.js: _.contains(array, value)(juga alias _.includedan_.includes )
• Dojo Toolkit: dojo.indexOf(array, value, [fromIndex, findLast])
• Prototipe: array.indexOf(value)
• Mootools: array.indexOf(value)
• MochiKit: findValue(array, value)
• MS Ajax: array.indexOf(value)
• Ext: Ext.Array.contains(array, value)
• Lodash: _.includes(array, value, [from])(adalah_.contains sebelum 4.0.0)
• Ramda: R.includes(value, array)

Perhatikan bahwa beberapa kerangka kerja menerapkan ini sebagai fungsi, sementara yang lain menambahkan fungsi ke prototipe array.

Pembaruan dari 2019: Jawaban ini dari 2008 (11 tahun!) Dan tidak relevan untuk penggunaan JS modern. Peningkatan kinerja yang dijanjikan didasarkan pada tolok ukur yang dilakukan di browser saat itu. Mungkin tidak relevan dengan konteks eksekusi JS modern. Jika Anda membutuhkan solusi yang mudah, cari jawaban lain. Jika Anda membutuhkan kinerja terbaik, patok untuk diri sendiri di lingkungan eksekusi yang relevan.

Seperti yang orang lain katakan, iterasi melalui array mungkin adalah cara terbaik, tetapi telah terbukti bahwa whileloop yang menurun adalah cara tercepat untuk beralih di JavaScript. Jadi, Anda mungkin ingin menulis ulang kode Anda sebagai berikut:

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

Tentu saja, Anda juga dapat memperpanjang prototipe Array:

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

Dan sekarang Anda cukup menggunakan yang berikut ini:

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

indexOf mungkin, tetapi ini adalah "ekstensi JavaScript ke standar ECMA-262; karena itu mungkin tidak ada dalam implementasi standar lainnya."

Contoh:

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

AFAICS Microsoft tidak menawarkan semacam alternatif untuk ini, tetapi Anda dapat menambahkan fungsionalitas serupa ke array di Internet Explorer (dan browser lain yang tidak mendukung indexOf) jika Anda ingin, sebagai diungkapkan oleh pencarian Google cepat (misalnya, yang ini ).

ECMAScript 7 memperkenalkan Array.prototype.includes .

Dapat digunakan seperti ini:

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

Ia juga menerima argumen opsional kedua fromIndex:

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

Tidak seperti indexOf, yang menggunakan Strict Equality Comparison , includesmembandingkan menggunakan algoritma kesetaraan SameValueZero . Itu berarti bahwa Anda dapat mendeteksi jika array menyertakan NaN:

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

Juga tidak seperti indexOf, includestidak melewatkan indeks yang hilang:

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

Saat ini masih berupa konsep tetapi dapat di- polyfill agar berfungsi di semua browser.

Jawaban teratas mengasumsikan tipe primitif tetapi jika Anda ingin mengetahui apakah array berisi objek dengan beberapa sifat, Array.prototype.some () adalah solusi yang sangat elegan:

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

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

Yang menyenangkan tentang itu adalah bahwa iterasi dibatalkan setelah elemen ditemukan sehingga siklus iterasi yang tidak perlu terhindar.

Juga, itu sangat cocok dalam sebuah ifpernyataan karena mengembalikan boolean:

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

* Seperti yang ditunjukkan oleh jamess dalam komentar, pada saat jawaban ini, September 2018, Array.prototype.some()didukung penuh: tabel dukungan caniuse.com

Katakanlah Anda telah mendefinisikan array seperti:

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

Di bawah ini adalah tiga cara untuk memeriksa apakah ada 3di sana. Semuanya kembali trueataufalse .

Metode Array Asli (sejak ES2016) ( tabel kompatibilitas )

array.includes(3) // true

Sebagai metode Array khusus (sebelum 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

Fungsi sederhana

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

Inilah implementasi JavaScript 1.6 yang kompatibel dari 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;
        };
}

Menggunakan:

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

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

Memperluas Arrayobjek JavaScript adalah ide yang sangat buruk karena Anda memperkenalkan properti baru (metode khusus Anda) ke dalam for-inloop yang dapat memecah skrip yang ada. Beberapa tahun yang lalu penulis Prototipe perpustakaan harus merekayasa ulang implementasi perpustakaan mereka untuk menghapus hal semacam ini.

Jika Anda tidak perlu khawatir tentang kompatibilitas dengan JavaScript lain yang berjalan di halaman Anda, coba, jika tidak, saya akan merekomendasikan solusi fungsi berdiri bebas yang lebih aneh, tapi lebih aman.

Satu-liner:

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

Berpikir di luar kotak sejenak, jika Anda melakukan panggilan ini berkali-kali, jauh lebih efisien untuk menggunakan array asosiatif Peta untuk melakukan pencarian menggunakan fungsi hash.

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

Saya menggunakan yang berikut ini:

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 () ditambahkan ke standar ECMA-262 di edisi ke-5

Dua arah indexOf/ lastIndexOfalternatif semoga lebih cepat

2015

Meskipun metode baru termasuk sangat bagus, dukungan pada dasarnya nol untuk saat ini.

Sudah lama saya memikirkan cara untuk mengganti fungsi indexOf / lastIndexOf yang lambat.

Cara performan telah ditemukan, dengan melihat jawaban teratas. Dari yang saya pilih containsfungsi diposting oleh @Damir Zekic yang seharusnya menjadi yang tercepat. Tapi itu juga menyatakan bahwa tolok ukur berasal dari 2008 dan sudah usang.

Saya juga lebih suka whilelebih for, tetapi karena tidak alasan tertentu saya berakhir menulis fungsi dengan untuk loop. Bisa juga dilakukan dengan awhile -- .

Saya ingin tahu apakah iterasi jauh lebih lambat jika saya memeriksa kedua sisi array saat melakukannya. Tampaknya tidak, dan fungsi ini sekitar dua kali lebih cepat daripada yang terpilih. Jelas itu juga lebih cepat daripada yang asli. Ini di lingkungan dunia nyata, di mana Anda tidak pernah tahu apakah nilai yang Anda cari ada di awal atau di akhir array.

Ketika Anda tahu Anda baru saja mendorong array dengan sebuah nilai, menggunakan lastIndexOf mungkin merupakan solusi terbaik, tetapi jika Anda harus melakukan perjalanan melalui array besar dan hasilnya bisa di mana-mana, ini bisa menjadi solusi yang solid untuk membuat segalanya lebih cepat.

Bidirectional indexOf / lastIndexOf

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');

Uji kinerja

http://jsperf.com/bidirectionalindexof

Sebagai tes saya membuat array dengan entri 100 ribu.

Tiga pertanyaan: di awal, di tengah & di akhir array.

Saya harap Anda juga menemukan ini menarik dan menguji kinerjanya.

Catatan: Seperti yang Anda lihat saya sedikit memodifikasi containsfungsi untuk mencerminkan indexOf & lastIndexOf output (jadi pada dasarnya truedengan indexdan falsedengan -1). Itu seharusnya tidak merusaknya.

Varian prototipe array

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');

Fungsi ini juga dapat dengan mudah dimodifikasi untuk mengembalikan true atau false atau bahkan objek, string atau apa pun itu.

Dan inilah whilevariannya:

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');

Bagaimana ini mungkin?

Saya pikir perhitungan sederhana untuk mendapatkan indeks yang direfleksikan dalam array sangat sederhana sehingga dua kali lebih cepat daripada melakukan iterasi loop yang sebenarnya.

Berikut ini adalah contoh kompleks yang melakukan tiga pemeriksaan per iterasi, tetapi ini hanya mungkin dilakukan dengan perhitungan yang lebih lama yang menyebabkan pelambatan kode.

http://jsperf.com/bidirectionalindexof/2

Performa

Hari ini 2020.01.07 saya melakukan tes pada MacOs HighSierra 10.13.6 di Chrome v78.0.0, Safari v13.0.4 dan Firefox v71.0.0 untuk 15 solusi yang dipilih. Kesimpulan

• solusi berdasarkan JSON, Setdan secara mengejutkan find(K, N, O) paling lambat di semua browser
• ES6 includes(F) hanya cepat pada chrome
• solusi berdasarkan for (C, D) dan indexOf(G, H) cukup cepat pada semua browser pada array kecil dan besar jadi mungkin mereka adalah pilihan terbaik untuk solusi yang efisien
• solusi penurunan indeks selama loop, (B) lebih lambat mungkin karena cara cache CPU bekerja .
• Saya juga menjalankan tes untuk array besar ketika elemen yang dicari berada pada posisi 66% dari panjang array, dan solusi berdasarkan for(C, D, E) memberikan hasil yang sama (~ 630 ops / detik - tetapi E pada safari dan firefox adalah 10- 20% lebih lambat dari C dan D)

Hasil

Detail

Saya melakukan 2 tes kasus: untuk array dengan 10 elemen, dan array dengan 1 juta elemen. Dalam kedua kasus kami menempatkan elemen yang dicari di tengah array.

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!

Array kecil - 10 elemen

Anda dapat melakukan tes di mesin Anda DI SINI

Array besar - 1.000.000 elemen

Anda dapat melakukan tes di mesin Anda DI SINI

Jika Anda menggunakan JavaScript 1.6 atau lebih baru (Firefox 1.5 atau lebih baru) Anda dapat menggunakan Array.indexOf . Kalau tidak, saya pikir Anda akan berakhir dengan sesuatu yang mirip dengan kode asli Anda.

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

Mengembalikan indeks array jika ditemukan, atau -1 jika tidak ditemukan

Kami menggunakan cuplikan ini (berfungsi dengan objek, array, string):

/*
 * @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
});

Pemakaian:

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

Jika Anda memeriksa berulang kali untuk keberadaan suatu objek dalam array Anda mungkin harus melihat ke dalamnya

1. Menjaga agar array diurutkan setiap saat dengan melakukan sortasi pada array Anda (letakkan objek baru di tempat yang tepat)
2. Buat memperbarui objek sebagai menghapus operasi + insert yang diurutkan dan
3. Gunakan pencarian pencarian biner di blog Anda contains(a, obj).

Solusi yang bekerja di semua browser modern:

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);
}

Pemakaian:

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

Solusi 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;
  };
}

Pemakaian:

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

Mengapa harus menggunakan JSON.stringify?

Array.indexOfdan Array.includes(juga sebagian besar jawaban di sini) hanya membandingkan dengan referensi dan bukan dengan nilai.

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

Bonus

ES6 satu-liner yang tidak dioptimalkan:

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

Catatan: Membandingkan objek berdasarkan nilai akan bekerja lebih baik jika kunci berada dalam urutan yang sama, jadi agar aman Anda dapat mengurutkan kunci terlebih dahulu dengan paket seperti ini: https://www.npmjs.com/package/sort-keys

Memperbarui containsfungsi dengan optimasi perf. Terima kasih, keuangan karena menunjukkannya.

Gunakan beberapa fungsi lodash .

Ini ringkas, akurat dan memiliki dukungan lintas platform yang hebat.

Jawaban yang diterima bahkan tidak memenuhi persyaratan.

Persyaratan: Rekomendasikan cara yang paling ringkas dan efisien untuk mencari tahu apakah array JavaScript berisi objek.

Jawaban yang diterima:

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

Rekomendasi saya:

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

Catatan:

$ .inArray berfungsi dengan baik untuk menentukan apakah nilai skalar ada dalam array skalar ...

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

... tetapi pertanyaannya dengan jelas meminta cara yang efisien untuk menentukan apakah suatu objek terdapat dalam array.

Untuk menangani skalar dan objek, Anda bisa melakukan ini:

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

ECMAScript 6 memiliki proposal pencarian yang elegan.

Metode find mengeksekusi fungsi callback sekali untuk setiap elemen yang ada di dalam array sampai menemukan satu di mana callback mengembalikan nilai sebenarnya. Jika elemen tersebut ditemukan, cari segera mengembalikan nilai elemen itu. Kalau tidak, temukan pengembalian yang tidak ditentukan. callback dipanggil hanya untuk indeks array yang telah menetapkan nilai; itu tidak dipanggil untuk indeks yang telah dihapus atau yang tidak pernah diberi nilai.

Berikut adalah dokumentasi MDN tentang hal itu.

Fungsionalitas find berfungsi seperti ini.

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

Anda dapat menggunakan ini di ECMAScript 5 dan di bawahnya dengan mendefinisikan fungsi .

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;
    }
  });
}

Meskipun array.indexOf(x)!=-1merupakan cara paling ringkas untuk melakukan ini (dan telah didukung oleh browser non-Internet Explorer selama lebih dari satu dekade ...), itu bukan O (1), melainkan O (N), yang mengerikan. Jika array Anda tidak akan berubah, Anda dapat mengubah array Anda menjadi hashtable, lalu lakukan table[x]!==undefinedatau ===undefined:

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

Demo:

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

(Sayangnya, saat Anda dapat membuat Array.prototype.contain untuk "membekukan" array dan menyimpan hashtable di this._cache dalam dua baris, ini akan memberikan hasil yang salah jika Anda memilih untuk mengedit array Anda nanti. JavaScript memiliki kait yang tidak cukup untuk biarkan Anda mempertahankan status ini, tidak seperti Python misalnya.)

Satu dapat menggunakan Set yang memiliki metode "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'));

Menggunakan:

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

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

Demo

Untuk mengetahui apa yang tilde ~harus dilakukan pada saat ini, lihat pertanyaan ini Apa yang dilakukan tilde ketika mendahului ekspresi? .

Oke, Anda bisa mengoptimalkan kode Anda untuk mendapatkan hasilnya!

Ada banyak cara untuk melakukan ini yang lebih bersih dan lebih baik, tetapi saya hanya ingin mendapatkan pola Anda dan menerapkannya dengan menggunakan JSON.stringify, cukup lakukan sesuatu seperti ini dalam kasus Anda:

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

Bukan berarti yang terbaik, tetapi saya hanya menjadi kreatif dan menambah repertoar.

Jangan gunakan ini

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'));

Terkejut bahwa pertanyaan ini masih belum memiliki sintaks terbaru yang ditambahkan, menambahkan 2 sen saya.

Katakanlah kita memiliki array Objects arrObj dan kami ingin mencari objek di dalamnya.

Array.prototype. indexOf -> ( indeks pengembalian atau -1 ) umumnya digunakan untuk menemukan indeks elemen dalam array. Ini juga dapat digunakan untuk mencari objek tetapi hanya berfungsi jika Anda memberikan referensi ke objek yang sama.

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. termasuk -> (mengembalikan benar atau salah )

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 -> (mengambil callback, mengembalikan nilai / objek pertama yang mengembalikan true dalam 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. findIndex -> (mengambil callback, mengembalikan indeks nilai pertama / objek yang mengembalikan true dalam 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

Karena menemukan dan menemukanIndex menerima panggilan balik, kita dapat mengambil objek apa pun (bahkan jika kita tidak memiliki referensi) dari array dengan secara kreatif mengatur kondisi sebenarnya.

Solusi sederhana untuk persyaratan ini digunakan find()

Jika Anda memiliki berbagai objek seperti di bawah ini,

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

Kemudian Anda dapat memeriksa apakah objek dengan nilai Anda sudah ada atau belum

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

jika data nol maka tidak ada admin, selain itu akan mengembalikan objek yang ada seperti di bawah ini.

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

Kemudian Anda dapat menemukan indeks objek itu dalam array dan mengganti objek menggunakan kode di bawah ini.

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

Anda akan mendapatkan nilai seperti di bawah ini

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

Semoga ini bisa membantu siapa saja.