배열이 있습니다.

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

배열의 구조를 변경할 수 없습니다. id가 전달되고 배열에서 해당 객체 45를 얻고 싶습니다 'bar'.

JavaScript 또는 jQuery를 사용하여이 작업을 어떻게 수행합니까?

find()방법을 사용하십시오 :

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

에서 MDN :

find()있어서, 상기 어레이의 제 1 값을 반환 배열에 만족하는 요소가 제공하는 기능을 테스트하는 경우. 그렇지 않으면 undefined반환됩니다.

대신 인덱스 를 찾으려면 다음을 사용하십시오 findIndex().

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

에서 MDN :

이 findIndex()메소드는 제공된 테스트 기능을 만족하는 배열에서 첫 번째 요소의 색인을 리턴합니다. 그렇지 않으면 -1이 반환됩니다.

일치하는 요소의 배열을 얻으려면 filter()대신 메소드를 사용하십시오 .

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

이것은 객체의 배열을 반환합니다. foo속성 배열을 얻으려면 다음 map()방법 으로이 작업을 수행 할 수 있습니다 .

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

참고 사항 : find()또는 filter()과 같은 메소드 및 화살표 기능 은 IE와 같은 구형 브라우저에서 지원되지 않으므로 이러한 브라우저를 지원하려면 Babel ( polyfill 포함 )을 사용하여 코드를 변환해야합니다 .

이미 jQuery를 사용하고 있으므로 배열을 검색하기위한 grep 함수를 사용할 수 있습니다 .

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

결과는 찾은 항목이있는 배열입니다. 객체가 항상 존재하고 한 번만 발생한다는 것을 알고 있으면 result[0].foo값을 얻는 데 사용할 수 있습니다 . 그렇지 않으면 결과 배열의 길이를 확인해야합니다. 예:

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
}

또 다른 해결책은 조회 오브젝트를 작성하는 것입니다.

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

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

많은 조회를 수행해야하는 경우 특히 흥미 롭습니다.

ID와 객체가 공유되므로 더 많은 메모리가 필요하지 않습니다.

ECMAScript 2015 는 배열 에서 find () 메소드를 제공합니다.

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

외부 라이브러리없이 작동합니다. 그러나 이전 브라우저 지원 을 원할 경우이 polyfill 을 포함시킬 수 있습니다 .

Underscore.js 에는 다음과 같은 좋은 방법이 있습니다.

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

가장 쉬운 방법은 다음과 같지만 Internet Explorer 8 (또는 그 이전 버전)에서는 작동하지 않습니다.

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

다음을 시도하십시오

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]

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

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

실례 : http://jsfiddle.net/hunter/Pxaua/

필터를 사용할 수 있습니다.

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

get_my_obj = getById(73, myArray);

여기에는 많은 정답이 있지만, 그 중 다수는 이것이 한 번 이상 수행되는 경우 불필요하게 비싼 작업이라는 사실을 다루지 않습니다. 극단적 인 경우 실제 성능 문제의 원인 일 수 있습니다.

실제 환경에서 많은 항목을 처리하고 성능이 문제가되는 경우 처음에 조회를 작성하는 것이 훨씬 빠릅니다.

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

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

그런 다음 고정 시간에 다음과 같이 항목을 얻을 수 있습니다.

var bar = o[id];

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

발견되면 객체 요소를 반환하고 그렇지 않으면 false

이 작업을 여러 번 수행하면 맵 (ES6)을 설정할 수 있습니다.

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

그런 다음 간단히 할 수 있습니다.

map.get(27).foo

ECMAScript 3 이상에서 작동한다고 생각할 수있는 최소한의 방식으로 순수한 JavaScript로 어떻게 진행하는지 설명합니다. 일치하는 것을 발견하자마자 반환합니다.

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'

보다 일반적이고 짧은

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

귀하의 경우에는 Ex. var element = findFromArray(myArray,'id',45)그것은 당신에게 모든 요소를 ​​줄 것입니다.

http://sugarjs.com/ 에서 Sugarjs를 사용해 볼 수 있습니다 . .

Arrays에는 매우 달콤한 방법이 있습니다 .find. 따라서 다음과 같은 요소를 찾을 수 있습니다.

array.find( {id: 75} );

다른 "where-clause"를 추가하기 위해 더 많은 속성을 가진 객체를 전달할 수도 있습니다.

Sugarjs는 기본 객체를 확장하며 일부 사람들은 이것을 매우 악하다고 생각합니다.

허용 된 답변을 바탕으로 :

jQuery :

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

또는 CoffeeScript :

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

최근에는 거대한 배열에서 문자열을 검색 해야하는 것과 똑같은 문제에 직면해야합니다.

몇 가지 검색 후 간단한 코드로 쉽게 처리 할 수 ​​있습니다.

암호:

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

참조 https://jsfiddle.net/maheshwaghmare/cfx3p40v/4/를

배열의 모든 항목을 반복하십시오. 방문하는 모든 항목에 대해 해당 항목의 ID를 확인하십시오. 일치하는 경우 반환하십시오.

당신이 단지 코덱을 원한다면 :

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
}

그리고 ECMAScript 5의 Array 메소드를 사용하는 것과 같은 것 :

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

브라우저가 ECMA-262 , 5 판 (2009 년 12 월)을 지원하는 한, 이것은 거의 한 줄짜리 작동합니다.

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

배열에 내장 된 "필터"기능을 사용하여 순수한 JavaScript에서도이를 수행 할 수 있습니다.

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

이제 대신 "id"대신 key"45" 를 전달하면 id 45 value와 일치하는 전체 객체를 얻게됩니다.

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

Array.prototype.filter()기능을 사용하십시오 .

데모 : 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
  }
 }
];

필터

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

Jquery 메소드를 사용할 수 있습니다 $.each()/$.grep()

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

또는

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

ES6 구문을 사용하십시오.

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

또는 Lodash https://lodash.com/docs/4.17.10#filter , 밑줄 https://underscorejs.org/#filter를 사용 하십시오

Aaron Digulla가 제공 한 답변을 정말로 좋아했지만 나중에 반복 할 수 있도록 객체 배열을 유지해야했습니다. 그래서 나는 그것을 수정했다.

	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

사용하다:

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

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

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

id로 객체를 반환해야합니다.

이 솔루션도 도움이 될 수 있습니다.

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

나는 그것을 똑같이 만들었고 $.grep하나의 객체가 발견되면 함수 는 배열이 아닌 객체를 반환합니다.

aggaton 's answer 에서 시작 하여 "correct"요소에 대해 정확한 값을 반환하는 함수 와 null주어진 함수를 사용하여 원하는 요소를 실제로 반환하는 함수입니다 (또는 찾을 수없는 경우) .arraycallback

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

IE8에서 기본적으로 작동하지 않는다는 것을 기억하십시오 some. 폴리 필이 제공 될 수 있으며, 대안으로 항상 클래식 for루프가 있습니다.

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

실제로 더 빠르고 컴팩트합니다. 그러나 바퀴를 재발 명하고 싶지 않다면 밑줄이나 lodash와 같은 유틸리티 라이브러리를 사용하는 것이 좋습니다.

최단,

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

"axesOptions"는 객체 형식이 {: 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;
}