วิธีที่ดีที่สุดในการรับดัชนีของอาร์เรย์ซึ่งมีวัตถุคืออะไร

ลองนึกภาพสถานการณ์นี้:

var hello = {
    hello: 'world',
    foo: 'bar'
};
var qaz = {
    hello: 'stevie',
    foo: 'baz'
}

var myArray = [];
myArray.push(hello,qaz);

ตอนนี้ฉันต้องการที่จะมีindexOfวัตถุซึ่งhelloทรัพย์สินซึ่งในตัวอย่างนี้จะเป็น'stevie'1

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

ฉันคิดว่าคุณสามารถแก้มันในหนึ่งบรรทัดโดยใช้ฟังก์ชั่นแผนที่ :

pos = myArray.map(function(e) { return e.hello; }).indexOf('stevie');

Array.prototype.findIndexรองรับเบราว์เซอร์ทั้งหมดที่ไม่ใช่ IE (ไม่ใช่ขอบ) แต่polyfillที่จัดไว้ให้เป็นสิ่งที่ดี

var indexOfStevie = myArray.findIndex(i => i.hello === "stevie");

การแก้ปัญหาด้วยแผนที่ก็โอเค แต่คุณวนซ้ำทุกการค้นหา นั่นเป็นเพียงกรณีที่แย่ที่สุดสำหรับfindIndexซึ่งจะหยุดซ้ำเมื่อพบการแข่งขัน

var searchTerm = "stevie",
    index = -1;
for(var i = 0, len = myArray.length; i < len; i++) {
    if (myArray[i].hello === searchTerm) {
        index = i;
        break;
    }
}

หรือเป็นฟังก์ชั่น:

function arrayObjectIndexOf(myArray, searchTerm, property) {
    for(var i = 0, len = myArray.length; i < len; i++) {
        if (myArray[i][property] === searchTerm) return i;
    }
    return -1;
}
arrayObjectIndexOf(arr, "stevie", "hello"); // 1

เพียงบันทึกบางส่วน:

1. อย่าใช้สำหรับ ... ในลูปในอาร์เรย์
2. อย่าลืมลูปหรือกลับออกจากฟังก์ชั่นเมื่อคุณพบ "เข็ม" ของคุณ
3. ระวังความเสมอภาคของวัตถุ

ตัวอย่างเช่น,

var a = {obj: 0};
var b = [a];
b.indexOf({obj: 0}); // -1 not found

ใน ES2015 มันค่อนข้างง่าย:

myArray.map(x => x.hello).indexOf('stevie')

หรืออาจมีประสิทธิภาพที่ดีขึ้นสำหรับอาร์เรย์ขนาดใหญ่:

myArray.findIndex(x => x.hello === 'stevie')

var idx = myArray.reduce( function( cur, val, index ){

    if( val.hello === "stevie" && cur === -1 ) {
        return index;
    }
    return cur;

}, -1 );

ฉันชอบคำตอบของ Pablo แต่แผนที่ Array # indexOf และ Array # ไม่ทำงานบนเบราว์เซอร์ทั้งหมด ขีดเส้นใต้จะใช้รหัสเนทิฟหากมี แต่มีข้อผิดพลาดเช่นกัน นอกจากนี้ยังมีวิธีการถอนเพื่อทำสิ่งที่แผนที่แบบไม่ระบุชื่อของ Pablo ทำ

var idx = _.chain(myArray).pluck("hello").indexOf("Stevie").value();

หรือต้นแบบมัน:

Array.prototype.indexOfObject = function arrayObjectIndexOf(property, value) {
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i][property] === value) return i;
    }
    return -1;
}

myArr.indexOfObject("name", "stevie");

สั้น

myArray.indexOf('stevie','hello')

ใช้กรณี:

  /*****NORMAL****/  
[2,4,5].indexOf(4) ;//OUTPUT 1
 /****COMPLEX*****/
 [{slm:2},{slm:4},{slm:5}].indexOf(4,'slm');//OUTPUT 1
 //OR
 [{slm:2},{slm:4},{slm:5}].indexOf(4,function(e,i){
   return e.slm;
});//OUTPUT 1
/***MORE Complex**/
[{slm:{salat:2}},{slm:{salat:4}},{slm:{salat:5}}].indexOf(4,function(e,i){
   return e.slm.salat;
});//OUTPUT 1

API:

    Array.prototype.indexOfOld=Array.prototype.indexOf

    Array.prototype.indexOf=function(e,fn){
      if(!fn){return this.indexOfOld(e)}
      else{ 
       if(typeof fn ==='string'){var att=fn;fn=function(e){return e[att];}}
        return this.map(fn).indexOfOld(e);
      }
    };

ฉันทำการทดสอบประสิทธิภาพของคำตอบต่าง ๆ ที่นี่ซึ่งทุกคนสามารถดำเนินการด้วยตนเองได้:

https://jsperf.com/find-index-of-object-in-array-by-contents

จากการทดสอบครั้งแรกของฉันใน Chrome วิธีต่อไปนี้ (ใช้สำหรับลูปตั้งค่าภายในต้นแบบ) เป็นวิธีที่เร็วที่สุด:

Array.prototype.indexOfObject = function (property, value) {
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i][property] === value) return i;
    }
    return -1;
}

myArray.indexOfObject("hello", "stevie");

รหัสนี้เป็นคำตอบของ Nathan Zaetta รุ่นที่แก้ไขเล็กน้อย

ในการวัดประสิทธิภาพฉันลองใช้ทั้งกับเป้าหมายที่อยู่ตรงกลาง (ดัชนี 500) และจุดสิ้นสุด (ดัชนี 999) ของอาร์เรย์วัตถุ 1,000 รายการและแม้ว่าฉันจะวางเป้าหมายเป็นรายการสุดท้ายในอาร์เรย์ (ความหมาย มันจะต้องวนซ้ำทุกรายการในอาเรย์ก่อนที่จะพบมัน) มันยังคงเร็วที่สุด

โซลูชันนี้ยังมีประโยชน์ในการเป็นหนึ่งในบทสรุปที่มากที่สุดสำหรับการดำเนินการซ้ำ ๆ เนื่องจากเฉพาะบรรทัดสุดท้ายที่ต้องทำซ้ำ:

myArray.indexOfObject("hello", "stevie");

ฉันเปรียบเทียบวิธีการหลายวิธีและได้รับผลลัพธ์ด้วยวิธีที่เร็วที่สุดในการแก้ปัญหานี้ มันเป็นforวง เร็วกว่าวิธีอื่น ๆ มากกว่า 5 เท่า

นี่คือหน้าทดสอบ: https://jsbench.me/9hjewv6a98

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

// indexOf wrapper for the list of objects
function indexOfbyKey(obj_list, key, value) {
    for (index in obj_list) {
        if (obj_list[index][key] === value) return index;
    }
    return -1;
}
// Find the string in the list (default -1)
var test1 = indexOfbyKey(object_list, 'name', 'Stevie');
var test2 = indexOfbyKey(object_list, 'last_name', 'some other name');

ขึ้นอยู่กับสิ่งที่สำคัญสำหรับคุณ มันอาจบันทึกบรรทัดของรหัสและฉลาดมากที่จะใช้หนึ่งซับหรือวางโซลูชันทั่วไปที่ไหนสักแห่งที่ครอบคลุมกรณีขอบต่าง ๆ แต่บางครั้งก็เป็นการดีกว่าที่จะพูดว่า: "ที่นี่ฉันทำแบบนี้" แทนที่จะปล่อยให้นักพัฒนาในอนาคตมีงานวิศวกรรมย้อนกลับเป็นพิเศษ โดยเฉพาะอย่างยิ่งถ้าคุณพิจารณาตัวเองว่า "มือใหม่" ในคำถามของคุณ

array.filter(function(item, indx, arr){ return(item.hello === 'stevie'); })[0];

ใจ [0] .

มันเหมาะที่จะใช้reduceเช่นเดียวกับในAntonio Lagunaคำตอบของ

ขอโทษสำหรับความกะทัดรัด ...

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

var hello = {
    hello: 'world',
    foo: 'bar'
};
var qaz = {
    hello: 'stevie',
    foo: 'baz'
}

var qazCLONE = { // new object instance and same structure
    hello: 'stevie',
    foo: 'baz'
}

var myArray = [hello,qaz];

myArray.indexOf(qaz) // should return 1
myArray.indexOf(qazCLONE) // should return -1

ลองสิ่งนี้:

console.log(Object.keys({foo:"_0_", bar:"_1_"}).indexOf("bar"));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

ง่าย:

myArray.indexOf(myArray.filter(function(item) {
    return item.hello == "stevie"
})[0])

หากคุณมีความสนใจเฉพาะลงในการหาตำแหน่งที่เห็น@ คำตอบของปาโบล

pos = myArray.map(function(e) { return e.hello; }).indexOf('stevie');

แต่ถ้าคุณกำลังมองไปข้างหน้าเพื่อหาองค์ประกอบ (เช่นหากคุณมีความคิดในการทำบางสิ่งบางอย่างเช่นนี้myArray[pos]) มีความเป็นหนึ่งบรรทัดมีประสิทธิภาพมากขึ้นfilterวิธีที่จะทำโดยใช้

element = myArray.filter((e) => e.hello === 'stevie')[0];

ดูผลลัพธ์ที่สมบูรณ์แบบ (~ + 42% ops / วินาที): http://jsbench.github.io/#7fa01f89a5dc5cc3bee79abfde80cdb3

ดูตัวอย่างนี้: http://jsfiddle.net/89C54/

for (i = 0; i < myArray.length; i++) {
    if (myArray[i].hello === 'stevie') {
        alert('position: ' + i);
        return;
    }
}

มันเริ่มนับด้วยศูนย์

ฉันได้ทำฟังก์ชั่นทั่วไปเพื่อตรวจสอบด้านล่างเป็นรหัส & ใช้งานได้กับวัตถุใด ๆ

function indexOfExt(list, item) {
    var len = list.length;

    for (var i = 0; i < len; i++) {
        var keys = Object.keys(list[i]);
        var flg = true;
        for (var j = 0; j < keys.length; j++) {
            var value = list[i][keys[j]];
            if (item[keys[j]] !== value) {
                flg = false;
            }
        }
        if (flg == true) {
            return i;
        }
    }
    return -1;
}

var items = [{ "hello": 'world', "foo": 'bar' }];
var selectedItem = { "hello": 'world', "foo": 'bar' };
alert(items.indexOf(selectedItem));
alert(indexOfExt(items, selectedItem));

การแจ้งเตือนครั้งแรกจะส่งคืน -1 (หมายถึงไม่พบการจับคู่) และการแจ้งเตือนครั้งที่สองจะส่งคืน 0 (หมายถึงการจับคู่ที่ตรงกัน)

ใช้_.findIndexจากunderscore.js ไลบรารี่

นี่คือตัวอย่าง _.findIndex([{a:1},{a: 2,c:10},{a: 3}], {a:2,c:10}) //1

ใช้findIndexเมธอด ES6 โดยไม่มี lodash หรือไลบรารี่อื่นคุณสามารถเขียน:

function deepIndexOf(arr, obj) {
  return arr.findIndex(function (cur) {
    return Object.keys(obj).every(function (key) {
      return obj[key] === cur[key];
    });
  });
}

สิ่งนี้จะเปรียบเทียบคุณสมบัติของวัตถุในทันที แต่จะไม่ถูกนำกลับไปใช้กับคุณสมบัติ

หากการใช้งานของคุณยังไม่ได้ให้บริการfindIndex(ส่วนใหญ่ยังไม่ได้) คุณสามารถเพิ่ม polyfill แบบอ่อนที่รองรับการค้นหานี้:

function deepIndexOf(arr, obj) {
  function findIndex = Array.prototype.findIndex || function (pred) {
    for (let i = 0; i < this.length; ++i) {
      if (pred.call(this, this[i], i)) {
        return i;
      }
    }

    return -1;
  }

  return findIndex.call(arr, function (cur) {
    return Object.keys(obj).every(function (key) {
      return obj[key] === cur[key];
    });
  });
}

(จากคำตอบของฉันในล่อนี้ )

คุณสามารถใช้ฟังก์ชั่นแบบเนทีฟและใช้งานง่ายArray.prototype.findIndex()โดยทั่วไป:

เมธอด findIndex () ส่งคืนดัชนีในอาร์เรย์ถ้าองค์ประกอบในอาร์เรย์เป็นไปตามฟังก์ชันการทดสอบที่ให้ไว้ มิฉะนั้นจะถูกส่งกลับ -1

เพียงทราบว่ามันไม่ได้รับการสนับสนุนใน Internet Explorer, Opera และ Safari แต่คุณสามารถใช้ Polyfill ที่ให้ไว้ในลิงค์ด้านล่าง

ข้อมูลมากกว่านี้:

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

var hello = {
  hello: 'world',
  foo: 'bar'
};
var qaz = {
  hello: 'stevie',
  foo: 'baz'
}

var myArray = [];
myArray.push(hello, qaz);

var index = myArray.findIndex(function(element, index, array) {
  if (element.hello === 'stevie') {
    return true;
  }
});
alert('stevie is at index: ' + index);

อีกต่อไปของ@Monika Garg ตอบคุณสามารถใช้findIndex()(มีpolyfillเบราว์เซอร์ unsupprted)

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

เมธอด findIndex () ส่งคืนดัชนีในอาร์เรย์ถ้าองค์ประกอบในอาร์เรย์เป็นไปตามฟังก์ชันการทดสอบที่ให้ไว้ มิฉะนั้นจะถูกส่งกลับ -1

ตัวอย่างเช่น:

var hello = {
  hello: 'world',
  foo: 'bar'
};
var qaz = {
  hello: 'stevie',
  foo: 'baz'
}

var myArray = [];
myArray.push(hello,qaz);

var index = myArray.findIndex(function(element) {
  return element.hello == 'stevie';
});

alert(index);

นี่คือวิธีการค้นหาดัชนีของวัตถุในอาร์เรย์

    var myArray = [{  hello: 'world',
        foo: 'bar'
    },{
        hello: 'stevie',
        foo: 'baz'
    }];



    for (i = 0; i < myArray.length; i++) {
        if (myArray[i].hello === 'stevie') {
            alert('position: ' + i);
            return;
        }
    }

ใช้งานได้โดยไม่มีรหัสที่กำหนดเอง

var arr, a, found;
arr = [{x: 1, y: 2}];
a = {x: 1, y: 2};
found = JSON.stringify(arr).indexOf(JSON.stringify(a)) > - 1;
// found === true

หมายเหตุ:สิ่งนี้ไม่ได้ให้ดัชนีจริงมันจะบอกเฉพาะถ้าวัตถุของคุณมีอยู่ในโครงสร้างข้อมูลปัจจุบัน

คุณสามารถใช้

const someId = 2;
const array = [{id:1}, {id:2}, {id:3}];
const index = array.reduce((i, item, index) => item.id === someId ? index : i, -1);
alert('someId ' + someId + ' is at index ' + index);

ไม่ขีดเส้นใต้ไม่มีสำหรับการลดลง

var hello = {hello: "world",  foo: "bar"};
var qaz = {hello: "stevie", foo: "baz"};
var myArray = [];
myArray.push(hello,qaz);

function indexOfObject( arr, key, value   ) {
    var j = -1;
    var result = arr.some(function(obj, i) { 
        j++;
        return obj[key] == value;
    })

    if (!result) {
        return -1;
    } else {
        return j;
    };
}

alert(indexOfObject(myArray,"hello","world"));

คุณสามารถสร้างต้นแบบของคุณเองเพื่อทำสิ่งนี้:

สิ่งที่ต้องการ:

Array.prototype.indexOfObject = function (object) {
    for (var i = 0; i < this.length; i++) {
        if (JSON.stringify(this[i]) === JSON.stringify(object))
            return i;
    }
}

ฉันต้องการใช้findIndex()วิธี:

 var index = myArray.findIndex('hello','stevie');

index จะให้หมายเลขดัชนีแก่คุณ