วิธีที่รัดกุมและมีประสิทธิภาพมากที่สุดในการค้นหาว่าอาร์เรย์ JavaScript มีค่าคืออะไร?

นี่เป็นวิธีเดียวที่ฉันรู้:

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

มีวิธีที่ดีกว่าและรัดกุมกว่านี้หรือไม่

คำถามนี้เกี่ยวข้องกับคำถาม Stack Overflow มากที่สุดวิธีที่ดีที่สุดในการค้นหารายการในอาร์เรย์ JavaScript หรือไม่ indexOfซึ่งอยู่ในการหาวัตถุในอาร์เรย์ใช้

เบราว์เซอร์ที่ทันสมัยมีArray#includesซึ่งไม่ตรงกับที่และได้รับการสนับสนุนอย่างกว้างขวางโดยทุกคนยกเว้น IE:

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

คุณยังสามารถใช้Array#indexOfซึ่งน้อยกว่าโดยตรง แต่ไม่ต้องการโพลีฟิลสำหรับเบราว์เซอร์ที่ล้าสมัย

เฟรมเวิร์กจำนวนมากเสนอวิธีการที่คล้ายกัน:

• jQuery: $.inArray(value, array, [fromIndex])
• Underscore.js: _.contains(array, value)(และใช้นามแฝงเป็น_.includeและ_.includes)
• ชุดเครื่องมือ Dojo: dojo.indexOf(array, value, [fromIndex, findLast])
• ต้นแบบ: 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])( _.containsก่อนหน้า 4.0.0)
• Ramda: R.includes(value, array)

ขอให้สังเกตว่าบางเฟรมเวิร์คใช้สิ่งนี้เป็นฟังก์ชั่นในขณะที่คนอื่น ๆ เพิ่มฟังก์ชั่นให้กับต้นแบบอาร์เรย์

อัปเดตจาก 2019: คำตอบนี้มาจาก 2008 (อายุ 11 ปี!) และไม่เกี่ยวข้องกับการใช้งาน JS ที่ทันสมัย การปรับปรุงประสิทธิภาพที่ได้สัญญาไว้นั้นเป็นไปตามเกณฑ์มาตรฐานที่ทำในเบราว์เซอร์ในขณะนั้น อาจไม่เกี่ยวข้องกับบริบทการดำเนินการ JS สมัยใหม่ หากคุณต้องการทางออกที่ง่ายให้มองหาคำตอบอื่น ๆ หากคุณต้องการประสิทธิภาพที่ดีที่สุดให้สร้างมาตรฐานสำหรับตัวคุณเองในสภาพแวดล้อมการดำเนินการที่เกี่ยวข้อง

ดังที่คนอื่น ๆ กล่าวไว้การวนซ้ำผ่านอาร์เรย์อาจเป็นวิธีที่ดีที่สุด แต่ได้รับการพิสูจน์แล้วว่าการwhileวนซ้ำที่ลดลงเป็นวิธีที่เร็วที่สุดในการวนซ้ำใน JavaScript ดังนั้นคุณอาจต้องการเขียนรหัสของคุณใหม่ดังนี้:

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

แน่นอนคุณอาจขยายต้นแบบ Array ได้เช่นกัน:

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

และตอนนี้คุณสามารถใช้สิ่งต่อไปนี้:

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

indexOf อาจเป็นได้ แต่เป็น "ส่วนขยาย JavaScript ของมาตรฐาน ECMA-262 ดังนั้นจึงอาจไม่มีอยู่ในการปรับใช้มาตรฐานอื่น ๆ "

ตัวอย่าง:

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

AFAICS Microsoft ไม่เสนอทางเลือกประเภทนี้ แต่คุณสามารถเพิ่มฟังก์ชันการทำงานที่คล้ายกันในอาร์เรย์ใน Internet Explorer (และเบราว์เซอร์อื่นที่ไม่สนับสนุนindexOf) หากคุณต้องการเนื่องจากการค้นหาโดย Google ที่รวดเร็ว (ตัวอย่างเช่นอันนี้ )

ECMAScript 7 Array.prototype.includesเปิดตัว

มันสามารถใช้เช่นนี้:

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

นอกจากนี้ยังยอมรับอาร์กิวเมนต์ตัวเลือกที่สองfromIndex:

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

ซึ่งแตกต่างจากindexOfที่ใช้เข้มงวดเปรียบเทียบความเท่าเทียมกัน , includesเปรียบเทียบโดยใช้SameValueZeroอัลกอริทึมเท่าเทียมกัน นั่นหมายความว่าคุณสามารถตรวจสอบได้ว่าอาร์เรย์มีNaN:

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

ไม่เหมือนindexOfกันincludesอย่าข้ามดัชนีที่ขาดหายไป:

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

ขณะนี้ยังคงเป็นร่าง แต่สามารถpolyfilledเพื่อให้ทำงานบนเบราว์เซอร์ทั้งหมด

คำตอบอันดับแรกถือว่าเป็นประเภทดั้งเดิม แต่ถ้าคุณต้องการทราบว่าอาร์เรย์มีวัตถุที่มีลักษณะบางอย่างหรือไม่Array.prototype.some ()เป็นคำตอบที่สวยงามมาก:

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

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

สิ่งที่ดีเกี่ยวกับเรื่องนี้ก็คือการทำซ้ำจะถูกยกเลิกเมื่อองค์ประกอบพบว่าวงจรการทำซ้ำที่ไม่จำเป็นจะได้รับการงดเว้น

นอกจากนี้ยังเหมาะอย่างยิ่งในifคำสั่งเพราะมันกลับบูลีน:

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

* ตามที่ jamess ชี้ให้เห็นในความคิดเห็นในเวลาที่คำตอบนี้เดือนกันยายน 2018 Array.prototype.some()ได้รับการสนับสนุนอย่างเต็มที่: ตารางการสนับสนุน caniuse.com

สมมติว่าคุณได้กำหนดอาร์เรย์ไว้ดังนี้:

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

ด้านล่างมีสามวิธีในการตรวจสอบว่ามี3ในนั้นหรือไม่ ทั้งหมดของพวกเขากลับมาอย่างใดอย่างหนึ่งหรือtruefalse

วิธี Native Array (ตั้งแต่ ES2016) ( ตารางความเข้ากันได้ )

array.includes(3) // true

เป็นวิธี Array แบบกำหนดเอง (ก่อน 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

ฟังก์ชั่นที่เรียบง่าย

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

นี่คือการใช้งานร่วมกันได้ของJavaScript 1.6Array.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;
        };
}

ใช้:

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

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

การขยายArrayวัตถุJavaScript เป็นความคิดที่แย่มากเพราะคุณแนะนำคุณสมบัติใหม่ (วิธีการที่คุณกำหนดเอง) เป็นfor-inวงที่สามารถแบ่งสคริปต์ที่มีอยู่ ไม่กี่ปีที่ผ่านมาผู้เขียนห้องสมุดต้นแบบต้องปรับโครงสร้างการใช้งานห้องสมุดใหม่เพื่อลบสิ่งเหล่านี้ออกไป

หากคุณไม่ต้องกังวลเกี่ยวกับความเข้ากันได้กับจาวาสคริปต์อื่น ๆ ที่ใช้งานบนหน้าเว็บของคุณให้ลองใช้งานมิฉะนั้นฉันจะแนะนำวิธีแก้ปัญหาฟังก์ชั่นยืนฟรีที่ปลอดภัยกว่า

หนึ่งในสายการบิน:

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

คิดนอกกรอบสักครู่ถ้าคุณโทรมาหลายครั้งมันจะมีประสิทธิภาพมากกว่าในการใช้อาเรย์แบบเชื่อมโยง Map เพื่อทำการค้นหาโดยใช้ฟังก์ชันแฮช

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

ฉันใช้สิ่งต่อไปนี้:

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 ()ถูกเพิ่มเข้าในมาตรฐาน ECMA-262 ในรุ่นที่ 5

หวังว่าแบบสองทิศทางindexOf/ lastIndexOfทางเลือกที่เร็วขึ้น

2015

ในขณะที่วิธีการใหม่รวมถึงดีมากการสนับสนุนเป็นศูนย์สำหรับตอนนี้

เป็นเวลานานที่ฉันคิดถึงวิธีที่จะแทนที่ฟังก์ชัน indexOf / lastIndexOf ที่ช้า

พบวิธีที่นักแสดงแล้วดูคำตอบยอดนิยม จากที่ฉันเลือกcontainsฟังก์ชั่นที่โพสต์โดย @Damir Zekic ซึ่งน่าจะเร็วที่สุด แต่มันก็ยังระบุว่ามาตรฐานมาจากปี 2008 และล้าสมัย

ฉันชอบwhileมากกว่าforแต่ไม่ใช่เหตุผลเฉพาะที่ฉันสิ้นสุดการเขียนฟังก์ชันด้วย for for loop while --มันอาจจะทำยังกับ

ฉันสงสัยว่าการวนซ้ำนั้นช้ากว่านี้มากไหมถ้าฉันตรวจสอบทั้งสองด้านของอาเรย์ขณะทำ เห็นได้ชัดว่าไม่และฟังก์ชั่นนี้เร็วกว่าฟังก์ชั่นโหวตสูงสุดสองเท่า เห็นได้ชัดว่ามันเร็วกว่าของพื้นเมือง สิ่งนี้ในสภาพแวดล้อมจริงที่คุณไม่เคยรู้ว่าคุณค่าที่คุณกำลังค้นหานั้นอยู่ที่จุดเริ่มต้นหรือจุดสิ้นสุดของอาร์เรย์

เมื่อคุณรู้ว่าคุณเพิ่งผลักอาร์เรย์ที่มีค่าการใช้ lastIndexOf ยังคงเป็นทางออกที่ดีที่สุด แต่ถ้าคุณต้องเดินทางผ่านอาร์เรย์ขนาดใหญ่และผลลัพธ์อาจอยู่ทุกหนทุกแห่ง

แบบสองทิศทาง 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');

การทดสอบประสิทธิภาพ

http://jsperf.com/bidirectionalindexof

เมื่อทดสอบฉันสร้างอาร์เรย์ที่มีรายการ 100k

สามข้อความค้นหา: ที่จุดเริ่มต้นตรงกลาง & ท้ายอาร์เรย์

ฉันหวังว่าคุณจะพบสิ่งที่น่าสนใจและทดสอบประสิทธิภาพ

หมายเหตุ: อย่างที่คุณเห็นฉันปรับเปลี่ยนcontainsฟังก์ชั่นเล็กน้อยเพื่อสะท้อนเอาท์พุท indexOf & lastIndexOf (โดยพื้นฐานแล้วtrueด้วยindexและfalseด้วย-1) ไม่ควรทำอันตราย

ชุดต้นแบบอาร์เรย์

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

ฟังก์ชั่นนี้ยังสามารถแก้ไขได้อย่างง่ายดายเพื่อคืนค่าจริงหรือเท็จหรือแม้กระทั่งวัตถุสตริงหรืออะไรก็ตาม

และนี่คือwhileตัวแปร:

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

เป็นไปได้อย่างไร?

ฉันคิดว่าการคำนวณอย่างง่ายเพื่อให้ได้ดัชนีที่สะท้อนในอาเรย์นั้นง่ายมากซึ่งเร็วกว่าการวนซ้ำจริงสองเท่า

นี่คือตัวอย่างที่ซับซ้อนที่ทำการตรวจสอบสามครั้งต่อการวนซ้ำ แต่เป็นไปได้เฉพาะกับการคำนวณที่นานขึ้นซึ่งทำให้โค้ดช้าลง

http://jsperf.com/bidirectionalindexof/2

ประสิทธิภาพ

วันนี้ 2020.01.07 ฉันทำการทดสอบบน MacOs HighSierra 10.13.6 บน Chrome v78.0.0, Safari v13.0.4 และ Firefox v71.0.0 สำหรับ 15 โซลูชั่นที่เลือก สรุปผลการวิจัย

• ขึ้นอยู่กับการแก้ปัญหาJSON, Setและที่น่าแปลกใจfind(K, N, O) เป็นที่ช้าที่สุดบนเบราว์เซอร์
• es6 includes(F) เร็วเพียงกับโครเมียมเท่านั้น
• โซลูชันที่ใช้for(C, D) และindexOf(G, H) นั้นค่อนข้างเร็วสำหรับเบราว์เซอร์ทั้งหมดในอาร์เรย์ขนาดเล็กและขนาดใหญ่ดังนั้นอาจเป็นตัวเลือกที่ดีที่สุดสำหรับโซลูชันที่มีประสิทธิภาพ
• การแก้ปัญหาที่ดัชนีลดลงในช่วงห่วง (B) จะช้าอาจจะเป็นเพราะทางของCPU งานแคช
• ฉันยังรันการทดสอบอาร์เรย์ขนาดใหญ่เมื่อองค์ประกอบการค้นหาอยู่ในตำแหน่ง 66% ของความยาวอาร์เรย์และโซลูชันที่อิงตามfor(C, D, E) ให้ผลลัพธ์ที่คล้ายกัน (~ 630 ops / วินาที - แต่ E บนซาฟารีและ Firefox คือ 10- ช้ากว่า C และ D 20%

ผล

รายละเอียด

ฉันทำการทดสอบ 2 กรณี: สำหรับอาเรย์ที่มี 10 องค์ประกอบและอาเรย์ที่มี 1 milion องค์ประกอบ ในทั้งสองกรณีเราใส่อิลิเมนต์การค้นหาในอาร์เรย์กลาง

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 ขนาดเล็ก - 10 องค์ประกอบ

คุณสามารถทำการทดสอบในเครื่องของคุณที่นี่

Array ใหญ่ - 1,000,000 องค์ประกอบ

คุณสามารถทำการทดสอบในเครื่องของคุณที่นี่

หากคุณกำลังใช้ JavaScript 1.6 หรือสูงกว่า (Firefox 1.5 หรือใหม่กว่า) คุณสามารถใช้Array.indexOf มิฉะนั้นฉันคิดว่าคุณกำลังจะจบลงด้วยสิ่งที่คล้ายกับรหัสต้นฉบับของคุณ

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

ส่งคืนดัชนีอาร์เรย์ถ้าพบหรือ -1 ถ้าไม่พบ

เราใช้ตัวอย่างนี้ (ทำงานกับวัตถุ, อาร์เรย์, สตริง):

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

การใช้งาน:

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

หากคุณกำลังตรวจสอบซ้ำ ๆ ว่ามีวัตถุอยู่ในอาเรย์คุณควรตรวจสอบ

1. รักษาอาร์เรย์ที่เรียงตลอดเวลาโดยทำการเรียงลำดับการแทรกในอาร์เรย์ของคุณ (ใส่วัตถุใหม่ในสถานที่ที่เหมาะสม)
2. ทำให้การอัปเดตวัตถุเป็นลบ + ดำเนินการแทรกเรียงและ
3. ใช้ค้นหา binarycontains(a, obj)ค้นหาในของคุณ

โซลูชันที่ใช้งานได้ในเบราว์เซอร์สมัยใหม่ทั้งหมด:

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

การใช้งาน:

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

โซลูชัน 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;
  };
}

การใช้งาน:

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

ทำไมต้องใช้JSON.stringify?

Array.indexOfและArray.includes(รวมถึงคำตอบส่วนใหญ่ที่นี่) เปรียบเทียบโดยอ้างอิงเท่านั้นและไม่ใช่มูลค่า

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

โบนัส

ES6 แบบหนึ่งซับที่ไม่เหมาะ:

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

หมายเหตุ: การเปรียบเทียบออบเจ็กต์ตามค่าจะทำงานได้ดีขึ้นหากคีย์อยู่ในลำดับเดียวกันดังนั้นเพื่อความปลอดภัยคุณอาจเรียงลำดับคีย์ก่อนด้วยแพ็คเกจเช่นนี้: https://www.npmjs.com/package/sort-keys

อัปเดตcontainsฟังก์ชั่นด้วยการเพิ่มประสิทธิภาพที่สมบูรณ์แบบ ขอบคุณมากสำหรับการชี้ให้เห็น

ใช้ lodash เป็นบางฟังก์ชั่น

มันกระชับถูกต้องและมีการสนับสนุนข้ามแพลตฟอร์มที่ยอดเยี่ยม

คำตอบที่ยอมรับนั้นไม่เป็นไปตามข้อกำหนด

ข้อกำหนด:แนะนำวิธีรัดกุมและมีประสิทธิภาพมากที่สุดเพื่อค้นหาว่าอาร์เรย์ JavaScript มีวัตถุหรือไม่

คำตอบที่ยอมรับ:

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

คำแนะนำของฉัน:

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

หมายเหตุ:

$ .inArray ทำงานได้ดีในการพิจารณาว่ามีค่าสเกลาร์อยู่ในสเกลาร์หรือไม่ ...

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

... แต่คำถามนั้นถามอย่างชัดเจนถึงวิธีที่มีประสิทธิภาพในการพิจารณาว่ามีวัตถุอยู่ในอาร์เรย์หรือไม่

ในการจัดการทั้งสเกลาร์และวัตถุคุณสามารถทำได้:

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

ECMAScript 6 มีข้อเสนอสุดหรูในการค้นหา

เมธอด find เรียกใช้งานฟังก์ชัน callback หนึ่งครั้งสำหรับแต่ละองค์ประกอบที่มีอยู่ในอาร์เรย์จนกว่าจะพบวิธีที่ callback คืนค่าจริง หากพบองค์ประกอบดังกล่าวให้ค้นหาส่งกลับค่าขององค์ประกอบนั้นทันที มิฉะนั้นค้นหาส่งคืนไม่ได้กำหนด การเรียกกลับถูกเรียกใช้เฉพาะสำหรับดัชนีของอาร์เรย์ที่มีค่าที่กำหนดไว้เท่านั้น มันไม่ได้ถูกเรียกใช้สำหรับดัชนีที่ถูกลบไปหรือที่ไม่เคยมีการกำหนดค่า

นี่คือเอกสาร MDNที่

ฟังก์ชันการค้นหาใช้งานได้เช่นนี้

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

คุณสามารถใช้ใน ECMAScript 5 และด้านล่างโดยกำหนดฟังก์ชั่น

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

แม้ว่าarray.indexOf(x)!=-1จะเป็นวิธีที่รัดกุมที่สุดในการทำเช่นนี้ (และได้รับการสนับสนุนโดยเบราว์เซอร์ที่ไม่ใช่ Internet Explorer มานานกว่าทศวรรษ ... ) แต่ก็ไม่ใช่ O (1) แต่เป็น O (N) ซึ่งแย่มาก หากอาร์เรย์ของคุณจะไม่เปลี่ยนแปลงคุณสามารถแปลงอาร์เรย์ของคุณเป็น hashtable จากนั้นทำtable[x]!==undefinedหรือ===undefined:

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

การสาธิต:

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

(น่าเสียดายที่ในขณะที่คุณสามารถสร้าง Array.prototype.contain เพื่อ "หยุด" อาร์เรย์และเก็บ hashtable ใน this._cache ในสองบรรทัดนี้จะให้ผลลัพธ์ที่ผิดถ้าคุณเลือกที่จะแก้ไขอาร์เรย์ของคุณในภายหลัง JavaScript มี hooks ไม่เพียงพอที่จะ ให้คุณรักษาสถานะนี้ไม่เหมือนกับ Python)

หนึ่งสามารถใช้ชุดที่มีวิธีการ "มี ()":

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

ใช้:

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

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

การสาธิต

หากต้องการทราบว่าสิ่งที่tilde ~ต้องทำ ณ จุดนี้ให้อ้างอิงคำถามนี้ตัวหนอนจะทำอะไรเมื่อมันนำหน้านิพจน์ .

ตกลงคุณสามารถเพิ่มประสิทธิภาพรหัสของคุณเพื่อรับผล!

มีหลายวิธีในการทำสิ่งนี้ที่สะอาดกว่าและดีกว่า แต่ฉันแค่อยากได้รูปแบบของคุณและนำไปใช้กับสิ่งนั้นโดยใช้JSON.stringifyเพียงแค่ทำสิ่งนี้ในกรณีของคุณ:

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

ไม่ได้ดีที่สุด แต่ฉันเพิ่งได้รับความคิดสร้างสรรค์และเพิ่มไปยังเพลง

ห้ามใช้สิ่งนี้

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

แปลกใจที่คำถามนี้ยังไม่มีการเพิ่มไวยากรณ์ล่าสุดเพิ่ม 2 เซนต์ของฉัน

สมมติว่าเรามีอาเรย์ของ Objects arrObj และเราต้องการค้นหา obj ในนั้น

Array.prototype indexOf -> (return index หรือ -1 ) โดยทั่วไปจะใช้สำหรับการค้นหาดัชนีขององค์ประกอบในอาร์เรย์ นอกจากนี้ยังสามารถใช้สำหรับการค้นหาวัตถุ แต่ใช้ได้เฉพาะเมื่อคุณส่งการอ้างอิงไปยังวัตถุเดียวกัน

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 รวม -> (ส่งคืนจริงหรือเท็จ )

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 -> (รับการเรียกกลับส่งคืนค่าแรก/ วัตถุที่ส่งกลับค่าจริงใน 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 -> (รับการเรียกกลับส่งคืนดัชนีของค่า / วัตถุแรกที่ส่งคืนจริงใน 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

เนื่องจาก find และ findIndex รับการเรียกกลับเราสามารถดึงวัตถุใด ๆ (แม้ว่าเราจะไม่มีการอ้างอิง) จากอาร์เรย์โดยการตั้งค่าเงื่อนไขที่สร้างสรรค์อย่างสร้างสรรค์

วิธีแก้ปัญหาอย่างง่ายสำหรับข้อกำหนดนี้คือการใช้ find()

หากคุณมีวัตถุหลายอย่างดังต่อไปนี้

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

จากนั้นคุณสามารถตรวจสอบว่าวัตถุที่มีค่าของคุณมีอยู่แล้วหรือไม่

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

หากข้อมูลเป็นโมฆะจะไม่มีผู้ดูแลระบบมิฉะนั้นจะส่งคืนออบเจ็กต์ที่มีอยู่ด้านล่าง

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

จากนั้นคุณสามารถค้นหาดัชนีของวัตถุนั้นในอาร์เรย์และแทนที่วัตถุโดยใช้รหัสด้านล่าง

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

คุณจะได้รับค่าเช่นด้านล่าง

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

หวังว่าสิ่งนี้จะช่วยให้ทุกคน