Nesneler içeren bir dizinin dizinini almanın en iyi yöntemi nedir?

Bu senaryoyu düşünün:

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

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

Şimdi , bu örnekte indexOfhangi helloözelliğin olduğu nesneye sahip 'stevie'olmak istiyorum 1.

JavaScript ile oldukça yeni başlıyorum ve basit bir yöntem olup olmadığını veya bunu yapmak için kendi işlevimi oluşturmak gerekir bilmiyorum.

Harita işlevini kullanarak tek bir satırda çözebileceğinizi düşünüyorum :

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

Array.prototype.findIndex , IE (kenar dışı) dışındaki tüm tarayıcılarda desteklenir. Ancak sağlanan çoklu dolgu güzel.

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

Harita ile çözüm tamam. Ancak her aramada tüm diziyi yineliyorsunuz. Bu sadece bir eşleşme bulunduğunda tekrarlamayı durduran findIndex için en kötü durumdur .

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

veya bir işlev olarak:

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

Sadece bazı notlar:

1. Dizilerdeki döngülerde kullanmayın
2. "İğnenizi" bulduğunuzda döngüden çıktığınızdan veya işlevden çıktığınızdan emin olun.
3. Nesne eşitliğine dikkat edin

Örneğin,

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

ES2015'te bu oldukça kolaydır:

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

veya büyük diziler için muhtemelen daha iyi performansla:

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'nun cevabını seviyorum, ancak Array # indexOf ve Array # haritası tüm tarayıcılarda çalışmıyor. Alt çizgi mevcutsa yerel kodu kullanır, ancak yedekleri de vardır. Ayrıca, Pablo'nun anonim harita yönteminin tam olarak ne yaptığını yapmak için pluck yöntemine sahiptir.

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

Veya prototip oluşturun:

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

Kısa

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

Kullanım Durumları:

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

Herkesin kendi kendine çalıştırabileceği çeşitli cevapların bazı performans testlerini yaptım:

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

Chrome'daki ilk testlerime dayanarak, aşağıdaki yöntem (bir prototipin içinde for for döngüsü kullanarak) en hızlı yöntemdir:

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

Bu kod Nathan Zaetta'nın cevabının biraz değiştirilmiş bir versiyonudur.

Performans ölçütlerinde, 1000 nesne dizisinin ortası (dizin 500) ve en sonunda (dizin 999) olması ve denemeyi dizideki son öğe olarak koysam bile (yani dizideki her öğeyi bulmadan önce döngü yapması gerekir) yine de en hızlı şekilde sonuçlanır.

Bu çözüm aynı zamanda tekrar tekrar yürütmek için en çok sıradan olanı olma avantajına sahiptir, çünkü sadece son satırın tekrarlanması gerekir:

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

Birkaç yöntemi karşılaştırdım ve bu sorunu çözmenin en hızlı yoluyla bir sonuç aldım. Bu bir fordöngü. Diğer yöntemlerden 5 kat daha hızlıdır.

Testin sayfası: https://jsbench.me/9hjewv6a98

Buradaki diğer cevapların çoğu geçerlidir. Bazen, kullanacağınız yere yakın kısa bir basit işlev yapmak en iyisidir.

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

Sizin için neyin önemli olduğuna bağlıdır. Kod satırlarını kaydedebilir ve bir astar kullanmak veya çeşitli kenar durumlarını kapsayan bir yere genel bir çözüm koymak çok akıllı olabilir. Ancak bazen, gelecekteki geliştiricilerin ekstra ters mühendislik çalışması yapmasını bırakmak yerine, "burada böyle yaptım" demek daha iyidir. Özellikle kendinizi sorunuzdaki gibi bir "acemi" olarak görüyorsanız.

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

Dikkat et [0].

Cevabında olduğu reducegibi kullanmak uygun Antonio Laguna.

Kısa özür dileriz ...

Nesneniz dizi içinde kullandığınız nesnelerle aynı ise, nesnenin dizinini, bir dize gibi yaptığınız gibi almanız gerekir.

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

Bunu dene:

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

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

basit:

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

Sadece pozisyon bulmakla ilgileniyorsanız @ Pablo'nun cevabına bakınız .

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

Bununla birlikte, öğeyi bulmayı dört gözle bekliyorsanız (örneğin, böyle bir şey yapmayı düşünüyorsanız myArray[pos]), bunu kullanmanın daha etkili bir tek satır yolu vardır filter.

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

Performans sonuçlarına bakın (~ +% 42 ops / sn): http://jsbench.github.io/#7fa01f89a5dc5cc3bee79abfde80cdb3

Bu örneğe bakın: http://jsfiddle.net/89C54/

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

Sıfırla saymaya başlar.

Aşağıdaki kod ve herhangi bir nesne için çalışır kontrol etmek için genel bir işlev yaptık

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

İlk uyarı -1 döndürür (eşleşme bulunamadı anlamına gelir) ve ikinci uyarı 0 döndürür (eşleşme bulunur anlamına gelir).

Kullanım _.findIndexgelen underscore.js kütüphanesinden

İşte örnek _.findIndex([{a:1},{a: 2,c:10},{a: 3}], {a:2,c:10}) //1

ES6 findIndexyöntemini kullanarak, lodash veya başka bir kitaplık olmadan şunları yazabilirsiniz:

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

Bu, nesnenin anlık özelliklerini karşılaştırır, ancak özelliklere geri dönmez.

Uygulamanız findIndexhenüz sağlamazsa (çoğu sağlamaz), bu aramayı destekleyen hafif bir çoklu dolgu ekleyebilirsiniz:

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

( bu dupe'deki cevabımdan )

Array.prototype.findIndex()Temel olarak yerel ve kullanışlı bir işlev kullanabilirsiniz :

Dizideki bir öğe sağlanan test işlevini karşılıyorsa, findIndex () yöntemi dizideki bir dizini döndürür. Aksi takdirde -1 döndürülür.

Internet Explorer, Opera ve Safari'de desteklenmediğini ancak aşağıdaki bağlantıda sağlanan bir Çoklu Dolgu kullanabilirsiniz.

Daha fazla bilgi:

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

Arasında Furthor @Monika Garg cevap kullanabileceğiniz findIndex()(bir yoktur polyfill unsupprted tarayıcılar için).

İnsanların bu cevabı düşürdüğünü gördüm ve umarım bunu yanlış sözdizimi nedeniyle yapmışlardır, çünkü bence bu en zarif yoldur.

Dizideki bir öğe sağlanan test işlevini karşılıyorsa, findIndex () yöntemi dizideki bir dizini döndürür. Aksi takdirde -1 döndürülür.

Örneğin:

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

Nesnenin dizinini dizide bulmanın yolu budur

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

Bu özel kod olmadan çalışır

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

Not: Bu gerçek dizini vermez, yalnızca nesnenizin geçerli veri yapısında bulunduğunu söyler

Sadece kullanabilirsiniz

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

Alt çizgi yok, hayır, sadece bir indirim.

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

Bunu yapmak için kendi prototipinizi oluşturabilirsiniz:

gibi bir şey:

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

findIndex()Yöntemi kullanmayı tercih edeceğim :

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

index size endeks numarasını verecektir.