كيف يمكنني التحقق مما إذا كانت المصفوفة تتضمن كائنًا في JavaScript؟

Question

ما هي الطريقة الأكثر إيجازًا وفعالية لمعرفة ما إذا كانت مصفوفة JavaScript تحتوي على كائن؟

هذه هي الطريقة الوحيدة التي أعرفها للقيام بذلك:

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

هل هناك طريقة أفضل وأكثر إيجازًا لتحقيق ذلك؟

يرتبط هذا ارتباطًا وثيقًا بسؤال Stack Overflow أفضل طريقة للعثور على عنصر في JavaScript Array؟ الذي يتناول العثور على الكائنات في صفيف باستخدام indexOf.

Answer 1

المتصفحات الحالية لديها Array#includes, ، وهو ما يفعل بالضبط الذي - التي، يتم دعمه على نطاق واسع, ، وله polyfill للمتصفحات القديمة.

> ['joe', 'jane', 'mary'].includes('jane');
true 

تستطيع ايضا استخذام Array#indexOf, ، وهو أقل مباشرة، ولكنه لا يتطلب Polyfills للمتصفحات القديمة.

عروض مسج $.inArray, ، وهو ما يعادل وظيفيا Array#indexOf.

تسطير أسفل السطر.js, ، تقدم مكتبة أدوات جافا سكريبت _.contains(list, value), ، الاسم المستعار _.include(list, value), وكلاهما يستخدم دليل ل داخليًا إذا تم تمرير مصفوفة JavaScript.

تقدم بعض الأطر الأخرى طرقًا مماثلة:

• مجموعة أدوات دوجو: dojo.indexOf(array, value, [fromIndex, findLast])
• النموذج المبدئي: array.indexOf(value)
• أدوات مو: array.indexOf(value)
• موتشيكيت: findValue(array, value)
• إم إس أياكس: array.indexOf(value)
• تحويلة: Ext.Array.contains(array, value)
• لوداش: _.includes(array, value, [from]) (يكون _.contains قبل 4.0.0)
• إيكماسكريبت 2016: array.includes(value)

لاحظ أن بعض الأطر تنفذ هذا كدالة، بينما يضيف البعض الآخر الوظيفة إلى النموذج الأولي للمصفوفة.

Answer 2

تحديث:كما ذكر @orip في التعليقات، تم إجراء المعيار المرتبط في عام 2008، لذا قد لا تكون النتائج ذات صلة بالمتصفحات الحديثة.ومع ذلك، ربما تحتاج إلى هذا لدعم المتصفحات غير الحديثة على أي حال، وربما لم يتم تحديثها منذ ذلك الحين.اختبر نفسك دائمًا.

كما قال آخرون، ربما يكون التكرار عبر المصفوفة هو أفضل طريقة، لكنه كذلك وقد ثبت أن التناقص while تعد الحلقة أسرع طريقة للتكرار في JavaScript.لذلك قد ترغب في إعادة كتابة التعليمات البرمجية الخاصة بك على النحو التالي:

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

بالطبع، يمكنك أيضًا توسيع النموذج الأولي للصفيف:

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

Answer 3

indexOf ربما، ولكن هذا "جافا سكريبت تمديد ل معيار ECMA-262؛ على هذا النحو قد لا تكون موجودة في تطبيقات أخرى من معيار "

مثال:

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

مايكروسوفت يفعل <م> لا تقديم نوع من بديل لهذا، ولكن يمكنك إضافة وظائف مماثلة لصفائف في Internet Explorer (وغيرها من المتصفحات التي لا تدعم indexOf) إذا كنت تريد، وذلك <أ href = ل "http://google.com/search؟q=indexof٪20internet٪20explorer" يختلط = "noreferrer"> جوجل للبحث سريع يكشف (وعلى سبيل المثال، <وأ href = "http://soledadpenades.com/ 2007 / 17/05 / arrayindexof-في-الإنترنت إكسبلورر / "يختلط =" noreferrer "> هذا واحد ).

Answer 4

يقدم 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

حاليًا لا تزال مسودة ولكن يمكن أن تكون كذلك مملوءة لكي يعمل على جميع المتصفحات

Answer 5

وb هي القيمة، وa هو مجموعة. وتعود true أو false:

function(a, b) {
    return a.indexOf(b) != -1
}

Answer 6

والأجوبة أعلى تفترض أنواع بدائية ولكن إذا كنت ترغب في معرفة ما إذا كان مجموعة يحتوي على كائن مع بعض السمات، <وأ href = "https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / صفيف / بعض "يختلط =" noreferrer "> 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
}

* كما أشار جمس] في التعليق، اعتبارا من اليوم، سبتمبر 2018، ويدعم Array.prototype.some() تماما: <لأ href = "http://kangax.github.io/compat-table/es5/#test-Array_methods_Array. prototype.some_a_href = _https: //developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some_title=_MDN_documentation_img_src=_../mdn.png_alt=_MDN_ (Mozilla_Development_Network) _logo_width = = _15_height _13 _ / _ / a_nbsp. " يختلط = "noreferrer"> caniuse.com دعم الجدول

Answer 7

وفيما يلي جافا سكريبت 1.6 تنفيذ متوافق من 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;
        };
}

Answer 8

استخدم:

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

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

Answer 9

وتوسيع الكائن Array جافا سكريبت هو فكرة سيئة حقا لأنك إدخال خصائص جديدة (الطرق المخصصة) في حلقات for-in التي يمكن كسر البرامج النصية الموجودة. وقبل بضع سنوات كان الكتاب من مكتبة نموذج لإعادة تصميم تطبيق مكتبة لإزالة فقط هذا النوع من الشيء.

إذا كنت لا داعي للقلق حول التوافق مع جافا سكريبت أخرى تعمل على الصفحة الخاصة بك، لأنها تذهب، وإلا، أنصح أكثر صعوبة، ولكن أكثر أمنا قائمة بذاتها وظيفة حل.

Answer 10

والتفكير من خارج منطقة الجزاء لثانية واحدة، إذا كنت ترغب بجعل هذه الدعوة عدة مرات عديدة، هو إلى حد كبير أكثر كفاءة في استخدام <الإضراب> مجموعة النقابي خريطة للقيام عمليات البحث باستخدام دالة التجزئة.

https://developer.mozilla.org/ أون-US / مستندات / الانترنت / جافا سكريبت / المرجع / Global_Objects / خريطة

Answer 11

وبطانة الأول:

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

Answer 12

وأنا استخدم ما يلي:

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

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

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

Answer 13

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

تمت إضافة

Array.prototype.some () لمعيار ECMA-262 في 5th الطبعة

Answer 14

نأمل أن يكون ثنائي الاتجاه أسرع indexOf / lastIndexOf بديل

2015

بينما الطريقة الجديدة يشمل جميل جدًا، الدعم صفر في الوقت الحالي.

لقد كنت أفكر في طريقة لاستبدال وظائف IndexOf/lastIndexOf البطيئة منذ وقت طويل.

لقد تم بالفعل العثور على طريقة فعالة، من خلال النظر إلى أفضل الإجابات.ومن هؤلاء اخترت contains الوظيفة التي نشرها @Damir Zekic والتي يجب أن تكون الأسرع.لكنه ينص أيضًا على أن المعايير ترجع إلى عام 2008 وبالتالي فهي قديمة.

أنا أفضل أيضا while زيادة for, ولكن ليس لسبب محدد انتهيت من كتابة الوظيفة باستخدام حلقة for.ويمكن أن يتم ذلك أيضًا باستخدام أ while --.

كنت أشعر بالفضول لمعرفة ما إذا كان التكرار أبطأ بكثير إذا قمت بفحص جانبي المصفوفة أثناء القيام بذلك.على ما يبدو لا، وبالتالي فإن هذه الوظيفة أسرع بحوالي مرتين من الوظائف التي تم التصويت عليها في الأعلى.ومن الواضح أنها أيضًا أسرع من النسخة الأصلية.يحدث هذا في بيئة حقيقية، حيث لا تعرف أبدًا ما إذا كانت القيمة التي تبحث عنها موجودة في بداية المصفوفة أم في نهايتها.

عندما تعلم أنك دفعت للتو مصفوفة ذات قيمة، فإن استخدام lastIndexOf ربما يظل هو الحل الأفضل، ولكن إذا كان عليك السفر عبر مصفوفات كبيرة ويمكن أن تكون النتيجة في كل مكان، فقد يكون هذا حلاً قويًا لجعل الأمور أسرع.

مؤشر ثنائي الاتجاه/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

كاختبار قمت بإنشاء مصفوفة تحتوي على 100 ألف إدخال.

ثلاثة استفسارات:في بداية المصفوفة وفي وسطها وفي نهايتها.

آمل أن تجد هذا أيضًا مثيرًا للاهتمام وتختبر الأداء.

ملحوظة:كما ترون لقد قمت بتعديل طفيف 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

Answer 15

إذا كنت تستخدم جافا سكريبت 1.6 أو في وقت لاحق (فايرفوكس 1.5 أو في وقت لاحق) يمكنك استخدام <لأ href = "https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf" يختلط = " noreferrer "> Array.indexOf . وبخلاف ذلك، أعتقد أنك سوف ينتهي مع شيء مماثل إلى رمز الأصلي.

Answer 16

إذا كنت تتحقق بشكل متكرر من وجود كائن في مصفوفة، فربما ينبغي عليك النظر فيه

1. الحفاظ على فرز المصفوفة في جميع الأوقات عن طريق القيام بذلك ترتيب بالإدراج في المصفوفة الخاصة بك (ضع كائنات جديدة في المكان المناسب)
2. جعل تحديث الكائنات كعملية إزالة + إدراج مرتبة و
3. إستخدم بحث ثنائي بحث في الخاص بك contains(a, obj).

Answer 17

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

وإرجاع مؤشر مجموعة إذا وجدت، أو -1 إذا لم يتم العثور

Answer 18

نستخدم هذا المقتطف (يعمل مع الكائنات والمصفوفات والسلاسل):

/*
 * @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

Answer 19

استخدم لوداش بعض وظيفة.

إنها موجزة ودقيقة وتتمتع بدعم رائع عبر الأنظمة الأساسية.

الإجابة المقبولة لا تلبي حتى المتطلبات.

متطلبات: نوصي بالطريقة الأكثر إيجازًا وفعالية لمعرفة ما إذا كانت مصفوفة 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)

Answer 20

والحل الذي يعمل في جميع المتصفحات الحديثة:

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

---

ملحوظة: مقارنة الأشياء من حيث القيمة سوف تعمل على نحو أفضل إذا كانت المفاتيح في نفس النظام، وذلك لتكون آمنة قد فرز مفاتيح لأول مرة مع حزمة مثل هذا واحد: <لأ href = "https://www.npmjs.com/package/ نوع مفاتيح "يختلط =" noreferrer "> https://www.npmjs.com/package/sort-keys

---

وتحديث وظيفة contains مع تحسين الأداء. بفضل itinance لافتا من ذلك.

Answer 21

وعلى الرغم array.indexOf(x)!=-1 هي الطريقة الأكثر إيجازا للقيام بذلك (وتمت بدعم من المتصفحات غير الإنترنت إكسبلورر لأكثر من عشر سنوات ...)، فإنه ليس O (1)، وإنما O (N)، الذي أمر فظيع . إذا الصفيف الخاص بك لن تتغير، يمكنك تحويل مجموعة الخاص بك إلى جدول هاش، ثم لا 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.contains الى "تجميد" مجموعة وتخزين جدول هاش في this._cache في سطرين، وهذا من شأنه أن يعطي نتائج خاطئة إذا اخترت لتعديل مجموعة في وقت لاحق. جافا سكريبت لديها غير كافية السنانير لتمكنك من البقاء هذه الحالة، على عكس بيثون على سبيل المثال).

Answer 22

يحتوي ECMAScript 6 على اقتراح رائع للبحث عنه.

تنفذ طريقة البحث وظيفة رد الاتصال مرة واحدة لكل عنصر موجود في الصفيف حتى يجد واحدة حيث يعيد رد الاتصال قيمة حقيقية.إذا تم العثور على مثل هذا العنصر ، فابحث على الفور قيمة هذا العنصر.خلاف ذلك، ابحث عن عوائد غير محددة.يتم استدعاء رد الاتصال فقط لفهارس الصفيف التي حددت القيم ؛لم يتم الاحتجاج به للفهارس التي تم حذفها أو لم يتم تعيين قيم.

هنا هو وثائق 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;
    }
  });
}

Answer 23

استخدم:

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

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

تجريبي

لمعرفة بالضبط ما يفعله tilde ~ عند هذه النقطة، راجع على هذا السؤال <م> <وأ href = "https://stackoverflow.com/questions/12299665/what-does-a-tilde-do-when -IT-تسبق-على-التعبير "> ماذا تيلدا تفعل عندما تسبق تعبير؟ .

Answer 24

وهنا كيف نموذج يفعل :

/**
 *  Array#indexOf(item[, offset = 0]) -> Number
 *  - item (?): A value that may or may not be in the array.
 *  - offset (Number): The number of initial items to skip before beginning the
 *      search.
 *
 *  Returns the position of the first occurrence of `item` within the array — or
 *  `-1` if `item` doesn't exist in the array.
**/
function indexOf(item, i) {
  i || (i = 0);
  var length = this.length;
  if (i < 0) i = length + i;
  for (; i < length; i++)
    if (this[i] === item) return i;
  return -1;
}

وانظر أيضا هنا عن الكيفية التي وصل الأمر.

Answer 25

حسنًا، يمكنك فقط تحسين الخاص بك كود للحصول على النتيجة!

هناك العديد من الطرق للقيام بذلك والتي هي أنظف وأفضل، ولكنني أردت فقط الحصول على النمط الخاص بك وتطبيقه على ذلك باستخدام 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;
}

Answer 26

استخدم:

Array.prototype.contains = function(x){
  var retVal = -1;

  // x is a primitive type
  if(["string","number"].indexOf(typeof x)>=0 ){ retVal = this.indexOf(x);}

  // x is a function
  else if(typeof x =="function") for(var ix in this){
    if((this[ix]+"")==(x+"")) retVal = ix;
  }

  //x is an object...
  else {
    var sx=JSON.stringify(x);
    for(var ix in this){
      if(typeof this[ix] =="object" && JSON.stringify(this[ix])==sx) retVal = ix;
    }
  }

  //Return False if -1 else number if numeric otherwise string
  return (retVal === -1)?false : ( isNaN(+retVal) ? retVal : +retVal);
}

وأنا أعلم أنها ليست أفضل طريقة للذهاب، ولكن لأنه ليس هناك أي وسيلة IComparable الأم للتفاعل بين الكائنات، أعتقد أن هذا هو أقرب ما يمكنك الحصول على المقارنة بين اثنين من الكيانات في صفيف. أيضا، وتمتد الكائن صفيف قد لا يكون شيء من الحكمة أن تفعل، ولكن في بعض الأحيان لا بأس (إذا كنت على علم به والمفاضلة).

Answer 27

ويمكن للمرء أن استخدام تعيين له طريقة "لديه ()":

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

Answer 28

ويمكنك أيضا استخدام هذه الحيلة:

var arrayContains = function(object) {
  return (serverList.filter(function(currentObject) {
    if (currentObject === object) {
      return currentObject
    }
    else {
      return false;
    }
  }).length > 0) ? true : false
}

Answer 29

1. إما استخدام Array.indexOf(Object).
2. مع ECMA 7 يمكن للمرء استخدام Array.includes(Object).

3. مع ECMA 6 يمكنك استخدامه Array.find(FunctionName) أين FunctionName هي وظيفة محددة المستخدم للبحث عن الكائن في الصفيف.

   أتمنى أن يساعدك هذا!

Answer 30

وشيء مماثل: يجد العنصر الأول من قبل "لامدا البحث":

Array.prototype.find = function(search_lambda) {
  return this[this.map(search_lambda).indexOf(true)];
};

والاستعمال:

[1,3,4,5,8,3,5].find(function(item) { return item % 2 == 0 })
=> 4

ونفس في coffeescript:

Array.prototype.find = (search_lambda) -> @[@map(search_lambda).indexOf(true)]