Ich habe ein Array:

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}, etc.]

Ich kann die Struktur des Arrays nicht ändern. Mir wird eine ID von übergeben 45, und ich möchte 'bar'für dieses Objekt im Array abrufen.

Wie mache ich das in JavaScript oder mit jQuery?

Verwenden Sie die find()Methode:

myArray.find(x => x.id === '45').foo;

Von MDN :

Die find()Methode gibt den ersten Wert im Array zurück, wenn ein Element im Array die bereitgestellte Testfunktion erfüllt. Andernfalls undefinedwird zurückgegeben.

Wenn Sie stattdessen den Index suchen möchten , verwenden Sie findIndex():

myArray.findIndex(x => x.id === '45');

Von MDN :

Die findIndex()Methode gibt den Index des ersten Elements im Array zurück, das die bereitgestellte Testfunktion erfüllt. Andernfalls wird -1 zurückgegeben.

Wenn Sie ein Array übereinstimmender Elemente erhalten möchten, verwenden Sie filter()stattdessen die folgende Methode:

myArray.filter(x => x.id === '45');

Dies gibt ein Array von Objekten zurück. Wenn Sie ein Array von fooEigenschaften erhalten möchten , können Sie dies mit der folgenden map()Methode tun :

myArray.filter(x => x.id === '45').map(x => x.foo);

Randnotiz: Methoden wie find()oder filter()und Pfeilfunktionen werden von älteren Browsern (wie IE) nicht unterstützt. Wenn Sie diese Browser unterstützen möchten, sollten Sie Ihren Code mit Babel (mit der Polyfüllung ) transpilieren .

Da Sie jQuery bereits verwenden, können Sie die grep- Funktion verwenden, die zum Durchsuchen eines Arrays vorgesehen ist:

var result = $.grep(myArray, function(e){ return e.id == id; });

Das Ergebnis ist ein Array mit den gefundenen Elementen. Wenn Sie wissen, dass das Objekt immer vorhanden ist und nur einmal vorkommt, können Sie es einfach verwenden result[0].foo, um den Wert abzurufen. Andernfalls sollten Sie die Länge des resultierenden Arrays überprüfen. Beispiel:

if (result.length === 0) {
  // no result found
} else if (result.length === 1) {
  // property found, access the foo property using result[0].foo
} else {
  // multiple items found
}

Eine andere Lösung besteht darin, ein Suchobjekt zu erstellen:

var lookup = {};
for (var i = 0, len = array.length; i < len; i++) {
    lookup[array[i].id] = array[i];
}

... now you can use lookup[id]...

Dies ist besonders interessant, wenn Sie viele Suchvorgänge durchführen müssen.

Dies benötigt nicht viel mehr Speicher, da die IDs und Objekte gemeinsam genutzt werden.

ECMAScript 2015 bietet die find () -Methode für Arrays:

var myArray = [
 {id:1, name:"bob"},
 {id:2, name:"dan"},
 {id:3, name:"barb"},
]

// grab the Array item which matchs the id "2"
var item = myArray.find(item => item.id === 2);

// print
console.log(item.name);

Es funktioniert ohne externe Bibliotheken. Wenn Sie jedoch Unterstützung für ältere Browser wünschen, können Sie diese Polyfüllung einschließen .

Underscore.js hat dafür eine gute Methode:

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'},etc.]
obj = _.find(myArray, function(obj) { return obj.id == '45' })

Ich denke, der einfachste Weg wäre der folgende, aber er funktioniert nicht mit Internet Explorer 8 (oder früher):

var result = myArray.filter(function(v) {
    return v.id === '45'; // Filter out the appropriate one
})[0].foo; // Get result and access the foo property

Versuche Folgendes

function findById(source, id) {
  for (var i = 0; i < source.length; i++) {
    if (source[i].id === id) {
      return source[i];
    }
  }
  throw "Couldn't find object with id: " + id;
}

myArray.filter(function(a){ return a.id == some_id_you_want })[0]

Eine generische und flexiblere Version der obigen Funktion findById:

// array = [{key:value},{key:value}]
function objectFindByKey(array, key, value) {
    for (var i = 0; i < array.length; i++) {
        if (array[i][key] === value) {
            return array[i];
        }
    }
    return null;
}

var array = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];
var result_obj = objectFindByKey(array, 'id', '45');

Sie können dies einfach mit der Funktion map () erreichen :

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];

var found = $.map(myArray, function(val) {
    return val.id == 45 ? val.foo : null;
});

//found[0] == "bar";

Arbeitsbeispiel: http://jsfiddle.net/hunter/Pxaua/

Sie können Filter verwenden,

  function getById(id, myArray) {
    return myArray.filter(function(obj) {
      if(obj.id == id) {
        return obj 
      }
    })[0]
  }

get_my_obj = getById(73, myArray);

Obwohl es hier viele richtige Antworten gibt, sprechen viele von ihnen nicht die Tatsache an, dass dies eine unnötig teure Operation ist, wenn sie mehrmals ausgeführt wird. Im Extremfall kann dies die Ursache für echte Leistungsprobleme sein.

Wenn Sie in der realen Welt viele Elemente verarbeiten und die Leistung ein Problem darstellt, ist es viel schneller, zunächst eine Suche zu erstellen:

var items = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];

var lookup = items.reduce((o,i)=>o[i.id]=o,{});

Sie können dann zu Gegenständen in fester Zeit wie folgt gelangen:

var bar = o[id];

Sie können auch eine Map anstelle eines Objekts als Lookup verwenden: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Map

Native verwenden Array.reduce

var array = [ {'id':'73' ,'foo':'bar'} , {'id':'45' ,'foo':'bar'} , ];
var id = 73;

var found = array.reduce(function(a, b){
    return (a.id==id && a) || (b.id == id && b)
});

Gibt das Objektelement zurück, wenn es gefunden wird false

Wenn Sie dies mehrmals tun, können Sie eine Karte (ES6) einrichten:

const map = new Map( myArray.map(el => [el.id, el]) );

Dann können Sie einfach tun:

map.get(27).foo

Hier ist, wie ich es in reinem JavaScript machen würde, so minimal ich mir vorstellen kann, dass dies in ECMAScript 3 oder höher funktioniert. Es wird zurückgegeben, sobald eine Übereinstimmung gefunden wurde.

var getKeyValueById = function(array, key, id) {
    var testArray = array.slice(), test;
    while(test = testArray.pop()) {
        if (test.id === id) {
            return test[key];
        }
    }
    // return undefined if no matching id is found in array
    return;
}

var myArray = [{'id':'73', 'foo':'bar'}, {'id':'45', 'foo':'bar'}]
var result = getKeyValueById(myArray, 'foo', '45');

// result is 'bar', obtained from object with id of '45'

Allgemeiner und kurzer

function findFromArray(array,key,value) {
        return array.filter(function (element) {
            return element[key] == value;
        }).shift();
}

in Ihrem Fall Ex. var element = findFromArray(myArray,'id',45)das wird dir das ganze Element geben.

Sie können Sugarjs unter http://sugarjs.com/ ausprobieren .

Es hat eine sehr süße Methode auf Arrays , .find. So können Sie ein Element wie dieses finden:

array.find( {id: 75} );

Sie können ihm auch ein Objekt mit mehr Eigenschaften übergeben, um eine weitere "where-Klausel" hinzuzufügen.

Beachten Sie, dass Sugarjs einheimische Objekte erweitert, und einige Leute halten dies für sehr böse ...

Aufbauend auf der akzeptierten Antwort:

jQuery:

var foo = $.grep(myArray, function(e){ return e.id === foo_id})
myArray.pop(foo)

Oder CoffeeScript:

foo = $.grep myArray, (e) -> e.id == foo_id
myArray.pop foo

In letzter Zeit muss ich mich dem gleichen Problem stellen, bei dem ich den String aus einem riesigen Array durchsuchen muss.

Nach einiger Suche fand ich, dass es mit einfachem Code einfach zu handhaben sein wird:

Code:

var items = mydata.filter(function(item){
    return item.word.toLowerCase().startsWith( 'gk );
})

Siehe https://jsfiddle.net/maheshwaghmare/cfx3p40v/4/

Iterieren Sie über ein Element im Array. Überprüfen Sie für jeden Artikel, den Sie besuchen, die ID dieses Artikels. Wenn es ein Match ist, geben Sie es zurück.

Wenn Sie nur den Codez wollen:

function getId(array, id) {
    for (var i = 0, len = array.length; i < len; i++) {
        if (array[i].id === id) {
            return array[i];
        }
    }
    return null; // Nothing found
}

Und dasselbe mit den Array-Methoden von ECMAScript 5:

function getId(array, id) {
    var obj = array.filter(function (val) {
        return val.id === id;
    });

    // Filter returns an array, and we just want the matching item.
    return obj[0];
}

Solange der Browser ECMA-262 , 5. Ausgabe (Dezember 2009) unterstützt, sollte dies funktionieren, fast einzeilig:

var bFound = myArray.some(function (obj) {
    return obj.id === 45;
});

Sie können dies auch in reinem JavaScript tun, indem Sie die eingebaute "Filter" -Funktion für Arrays verwenden:

Array.prototype.filterObjects = function(key, value) {
    return this.filter(function(x) { return x[key] === value; })
}

Übergeben Sie nun einfach "id" anstelle von key"45" anstelle von "und" value, und Sie erhalten das vollständige Objekt, das einer ID von 45 entspricht.

myArr.filterObjects("id", "45");

Verwenden Sie Array.prototype.filter()Funktion.

DEMO : https://jsfiddle.net/sumitridhal/r0cz0w5o/4/

JSON

var jsonObj =[
 {
  "name": "Me",
  "info": {
   "age": "15",
   "favColor": "Green",
   "pets": true
  }
 },
 {
  "name": "Alex",
  "info": {
   "age": "16",
   "favColor": "orange",
   "pets": false
  }
 },
{
  "name": "Kyle",
  "info": {
   "age": "15",
   "favColor": "Blue",
   "pets": false
  }
 }
];

FILTER

var getPerson = function(name){
    return jsonObj.filter(function(obj) {
      return obj.name === name;
    });
}

Wir können Jquery-Methoden verwenden $.each()/$.grep()

var data= [];
$.each(array,function(i){if(n !== 5 && i > 4){data.push(item)}}

oder

var data = $.grep(array, function( n, i ) {
  return ( n !== 5 && i > 4 );
});

Verwenden Sie die ES6-Syntax:

Array.find, Array.filter, Array.forEach, Array.map

Oder verwenden Sie Lodash https://lodash.com/docs/4.17.10#filter , Underscore https://underscorejs.org/#filter

Die Antwort von Aaron Digulla hat mir sehr gut gefallen, aber ich musste meine Reihe von Objekten behalten, damit ich sie später durchlaufen konnte. Also habe ich es geändert

	var indexer = {};
	for (var i = 0; i < array.length; i++) {
	    indexer[array[i].id] = parseInt(i);
	}
	
	//Then you can access object properties in your array using 
	array[indexer[id]].property

Verwenden:

var retObj ={};
$.each(ArrayOfObjects, function (index, obj) {

        if (obj.id === '5') { // id.toString() if it is int

            retObj = obj;
            return false;
        }
    });
return retObj;

Es sollte ein Objekt mit der ID zurückgeben.

Diese Lösung kann auch hilfreich sein:

Array.prototype.grep = function (key, value) {
    var that = this, ret = [];
    this.forEach(function (elem, index) {
        if (elem[key] === value) {
            ret.push(that[index]);
        }
    });
    return ret.length < 2 ? ret[0] : ret;
};
var bar = myArray.grep("id","45");

Ich habe es so gemacht, $.grepund wenn ein Objekt herausgefunden wird, gibt die Funktion das Objekt zurück und nicht ein Array.

Ausgehend von der Antwort von aggaton ist dies eine Funktion, die tatsächlich das gewünschte Element zurückgibt (oder nullwenn sie nicht gefunden wird), vorausgesetzt , arrayund eine callbackFunktion, die einen wahrheitsgemäßen Wert für das "richtige" Element zurückgibt:

function findElement(array, callback) {
    var elem;
    return array.some(function(e) {
        if (callback(e)) {
            elem = e;
            return true;
        }
    }) ? elem : null;
});

Denken Sie daran, dass dies auf IE8- nativ nicht funktioniert, da es nicht unterstützt wird some. Eine Polyfüllung kann bereitgestellt werden, alternativ gibt es immer die klassische forSchleife:

function findElement(array, callback) {
    for (var i = 0; i < array.length; i++)
        if (callback(array[i])) return array[i];
    return null;
});

Es ist tatsächlich schneller und kompakter. Wenn Sie das Rad jedoch nicht neu erfinden möchten, empfehle ich die Verwendung einer Utility-Bibliothek wie Unterstrich oder Lodash.

Kürzeste,

var theAnswerObj = _.findWhere(array, {id : 42});

Betrachten Sie "axesOptions" als Array von Objekten mit einem Objektformat von {: field_type => 2 ,: fields => [1,3,4]}

function getFieldOptions(axesOptions,choice){
  var fields=[]
  axesOptions.each(function(item){
    if(item.field_type == choice)
        fields= hashToArray(item.fields)
  });
  return fields;
}