javascript - हरण - हिंदी में जावास्क्रिप्ट परिचय




जावास्क्रिप्ट ऑब्जेक्ट्स की सरणी में आईडी द्वारा ऑब्जेक्ट पाएं (19)

देशी 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

मुझे एक सरणी मिली है:

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

मैं सरणी की संरचना को बदलने में असमर्थ हूं। मुझे 45 की एक आईडी पारित की जा रही है, और मैं सरणी में उस ऑब्जेक्ट के लिए 'bar' प्राप्त करना चाहता हूं।

मैं जावास्क्रिप्ट में या jQuery का उपयोग करके यह कैसे करूं?


JQuery की फ़िल्टर विधि का प्रयोग करें:

 $(myArray).filter(function()
 {
     return this.id == desiredId;
 }).first();

वह निर्दिष्ट आईडी के साथ पहला तत्व वापस करेगा।

यह एक अच्छा सी # LINQ दिखने प्रारूप का लाभ भी है।


आप फिल्टर का उपयोग कर सकते हैं,

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

get_my_obj = getById(73, myArray);

आप शुगरज को http://sugarjs.com/ से आज़मा सकते हैं।

Arrays पर एक बहुत प्यारी विधि है, .find । तो आप इस तरह एक तत्व पा सकते हैं:

array.find( {id: 75} );

आप एक और वस्तु को "जहां-खंड" जोड़ने के लिए अधिक गुणों के साथ पास कर सकते हैं।

ध्यान दें कि शुगरज मूल वस्तुओं को फैलाता है, और कुछ लोग इस बहुत बुराई पर विचार करते हैं ...


उपयोग:

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

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

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

यह आईडी द्वारा एक वस्तु वापस करना चाहिए।


उपरोक्त 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');

कम से कम,

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

किसी ऑब्जेक्ट प्रारूप के साथ ऑब्जेक्ट्स की सरणी होने के लिए "axesOptions" पर विचार करें {: field_type => 2, फ़ील्ड => [1,3,4]}

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

जैसा कि आप पहले से ही jQuery का उपयोग कर रहे हैं, आप grep फ़ंक्शन का उपयोग कर सकते हैं जिसका उद्देश्य सरणी खोजना है:

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

परिणाम मिली वस्तुओं के साथ एक सरणी है। यदि आप जानते हैं कि ऑब्जेक्ट हमेशा होता है और यह केवल एक बार होता है, तो आप मूल्य प्राप्त करने के लिए result[0].foo का उपयोग कर सकते हैं। अन्यथा आपको परिणामस्वरूप सरणी की लंबाई जांचनी चाहिए। उदाहरण:

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

निम्नलिखित कोशिश करें

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

मुझे वास्तव में हारून डिगुल्ला द्वारा प्रदान किया गया जवाब पसंद आया लेकिन मुझे वस्तुओं की अपनी सरणी रखने की आवश्यकता थी ताकि मैं बाद में इसे फिर से चला सकूं। तो मैंने इसे संशोधित किया

	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


यदि आप इसे कई बार करते हैं, तो आप एक मानचित्र (ES6) सेट अप कर सकते हैं:

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

फिर आप बस कर सकते हैं:

map.get(27).foo

यह समाधान सहायक भी हो सकता है:

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 तरह बनाया है और यदि एक ऑब्जेक्ट पता चला है, तो फ़ंक्शन किसी सरणी के बजाय ऑब्जेक्ट वापस कर देगा।


यहां बताया गया है कि मैं शुद्ध जावास्क्रिप्ट में इसके बारे में कैसे जाउंगा, सबसे कम तरीके से मैं ईसीएमएस्क्रिप्ट 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'

स्वीकृत उत्तर पर बिल्डिंग:

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

Underscore.js के लिए एक अच्छी विधि है:

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

ईसीएमएस्क्रिप्ट 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);

यह बाहरी पुस्तकालयों के बिना काम करता है। लेकिन यदि आप पुराने ब्राउज़र समर्थन चाहते हैं तो आप इस पॉलीफिल को शामिल करना चाहेंगे।


Aggaton के जवाब से शुरू, यह एक ऐसा कार्य है जो वास्तव में वांछित तत्व (या null नहीं मिला) देता है, array और callback फ़ंक्शन देता है जो "सही" तत्व के लिए एक वास्तविक मूल्य देता है:

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

यह वास्तव में तेज़ और अधिक कॉम्पैक्ट है। लेकिन अगर आप पहिया को फिर से शुरू नहीं करना चाहते हैं, तो मैं अंडरस्कोर या लॉनाश जैसी उपयोगिता लाइब्रेरी का उपयोग करने का सुझाव देता हूं।


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

एमडीएन से:

find() विधि सरणी में एक मान देता है, यदि सरणी में कोई तत्व प्रदत्त परीक्षण फ़ंक्शन को संतुष्ट करता है। अन्यथा undefined वापस आ गया है।

यदि आप मिलान करने वाले तत्वों की एक सरणी प्राप्त करना चाहते हैं, तो इसके बजाय filter() विधि का उपयोग करें:

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

यह वस्तुओं की एक सरणी वापस कर देगा। यदि आप foo गुणों की एक सरणी प्राप्त करना चाहते हैं, तो आप इसे map() विधि के साथ कर सकते हैं:

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

साइड नोट: find() या filter() , और तीर फ़ंक्शंस जैसे तरीके पुराने ब्राउज़र (जैसे IE) द्वारा समर्थित नहीं हैं, इसलिए यदि आप इन ब्राउज़रों का समर्थन करना चाहते हैं, तो आपको Babel का उपयोग करके अपना कोड ट्रांसफ़िल करना चाहिए।





javascript-objects