මට පෙළක් තිබේ:

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

අරාවේ ව්‍යුහය වෙනස් කිරීමට මට නොහැකිය. මට හැඳුනුම්පතක් සම්මත කර ඇති අතර 45, 'bar'එම වස්තුව සඳහා අරාව තුළ ලබා ගැනීමට මට අවශ්‍යය .

මම මෙය ජාවාස්ක්‍රිප්ට් හි හෝ jQuery භාවිතා කරන්නේ කෙසේද?

find()ක්රමය භාවිතා කරන්න :

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

MDN වෙතින් :

මෙම find()අරාව තෘප්තිමත් තුල පවතී සපයා පරීක්ෂණ කාර්යය නම් ක්රමය, අරාව ප්රථම අගය පැමිණේ. එසේ නොමැතිනම් 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(), සහ කාර්යයන් arrow පැරණි බ්රව්සර (IE වැනි) මඟින් පහසුකම් සපයන්නේ නැත, ඒ නිසා ඔබ මේ වෙබ් බ්රව්සර සහාය කිරීමට අවශ්ය නම්, ඔබ භාවිතා කර ඔබගේ කේතය transpile යුතු බාබෙල් (සමග polyfill ).

ඔබ දැනටමත් jQuery භාවිතා කරන බැවින්, ඔබට අරාව සෙවීම සඳහා අදහස් කරන grep ශ්‍රිතය භාවිතා කළ හැකිය :

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

ප්‍රති result ලය වන්නේ සොයාගත් අයිතම සමඟ අරාවකි. වස්තුව සැමවිටම පවතින බවත් එය සිදුවන්නේ එක් වරක් පමණක් බවත් ඔබ දන්නේ නම්, ඔබට result[0].fooවටිනාකම ලබා ගැනීමට භාවිතා කළ හැකිය. එසේ නොමැතිනම් ඔබ එහි ප්‍රති ar ලයක් ලෙස ඇති අරාවේ දිග පරීක්ෂා කළ යුතුය. උදාහරණයක්:

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]...

ඔබට බොහෝ සොයා බැලීම් කිරීමට අවශ්‍ය නම් මෙය විශේෂයෙන් සිත්ගන්නා සුළුය.

හැඳුනුම්පත් සහ වස්තු බෙදාගන්නා බැවින් මේ සඳහා වැඩි මතකයක් අවශ්‍ය නොවේ.

ECMAScript 2015 අරා වල සොයා ගැනීමේ () ක්‍රමය සපයයි :

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

එය බාහිර පුස්තකාල නොමැතිව ක්‍රියා කරයි. නමුත් ඔබට පැරණි බ්‍රව්සර් සහාය අවශ්‍ය නම් ඔබට මෙම පොලිෆිල් ඇතුළත් කිරීමට අවශ්‍ය වනු ඇත .

Underscore.js ඒ සඳහා හොඳ ක්‍රමයක් ඇත:

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

මම හිතන්නේ පහසුම ක්‍රමය පහත දැක්වේ, නමුත් එය ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 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');

සිතියම් () ශ්‍රිතය භාවිතයෙන් ඔබට මෙය පහසුවෙන් ලබා ගත හැකිය :

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 හෝ ඊට පසුව ක්‍රියා කරන බව සිතිය හැකිය. තරඟයක් සොයාගත් වහාම එය නැවත පැමිණේ.

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/ වෙතින් සුගර්ජ් අත්හදා බැලිය හැකිය .

එය අරා මත ඉතා මිහිරි ක්‍රමයක් ඇත .find. එබැවින් ඔබට මෙවැනි අංගයක් සොයාගත හැකිය:

array.find( {id: 75} );

තවත් "කොහේද-වගන්තියක්" එකතු කිරීම සඳහා ඔබට වැඩි ගුණාංග සහිත වස්තුවක් යැවිය හැකිය.

සුගර්ජ් ස්වදේශික වස්තූන් විහිදුවන බව සලකන්න, සමහර අය මෙය ඉතා නපුරක් ලෙස සලකති ...

පිළිගත් පිළිතුර මත ගොඩනැගීම:

jQuery:

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

හෝ කෝපි ස්ක්‍රිප්ට්:

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/ බලන්න

අරාවෙහි ඇති ඕනෑම අයිතමයක් ගැන අනුමාන කරන්න. ඔබ පිවිසෙන සෑම අයිතමයක් සඳහාම, එම අයිතමයේ හැඳුනුම්පත පරීක්ෂා කරන්න. එය තරඟයක් නම්, එය ආපසු දෙන්න.

ඔබට තේ කෝඩෙස් අවශ්‍ය නම්:

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 හි අරා ක්‍රම භාවිතා කරන එකම දේ:

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 දෙසැම්බර්) සහය දක්වන තාක් කල් , මෙය ක්‍රියාත්මක විය යුතුය, එක් ලයිනර් පාහේ:

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

අරා සඳහා සාදන ලද “පෙරහන්” ශ්‍රිතය භාවිතා කිරීමෙන් ඔබට මෙය පිරිසිදු ජාවාස්ක්‍රිප්ට් තුළ පවා කළ හැකිය:

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

එබැවින් දැන් වෙනුවට "id" keyසහ "45" වෙනුවට සම්මත කරන්න value, එවිට ඔබට සම්පූර්ණ වස්තුව 45 හැඳුනුම්පතකට ගැලපේ. එබැවින් එය එසේ වනු ඇත.

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

නැතහොත් ලොඩාෂ් https://lodash.com/docs/4.17.10#filter , Underscore https://underscorejs.org/#filter භාවිතා කරන්න

ආරොන් ඩිගුල්ලා විසින් සපයන ලද පිළිතුරට මම සැබවින්ම කැමතියි, නමුත් මගේ වස්තූන් පෙළ තබා ගැනීමට අවශ්‍ය වූ අතර පසුව එය නැවත කියවීමට මට හැකි විය. ඒ නිසා මම එය වෙනස් කළා

	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;

එය වස්තුවක් හැඳුනුම්පත මගින් ආපසු ලබා දිය යුතුය.

මෙම විසඳුම ද ප්‍රයෝජනවත් විය හැකිය:

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අතර එක් වස්තුවක් සොයාගත හොත්, ශ්‍රිතය අරාවකට වඩා වස්තුව නැවත ලබා දෙනු ඇත.

අනෙක් අය පෙන්වා දී ඇති පරිදි, .find()ඔබේ අරාව තුළ එක් වස්තුවක් සොයන විට යා යුතු මාර්ගයයි. කෙසේ වෙතත්, මෙම ක්‍රමය භාවිතයෙන් ඔබේ වස්තුව සොයාගත නොහැකි නම්, ඔබේ වැඩසටහන බිඳ වැටෙනු ඇත:

const myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];
const res = myArray.find(x => x.id === '100').foo; // Uh oh!
/*
Error:
"Uncaught TypeError: Cannot read property 'foo' of undefined"
*/

එය .find()භාවිතා කිරීමට පෙර ප්‍රති result ලය නිර්වචනය කර ඇත්දැයි පරීක්ෂා කිරීමෙන් මෙය නිවැරදි කළ හැකිය .foo. නවීන JS අපට විකල්ප දම්වැලකින් පහසුවෙන් මෙය කිරීමට ඉඩ දෙයි undefined, ඔබේ කේතය බිඳ වැටෙනවාට වඩා වස්තුව සොයාගත නොහැකි නම් නැවත පැමිණීම :

const myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];
const res = myArray.find(x => x.id === '100')?.foo; // No error!
console.log(res); // undefined when the object cannot be found

සිට ආරම්භ aggaton පිළිතුර , මේ ඇත්තටම අවශ්යව අංගයක් (හෝ නැවත බව ශ්රිතයක් වේ nullදී ඇති, සොයාගත නොහැකි නම්) arrayසහ callbackශ්රිතයේ එම "නිවැරදි" අංගයක් සඳහා truthy අගය බව:

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

එය ඇත්ත වශයෙන්ම වේගවත් හා සංයුක්ත වේ. නමුත් ඔබට රෝදය ප්‍රතිනිර්මාණය කිරීමට අවශ්‍ය නැතිනම්, යටි ඉරි හෝ ලෝඩාෂ් වැනි උපයෝගිතා පුස්තකාලයක් භාවිතා කිරීමට මම යෝජනා කරමි.

කෙටිම,

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