Respostas:
Use o find()
método:
myArray.find(x => x.id === '45').foo;
Do MDN :
O
find()
método retorna o primeiro valor na matriz, se um elemento na matriz atender à função de teste fornecida. Caso contrário,undefined
é retornado.
Se você deseja encontrar seu índice , use findIndex()
:
myArray.findIndex(x => x.id === '45');
Do MDN :
O
findIndex()
método retorna o índice do primeiro elemento na matriz que satisfaz a função de teste fornecida. Caso contrário, -1 é retornado.
Se você deseja obter uma matriz de elementos correspondentes, use o filter()
método:
myArray.filter(x => x.id === '45');
Isso retornará uma matriz de objetos. Se você deseja obter uma matriz de foo
propriedades, pode fazer isso com o map()
método:
myArray.filter(x => x.id === '45').map(x => x.foo);
Nota lateral: métodos como find()
ou filter()
, e funções de seta não são suportadas por navegadores mais antigos (como o IE); portanto, se você deseja oferecer suporte a esses navegadores, transpile seu código usando Babel (com o polyfill ).
Como você já está usando o jQuery, você pode usar a função grep que se destina a procurar uma matriz:
var result = $.grep(myArray, function(e){ return e.id == id; });
O resultado é uma matriz com os itens encontrados. Se você sabe que o objeto está sempre lá e que ocorre apenas uma vez, basta usar result[0].foo
para obter o valor. Caso contrário, você deve verificar o comprimento da matriz resultante. Exemplo:
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
}
===
vez de ==
evitar problemas estranhos com o ==
operador do JavaScript .
e.id
e id
será cordas, acho que está ok para uso ==
. Mas se você não tiver certeza, poderá enfrentar problemas (já que '' == 0
é true
mas '' === 0
é false
). Sem mencionar, ===
parece ser mais rápido ( stackoverflow.com/questions/359494/… ).
===
porque funciona exatamente como ==
em outras linguagens de programação. Considero ==
inexistente em JavaScript.
Outra solução é criar um objeto de pesquisa:
var lookup = {};
for (var i = 0, len = array.length; i < len; i++) {
lookup[array[i].id] = array[i];
}
... now you can use lookup[id]...
Isso é especialmente interessante se você precisar fazer muitas pesquisas.
Isso não precisará de muito mais memória, pois os IDs e os objetos serão compartilhados.
lookup
objeto é uma perda de tempo.
O ECMAScript 2015 fornece o método find () em matrizes:
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);
Funciona sem bibliotecas externas. Mas se você deseja suporte para navegador mais antigo, inclua esse polyfill .
myArray.find(d=>d.id===45).foo;
.
myArray.find(({ id }) => id === 45).foo
. Mas esta é uma resposta antiga que foi escrita antes da sintaxe do ES2015 ser tão suportada quanto agora. A resposta de @ Gothdo é atualmente a mais atualizada no segmento.
myArray.find(d => d.id === 45)?.foo
.
O Underscore.js tem um bom método para isso:
myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'},etc.]
obj = _.find(myArray, function(obj) { return obj.id == '45' })
Eu acho que a maneira mais fácil seria a seguinte, mas não funcionará no Internet Explorer 8 (ou anterior):
var result = myArray.filter(function(v) {
return v.id === '45'; // Filter out the appropriate one
})[0].foo; // Get result and access the foo property
for
?
for
loop direto .
for
loop será encerrado na primeira correspondência.
id
Tente o seguinte
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]
Uma versão genérica e mais flexível da função findById acima:
// 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');
Você pode obter isso facilmente usando a função map () :
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";
Exemplo de trabalho: http://jsfiddle.net/hunter/Pxaua/
map
remove automaticamente null
elementos. Parece enganador para mim e para o conceito comum de map
, pois o resultado não é do mesmo tamanho da coleção original.
Você pode usar filtros,
function getById(id, myArray) {
return myArray.filter(function(obj) {
if(obj.id == id) {
return obj
}
})[0]
}
get_my_obj = getById(73, myArray);
Embora existam muitas respostas corretas aqui, muitas delas não tratam do fato de que essa é uma operação desnecessariamente cara se for feita mais de uma vez. Em um caso extremo, isso pode ser a causa de problemas reais de desempenho.
No mundo real, se você está processando muitos itens e o desempenho é uma preocupação, é muito mais rápido criar inicialmente uma pesquisa:
var items = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];
var lookup = items.reduce((o,i)=>o[i.id]=o,{});
você pode obter itens em tempo fixo como este:
var bar = o[id];
Você também pode considerar usar um mapa em vez de um objeto como a pesquisa: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Map
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)
});
retorna o elemento do objeto se encontrado, caso contrário false
Se você fizer isso várias vezes, poderá configurar um mapa (ES6):
const map = new Map( myArray.map(el => [el.id, el]) );
Então você pode simplesmente fazer:
map.get(27).foo
Eis como eu faria isso em JavaScript puro, da maneira mais minimalista possível, que funciona no ECMAScript 3 ou posterior. Ele retorna assim que uma correspondência é encontrada.
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'
Mais genérico e curto
function findFromArray(array,key,value) {
return array.filter(function (element) {
return element[key] == value;
}).shift();
}
no seu caso Ex. var element = findFromArray(myArray,'id',45)
isso lhe dará todo o elemento.
Você pode experimentar o Sugarjs em http://sugarjs.com/ .
Ele tem um método muito bom em Arrays .find
,. Então você pode encontrar um elemento como este:
array.find( {id: 75} );
Você também pode passar um objeto com mais propriedades para adicionar outra "cláusula where".
Note que o Sugarjs estende objetos nativos, e algumas pessoas consideram isso muito ruim ...
find
. Minha sugestão é que, se você deseja estender protótipos nativos, sempre use nomes mais específicos, deixando os mais simples para futuros desenvolvimentos padrão.
Com base na resposta aceita:
jQuery:
var foo = $.grep(myArray, function(e){ return e.id === foo_id})
myArray.pop(foo)
Ou CoffeeScript:
foo = $.grep myArray, (e) -> e.id == foo_id
myArray.pop foo
Recentemente, tenho que enfrentar a mesma coisa em que preciso pesquisar a string de uma enorme variedade.
Após algumas pesquisas, achei que seria fácil lidar com um código simples:
Código:
var items = mydata.filter(function(item){
return item.word.toLowerCase().startsWith( 'gk );
})
Iterar sobre qualquer item na matriz. Para cada item que você visita, verifique o ID desse item. Se for uma correspondência, devolva-a.
Se você quer apenas o codez:
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
}
E a mesma coisa usando os métodos Array do 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];
}
Você pode fazer isso mesmo em JavaScript puro usando a função "filtro" incorporada para matrizes:
Array.prototype.filterObjects = function(key, value) {
return this.filter(function(x) { return x[key] === value; })
}
Então agora simplesmente passe "id" no lugar de key
"45" no lugar de value
, e você obterá o objeto completo correspondente a um id de 45. Portanto,
myArr.filterObjects("id", "45");
Usar Array.prototype.filter()
função
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
}
}
];
FILTRO
var getPerson = function(name){
return jsonObj.filter(function(obj) {
return obj.name === name;
});
}
.filter
método on obj.info
no loop aninhado. var getPerson = function(name){ return jsonObj.filter(function(obj) { return obj.info.filter(function(info) { return pets === false; }); }); }
Podemos usar métodos Jquery $.each()/$.grep()
var data= [];
$.each(array,function(i){if(n !== 5 && i > 4){data.push(item)}}
ou
var data = $.grep(array, function( n, i ) {
return ( n !== 5 && i > 4 );
});
use a sintaxe ES6:
Array.find, Array.filter, Array.forEach, Array.map
Ou use Lodash https://lodash.com/docs/4.17.10#filter , Sublinhado https://underscorejs.org/#filter
Eu realmente gostei da resposta fornecida por Aaron Digulla, mas precisava manter minha variedade de objetos para que pudesse iterá-la mais tarde. Então eu modifiquei para
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
Usar:
var retObj ={};
$.each(ArrayOfObjects, function (index, obj) {
if (obj.id === '5') { // id.toString() if it is int
retObj = obj;
return false;
}
});
return retObj;
Ele deve retornar um objeto por id.
Esta solução também pode ser útil:
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");
Eu fiz exatamente como $.grep
e se um objeto for descoberto, a função retornará o objeto, em vez de uma matriz.
function will return the object, rather than an array
pode cometer um erro, mas acho que depende dos usuários.
Partindo de resposta de aggaton , esta é uma função que realmente retorna o elemento queria (ou null
se não for encontrado), dada a array
e uma callback
função que retorna um valor truthy para o elemento "correta":
function findElement(array, callback) {
var elem;
return array.some(function(e) {
if (callback(e)) {
elem = e;
return true;
}
}) ? elem : null;
});
Lembre-se de que isso não funciona nativamente no IE8-, pois não suporta some
. Um polyfill pode ser fornecido; alternativamente, há sempre o for
loop clássico :
function findElement(array, callback) {
for (var i = 0; i < array.length; i++)
if (callback(array[i])) return array[i];
return null;
});
Na verdade, é mais rápido e mais compacto. Mas se você não quiser reinventar a roda, sugiro usar uma biblioteca de utilidades como sublinhado ou lodash.
Mais curto,
var theAnswerObj = _.findWhere(array, {id : 42});
Considere "axesOptions" como uma matriz de objetos com um formato de objeto {: 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;
}