वस्तु गुणों के माध्यम से Iterate

Question

var obj = {
    name: "Simon",
    age: "20",
    clothing: {
        style: "simple",
        hipster: false
    }
}

for(var propt in obj){
    console.log(propt + ': ' + obj[propt]);
}

चर proptवस्तु के गुणों का प्रतिनिधित्व कैसे करता है ? यह एक अंतर्निहित पद्धति या संपत्ति नहीं है। यह वस्तु में प्रत्येक संपत्ति के साथ क्यों आता है?

Comments

if (typeof(obj[propt]) === 'object') {/ * इसे फिर से करें * /}

— noob

खैर, इस सवाल के लिए वास्तव में खेद है। मुझे पता है कि एक लूप क्या है, मैं अपना सिर "ऑब्जेक्ट प्रॉपर्टीज के माध्यम से लूपिंग" के आसपास नहीं पा सकता था, जो मुझे लगता है कि अब साफ हो गया है। स्कूल में स्टीव Suehring - इसके अलावा, वे मेरे जावास्क्रिप्ट चरण चरण 2 संस्करण द्वारा "सिफारिश की है।

— Rafay

यह ठीक-ठाक भिखारी सवाल है। मैं जोड़ूंगा कि मेरे पास अन्य भाषाओं के साथ 15 साल का पेशेवर अनुभव है और मुझे इस उत्तर की आवश्यकता है। अगर मैं कर सकता तो मैं प्लस 2000।

— नाथन सी। टार्च

पागल है, लेकिन मैं इस पेज पर आ रहा हूं कि हर कुछ महीनों में सिंटैक्स को कैसे करना है, यह कैसे करना है। मुझे याद नहीं है कि यह कैसे करना है ... मुझे याद है कि यह पृष्ठ हमेशा एसओ पर है।

— एचडीव

यह StackOverflow पर देखा गया सबसे अजीब पृष्ठ है। यदि आप प्रश्न को ध्यान से पढ़ते हैं, तो केवल एक उत्तर में उत्तर देने का प्रयास करना शुरू हो जाता है कि वास्तव में क्या पूछा जा रहा है, और इसका स्कोर -6 है। उच्चतम स्कोरिंग उत्तर, जिसे स्वीकार किया गया था, न केवल जवाब नहीं देता है, लेकिन बस गलत है।

Answer 1

संपत्तियों पर फेरबदल के लिए इस अतिरिक्त hasOwnPropertyजाँच की आवश्यकता होती है :

for (var prop in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
        // do stuff
    }
}

यह आवश्यक है क्योंकि किसी ऑब्जेक्ट के प्रोटोटाइप में ऑब्जेक्ट के लिए अतिरिक्त गुण होते हैं जो ऑब्जेक्ट के तकनीकी रूप से भाग होते हैं। ये अतिरिक्त गुण आधार ऑब्जेक्ट वर्ग से विरासत में मिले हैं, लेकिन अभी भी के गुण हैं obj।

hasOwnProperty बस यह देखने के लिए जांचें कि क्या यह इस वर्ग के लिए विशिष्ट संपत्ति है, और आधार वर्ग से विरासत में नहीं मिला है।

---

hasOwnPropertyऑब्जेक्ट के माध्यम से कॉल करना भी संभव है:

if (obj.hasOwnProperty(prop)) {
    // do stuff
}

लेकिन यह विफल हो जाएगा यदि ऑब्जेक्ट का समान नाम के साथ कोई असंबंधित फ़ील्ड है:

var obj = { foo: 42, hasOwnProperty: 'lol' };
obj.hasOwnProperty('foo');  // TypeError: hasOwnProperty is not a function

इसलिए इसके Object.prototypeबजाय इसके माध्यम से कॉल करना अधिक सुरक्षित है :

var obj = { foo: 42, hasOwnProperty: 'lol' };
Object.prototype.hasOwnProperty.call(obj, 'foo');  // true

Comments

@BT मोज़िला प्रलेखन के अनुसार : "यदि आप केवल ऑब्जेक्ट से जुड़ी संपत्तियों पर विचार करना चाहते हैं, और इसके प्रोटोटाइप नहीं, तो getOwnPropertyNames का उपयोग करें या एक hasOwnProperty चेक प्रदर्शन करें (propertyIsnumerable भी उपयोग किया जा सकता है)।"

— davidmdem

वास्तव में कॉल करने की बात क्या है object.hasOwnProperty()? तथ्य यह है कि propertyजो कुछ भी मूल्य है कि अपने में नहीं है object?

— एलेक्स एस

क्योंकि, एलेक्स एस, एक ऑब्जेक्ट के प्रोटोटाइप में ऑब्जेक्ट के लिए अतिरिक्त गुण होते हैं जो तकनीकी रूप से ऑब्जेक्ट का हिस्सा होते हैं। उन्हें बेस ऑब्जेक्ट क्लास से विरासत में मिला है, लेकिन वे अभी भी गुण हैं। hasOwnProperty बस यह देखने के लिए जांचती है कि क्या यह इस वर्ग के लिए विशिष्ट संपत्ति है, और आधार वर्ग से विरासत में नहीं मिली है। एक अच्छी व्याख्या: brianflove.com/2013/09/05/javascripts-hasownproperty-method

— काइल रिक्टर

मुझे लगता है कि मुझे उल्लेख करना चाहिए, हालांकि, ऑब्जेक्ट का कुंजी प्राप्त करने के लिए Object.keys (obj) अब एक बेहतर समाधान है। मोज़िला दस्तावेज़ से लिंक करें: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— काइल रिक्टर

एक महत्वपूर्ण जानकारी गायब है। propertyयहां एक तार है, जिसे बुलाया जाना चाहिए था propertyName। अन्यथा अपने जैसे जेएस न्यूबाय के लिए भ्रम पैदा कर सकता है, यानी अंदर क्या करना है if।

— नियोलिस्क

Answer 2

जावास्क्रिप्ट 1.8.5 के रूप में आप Object.keys(obj)ऑब्जेक्ट पर परिभाषित गुणों का एक सरणी प्राप्त करने के लिए उपयोग कर सकते हैं (जो लोग इसके लिए सही हैं obj.hasOwnProperty(key))।

Object.keys(obj).forEach(function(key,index) {
    // key: the name of the object key
    // index: the ordinal position of the key within the object 
});

यह फॉर-इन लूप का उपयोग करने से बेहतर (और अधिक पठनीय) है।

इन ब्राउज़रों पर इसका समर्थन किया गया:

• फ़ायरफ़ॉक्स (गेको): 4 (2.0)
• क्रोम: 5
• इंटरनेट एक्सप्लोरर 9

भविष्य की जानकारी के लिए मोज़िला डेवलपर नेटवर्क Object.keys () का संदर्भ देखें।

Comments

यह अब और अधिक व्यापक रूप से समर्थित है: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— डोम विनयार्ड

और अगर आप पुराने ब्राउज़रों के लिए समर्थन की जरूरत है, तो आप इस का उपयोग कर सकते polyfill

— KyleMit

इस भाषा के निर्माण का समर्थन करने वाले वातावरण में, यह विधि Array.foreach को कॉल करने की अनुमति देती है: Object.keys(myObject).forEach(function(key,index) { //key = the name of the object key //index = the ordinal position of the key within the object });

— टोड प्राइस

@ AJ_83 एक forEach () से बाहर निकलने का कोई अच्छा तरीका नहीं है। इस मामले में कुछ () का उपयोग करें, और तोड़ने के लिए सच लौटें

— डैनियल जेड।

यह इन-फॉर-इन की तुलना में अधिक पठनीय क्यों है? for candidate in candidateStatus... मेरे लिए पठनीय लगता है

— जोना

Answer 3

लड़कियों और दोस्तों हम 2019 में हैं और हमारे पास टाइपिंग के लिए उतना समय नहीं है ... तो चलिए इस शानदार नए फैंसी ECMAScript 2016 को पूरा करते हैं:

Object.keys(obj).forEach(e => console.log(`key=${e}  value=${obj[e]}`));

Comments

यह डैनी आर के जवाब से कैसे अलग है?

— १५:३r बजे क्रिलगर ११'१

यह एक oneliner है और forEach के बजाय मानचित्र का उपयोग करता है। और यह भी सांत्वना है। कुछ लोगों के लिए slogment शायद दिलचस्प है।

— फ्रैंक रोथ

सात्विक, वह काम नहीं करता है जब obj=window.performance.memory: - / जहाँ जैसा for inहोता है। अर्थात्var obj = window.performance.memory; for( key in obj ) console.log( 'key=' + key + ' val=' + obj[key] );

— माइकलएंजेल

window.performance.memoryकेवल क्रोम द्वारा समर्थित है और Object.keys(obj)एक खाली सरणी देता है। इससे कोई लेना-देना नहीं है .map।

— फ्रैंक रोथ

यदि कोई भी इस सिंगल-लाइनर को एक बार में एक से अधिक काम करने के लिए फिर से संरचना नहीं करना चाहता है e, तो मैंने इस जिस्ट को पोस्ट किया है। यह मूल रूप से बस सबसे हैश कार्यान्वयन की तरह है, और का उपयोग करता है ( (key) => (value) )के बजाय { key => value }, लेकिन अगर आप पहले कि से निपटने के लिए नहीं किया है, यह मदद कर सकता है आप इसे कल्पना बेहतर: gist.github.com/the-nose-knows/9f06e745a56ff20519707433e28a4fa8

— kayleeFrye_onDeck

Answer 4

यह for...in statement( MDN , ECMAScript युक्ति ) है।

आप इसे पढ़ सकते हैं के रूप में " के लिए हर संपत्ति मेंobj वस्तु, प्रत्येक संपत्ति के लिए आवंटित PROPT चर बदले में"।

Comments

बहुत बहुत धन्यवाद, मैं इसे अब समझता हूं। मैं अपना सिर पीट रहा था, किताबों और गूगल से गुजर रहा था।

— रफय

@RightSaidFred, के साथ सहमत inऑपरेटर और forबयान बिल्कुल शामिल नहीं कर रहे हैं, for-inबयान : अपने आप ही एक व्याकरण उत्पादन का प्रतिनिधित्व करता है for ( LeftHandSideExpression in Expression ),for ( var VariableDeclarationNoIn in Expression )

— सीएमएस

इस उत्तर में बहुत सारे वोट हैं, खासकर जब से ये लोकप्रिय टिप्पणियां इसके विपरीत लगती हैं।

— डॉग मोलिनक्स

यह उत्तर के रूप में क्यों चिह्नित है? यह संभवतः इस धागे में सबसे कम सहायक है ..

— कम्प्यूटरीज़

कम से कम सहायक उत्तर? निर्भर करता है कि आपको क्या लगता है कि ओपी पूछ रहा था; जब मैंने पहली बार प्रश्न को पढ़ा तो ऐसा लगा कि यह उस तंत्र के बारे में चकित करने वाला है, जिसके द्वारा किसी वस्तु के गुणों का निरीक्षण करने के लिए एक चर का उपयोग किया जा सकता है, और जो इस उत्तर को स्पष्ट रूप से ('फॉर-इन' मिथ्या नाम के बावजूद) समझाता है। सवाल मैं संकेत सकता ओपी hasOwnProperty लिए देख रहा था, लेकिन यह पता नहीं है को देखने के "ऐसा क्यों है कि हर संपत्ति किस प्रकार लाता है", लेकिन मुझे लगता है कि यह अधिक संभावना है इस क्या ओपी में जानना चाहता था था, और गलत तरीके से एक सही स्वीकार कर लिया है एक अलग सवाल का जवाब। :-)

— ऊबड़

Answer 5

ES के अप-टू-डेट कार्यान्वयन में, आप उपयोग कर सकते हैं Object.entries:

for (const [key, value] of Object.entries(obj)) { }

या

Object.entries(obj).forEach(([key, value]) => ...)

यदि आप केवल मूल्यों पर पुनरावृति करना चाहते हैं, तो Object.values ​​का उपयोग करें:

for (const value of Object.values(obj)) { }

या

Object.values(obj).forEach(value => ...)

Comments

यह सबसे अच्छा समाधान (object.entries ...) होगा, लेकिन मैं इसका उपयोग नहीं कर सकता। जब आप इसे कई बार करना चाहते हैं और अपने ढांचे में इसका समर्थन नहीं कर सकते, तो आप इस पेज पर पॉलीफिल का उपयोग कर सकते हैं: developer.mozilla.org/nl/docs/Web/JavaScript/Reference/…

— मारियो

तीसरा सुझाव बहुत अच्छा है यदि आप केवल गुणों का मान रखते हैं। बहुत बढ़िया!

— गिंज़बर्ग

Answer 6

यह सिर्फ एक for...inलूप है। मोज़िला में प्रलेखन देखें ।

Answer 7

यदि आपका वातावरण ES2017 का समर्थन करता है तो मैं Object.entries की सिफारिश करूंगा :

Object.entries(obj).forEach(([key, value]) => {
  console.log(`${key} ${value}`);
});

जैसा कि Mozillas Object.entries () प्रलेखन में दिखाया गया है :

Object.entries () विधि, एक दिया वस्तु की अपनी गणनीय संपत्ति [कुंजी, मूल्य] जोड़े की एक सरणी रिटर्न द्वारा प्रदान की किसी एक ही क्रम में एक के लिए ... पाश में (अंतर किया जा रहा है कि एक के लिए में पाश विश्लेषण करता है प्रोटोटाइप श्रृंखला में गुण)।

मूल रूप से Object.entries के साथ हम निम्नलिखित अतिरिक्त कदम से गुजर सकते हैं जो पुराने के लिए आवश्यक है ... लूप में:

// This step is not necessary with Object.entries
if (object.hasOwnProperty(property)) {
  // do stuff
}

Answer 8

jquery आपको अब ऐसा करने की अनुमति देता है:

$.each( obj, function( key, value ) {
  alert( key + ": " + value );
});

Comments

$.each({foo:1, length:0, bar:2}, function(k,v){console.log(k,v)})$ .each वस्तुओं के लिए उपयुक्त नहीं है । यदि किसी वस्तु की लंबाई संपत्ति होती है और उसका मान शून्य होता है, तो पूरी वस्तु को ऐसे माना जाता है जैसे कि वह एक खाली सरणी हो।

— बॉब स्टीन

विवरण क्यों मुझे लगता है कि यह एक बग-आमंत्रित दृष्टिकोण है ।

— बॉब स्टीन

Answer 9

डोमिनिक का जवाब एकदम सही है, मैं इसे उस तरह से करना पसंद करता हूं, जैसा कि यह पढ़ने के लिए क्लीनर है:

for (var property in object) {
    if (!object.hasOwnProperty(property)) continue;

    // Do stuff...
}

Comments

Objectहालांकि अपरकेस ओ के साथ होना चाहिए , नहीं?

— जोनाथन

Answer 10

उपरोक्त उत्तर थोड़े परेशान करने वाले हैं क्योंकि वे यह नहीं समझाते हैं कि आप लूप के लिए क्या करते हैं क्योंकि आप यह सुनिश्चित करते हैं कि यह एक वस्तु है: आप इसे सीधे नहीं कर सकते हैं! आपको वास्तव में केवल वह कुंजी वितरित की जाती है जिसे आपको OBJ पर लागू करने की आवश्यकता होती है:

var obj = {
  a: "foo",
  b: "bar",
  c: "foobar"
};

// We need to iterate the string keys (not the objects)
for(var someKey in obj)
{
  // We check if this key exists in the obj
  if (obj.hasOwnProperty(someKey))
  {
    // someKey is only the KEY (string)! Use it to get the obj:
    var myActualPropFromObj = obj[someKey]; // Since dynamic, use [] since the key isn't literally named "someKey"

    // NOW you can treat it like an obj
    var shouldBeBar = myActualPropFromObj.b;
  }
}

यह सभी ECMA5 सुरक्षित है। यहां तक ​​कि राइनो जैसे लंगड़े जेएस संस्करणों में भी काम करता है;)

Answer 11

ES2015 का उपयोग करने के लिए Reflect.ownKeys(obj)और एक पुनरावृत्ति के माध्यम से गुणों पर पुनरावृत्ति को जोड़ने के लिए ।

उदाहरण के लिए:

let obj = { a: 'Carrot', b: 'Potato', Car: { doors: 4 } };

द्वारा पुनरावृत्त किया जा सकता है

// logs each key
Reflect.ownKeys(obj).forEach(key => console.log(key));

यदि आप किसी ऑब्जेक्ट की कुंजियों के मानों पर सीधे चलना चाहते हैं, तो आप iteratorस्ट्रिंग्स, सरणियों, टाइप किए गए सरणियों, मैप और सेट के लिए JavaScipts के डिफ़ॉल्ट पुनरावृत्तियों की तरह, एक परिभाषित कर सकते हैं ।

जेएस डिफ़ॉल्ट पुनरावृत्ति गुण के माध्यम से पुनरावृति करने का प्रयास करेगा, जिसे परिभाषित किया जाना चाहिए Symbol.iterator।

यदि आप सभी वस्तुओं पर पुनरावृति करना चाहते हैं, तो आप इसे ऑब्जेक्ट के प्रोटोटाइप के रूप में जोड़ सकते हैं:

Object.prototype[Symbol.iterator] = function*() { 
    for(p of Reflect.ownKeys(this)){ yield this[p]; }
}

यह आपको लूप के लिए किसी ऑब्जेक्ट के मूल्यों पर पुनरावृति करने में सक्षम करेगा, उदाहरण के लिए:

for(val of obj) { console.log('Value is:' + val ) }

सावधानी : इस उत्तर को लिखने के रूप में (जून 2018) अन्य सभी ब्राउज़र, लेकिन IE, के for...ofमाध्यम से जनरेटर और पुनरावृत्ति का समर्थन करते हैंSymbol.iterator

Comments

यद्यपि आप वास्तव में ओपी के प्रश्न का उत्तर नहीं दे रहे हैं, यह मेरे लिए बहुत उपयोगी था, मुझे अभी तक रिफ्लेक्ट के बारे में नहीं पता था।

— मिकिएल

Answer 12

if(Object.keys(obj).length) {
    Object.keys(obj).forEach(key => {
        console.log("\n" + key + ": " + obj[key]);
    });
}

// *** Explanation line by line ***

// Explaining the bellow line
// It checks if obj has at least one property. Here is how:
// Object.keys(obj) will return an array with all keys in obj
// If there is no keys in obj, it will return empty array = []
// Then it will get it's length, if it has at least one element,
// it's bigger than 0 which evaluates to true and the bellow 
// code will be executed.
// Else means it's length = 0 which evaluates to false
// NOTE: you can use Object.hasOwnProperty() instead of Object.keys(obj).length
if(Object.keys(obj).length) {

    // Explaining the bellow line
    // Just like in the previous line, this returns an array with
    // all keys in obj (because if code execution got here, it means 
    // obj has keys.) 
    // Then just invoke built-in javascript forEach() to loop
    // over each key in returned array and calls a call back function 
    // on each array element (key), using ES6 arrow function (=>)
    // Or you can just use a normal function ((key) { blah blah }).
    Object.keys(obj).forEach(key => {

        // The bellow line prints out all keys with their 
        // respective value in obj.
        // key comes from the returned array in Object.keys(obj)
        // obj[key] returns the value of key in obj
        console.log("\n" + key + ": " + obj[key]);
    });
}

Comments

नमस्ते, क्या आप अपने उत्तर के बारे में अधिक जानकारी जोड़ सकते हैं, केवल कोड उपलब्ध कराने से मदद नहीं मिलती है।

— निकोलस

हाय @Nicolas मैं कोड के लिए लाइन स्पष्टीकरण द्वारा एक लाइन जोड़ दिया है। मुझे बताएं कि क्या यह अभी भी स्पष्ट नहीं है

— फूउड ब्रेड्रेडिन

क्योंकि forEach खाली मूल्यों को छोड़ देता है , मुझे लगता है कि आप छुटकारा पा सकते हैं और सिर्फ Object.keys(obj).forEach(e => console.log(`key=${e} value=${obj[e]}`));फ्रैंक रोथ के जवाब को पसंद करते हैं।

— डार्कप्रोडक्ट

Answer 13

के लिए ... पाश में प्रत्येक गुण का प्रतिनिधित्व करता है एक वस्तु क्योंकि यह सिर्फ एक पाश की तरह है। आपने प्रॉम्प्ट को ... द्वारा लूप में परिभाषित किया है:

    for(var propt in obj){
alert(propt + ': ' + obj[propt]);
}

एक के लिए ... लूप में किसी वस्तु के अनगिनत गुणों के माध्यम से पुनरावृति होती है। जो भी चर आप परिभाषित करते हैं, या लूप में डालते हैं ... लूप में परिवर्तित होने पर प्रत्येक बार अगली संपत्ति में जाने पर बदल जाता है। चर के लिए चर में ... लूप कुंजियों के माध्यम से पुनरावृत्त करता है, लेकिन इसका मूल्य कुंजी का मूल्य है। उदाहरण के लिए:

    for(var propt in obj) {
      console.log(propt);//logs name
      console.log(obj[propt]);//logs "Simon"
    }

आप देख सकते हैं कि वेरिएबल वेरिएबल के वैल्यू से कैसे अलग है। इसके विपरीत, लूप का एक ... इसके विपरीत होता है।

आशा है कि ये आपकी मदद करेगा।

Answer 14

let obj = {"a": 3, "b": 2, "6": "a"}

Object.keys(obj).map((item) => {console.log("item", obj[item])})

// a
// 3
// 2

Comments

जैसा कि अन्य टिप्पणियों में उल्लेख किया गया forEachहै, यहां अधिक उपयुक्त है, जैसा mapकि प्रत्येक पुनरावृत्ति पर कोड ब्लॉक को कॉल करने के परिणामों के साथ एक नया सरणी वापस करने का इरादा है। लेकिन हम केवल प्रत्येक पुनरावृत्ति के पक्ष को प्रभावित करते हैं, न कि रिटर्न वैल्यू को, इसलिए हमें उस नए ऐरे की आवश्यकता नहीं है जो mapहमें देता है।

— डैनी

Answer 15

Object.keys(obj).forEach(key =>
  console.log(`key=${key} value=${obj[key]}`)
);

Answer 16

आप लोदश का उपयोग कर सकते हैं। दस्तावेज़ीकरण

var obj = {a: 1, b: 2, c: 3};
_.keys(obj).forEach(function (key) {
    ...
});

Comments

पृथ्वी पर इस "उत्तर" में 10 उत्थान क्यों हैं? यह प्रश्न का उत्तर देने में पूरी तरह से विफल है। मैं औसत JS डेवलपर की बुद्धि में विश्वास खोना शुरू कर रहा हूं।

— डेवलेपर

@developerbmw मैं समझता हूं कि ES6 सुविधाओं का उपयोग करना अधिक सही तरीका है, लेकिन मैंने एक साल पहले उत्तर दिया है। कृपया, अपने विचार हमारे साथ साझा करें जब आपके पास एक मिनट हो।

— viktarpunko 8

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

Answer 17

आपका forलूप ऑब्जेक्ट के सभी गुणों पर ध्यान केंद्रित कर रहा है obj। proptलूप के लिए आपकी पहली पंक्ति में परिभाषित किया गया है। यह एक स्ट्रिंग है जो objऑब्जेक्ट की एक संपत्ति का नाम है । लूप के पहले पुनरावृत्ति में, propt"नाम" होगा।

Answer 18

जावास्क्रिप्ट में वस्तुएँ गुणों का संग्रह हैं और इसलिए उन्हें प्रत्येक कथन के लिए लूप किया जा सकता है।

आपको objएक प्रमुख मूल्य संग्रह के रूप में सोचना चाहिए ।

Comments

! इस महत्वपूर्ण अंतर के साथ कि इन 'गुणों की सूची' में कुंजी के रूप में नाम हो सकते हैं, जबकि सामान्य JS सरणियों में केवल कुंजी के रूप में संख्याएँ हो सकती हैं।

— Qqwy

Answer 19

आजकल आप एक मानक JS ऑब्जेक्ट को केवल Symbol.iterator पद्धति में जोड़कर पुनरावृत्त वस्तु में परिवर्तित कर सकते हैं। फिर आप एक for ofलूप का उपयोग कर सकते हैं और इसके मूल्यों को सीधे स्वीकार कर सकते हैं या यहां तक ​​कि ऑब्जेक्ट पर एक प्रसार ऑपरेटर का भी उपयोग कर सकते हैं। ठंडा। आइए देखें कि हम इसे कैसे बना सकते हैं:

var o = {a:1,b:2,c:3},
    a = [];
o[Symbol.iterator] = function*(){
                       var ok = Object.keys(this);
                            i = 0;
                       while (i < ok.length) yield this[ok[i++]];
                     };
for (var value of o) console.log(value);
// or you can even do like
a = [...o];
console.log(a);

Comments

ऐसा करने का दिलचस्प तरीका। function*खोज के लिए धन्यवाद !

— बेंज

Answer 20

अगर नोड चलाने की मैं सिफारिश करूंगा:

Object.keys(obj).forEach((key, index) => {
    console.log(key);
});

Answer 21

जबकि टॉप-रेटेड उत्तर सही है, यहां एक वैकल्पिक उपयोग का मामला है यानी यदि आप किसी ऑब्जेक्ट पर पुनरावृत्ति कर रहे हैं और अंत में एक सरणी बनाना चाहते हैं। के .mapबजाय का उपयोग करेंforEach

const newObj = Object.keys(obj).map(el => {
    //ell will hold keys 
   // Getting the value of the keys should be as simple as obj[el]
})

Answer 22

इसके अलावा पुनरावर्ती रास्ता जोड़ना:

function iterate(obj) {
    // watch for objects we've already iterated so we won't end in endless cycle
    // for cases like var foo = {}; foo.bar = foo; iterate(foo);
    var walked = [];
    var stack = [{obj: obj, stack: ''}];
    while(stack.length > 0)
    {
        var item = stack.pop();
        var obj = item.obj;
        for (var property in obj) {
            if (obj.hasOwnProperty(property)) {
                if (typeof obj[property] == "object") {
                  // check if we haven't iterated through the reference yet
                  var alreadyFound = false;
                  for(var i = 0; i < walked.length; i++)
                  {
                    if (walked[i] === obj[property])
                    {
                      alreadyFound = true;
                      break;
                    }
                  }
                  // new object reference
                  if (!alreadyFound)
                  {
                    walked.push(obj[property]);
                    stack.push({obj: obj[property], stack: item.stack + '.' + property});
                  }
                }
                else
                {
                    console.log(item.stack + '.' + property + "=" + obj[property]);
                }
            }
        }
    }
}

उपयोग:

iterate({ foo: "foo", bar: { foo: "foo"} }); 

Comments

@ इफ़िज़ - मेरी टिप्पणियों को देखें, यह अंतहीन लूप में फंसने से बचाव है जब आप बार-बार गर्त में चलते हैं जिसमें चक्रीय संदर्भ होते हैं

— ओन्ड्रेज स्वेजदार

Answer 23

For..in लूप क्या करता है कि यह एक नया वैरिएबल (var someVariable) बनाता है और फिर दिए गए ऑब्जेक्ट की प्रत्येक प्रॉपर्टी को इस नए वेरिएबल (someVariable) में एक-एक करके स्टोर करता है। इसलिए यदि आप ब्लॉक {} का उपयोग करते हैं, तो आप पुनरावृति कर सकते हैं। निम्नलिखित उदाहरण पर विचार करें।

var obj = {
     name:'raman',
     hobby:'coding',
     planet:'earth'
     };

for(var someVariable in obj) {
  //do nothing..
}

console.log(someVariable); // outputs planet

Comments

यह देखते हुए कि यह सरलता है। मेरे उपयोग के मामले में मुझे डोडी मूल्यों के लिए एक ऑब्जेक्ट में सभी विशेषताओं की जांच करने की आवश्यकता है-NaNs, नल, अपरिभाषित (वे एक ग्राफ पर अंक थे और इन मूल्यों ने ग्राफ को ड्राइंग से रोका)। नाम के बजाय मूल्य प्राप्त करने के लिए, लूप में आप बस करेंगे obj[someVariable]। शायद इसका कारण यह था कि इसे बहुत कम कर दिया गया था क्योंकि यह पुनरावर्ती नहीं है। यदि आपके पास अत्यधिक संरचित वस्तु है तो यह पर्याप्त समाधान नहीं होगा।

— काथराइन ओसबोर्न

@ कैथरीनऑनबोर्न या शायद यह इसलिए है क्योंकि निम्नलिखित वाक्यांश थोड़ा गूढ़ है: "इसलिए यदि आप ब्लॉक {} का उपयोग करते हैं, तो आप इसे पुनरावृत्त कर सकते हैं।" कोड पाठ से अधिक कहता है।

— bvdb

Answer 24

यहाँ मैं प्रत्येक नोड को पुनरावृत्त कर रहा हूँ और सार्थक नोड नाम बना रहा हूँ। यदि आप ध्यान दें, उदाहरण के लिए, Array और InstOf ऑब्जेक्ट बहुत अधिक एक ही काम करता है (मेरे आवेदन में, मैं अलग तर्क दे रहा हूँ)

function iterate(obj,parent_node) {
    parent_node = parent_node || '';
    for (var property in obj) {
        if (obj.hasOwnProperty(property)) {
            var node = parent_node + "/" + property;
            if(obj[property] instanceof Array) {
                //console.log('array: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            } else if(obj[property] instanceof Object){
                //console.log('Object: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            }
            else {
                console.log(node + ":" + obj[property]);
            }
        }
    }
}

नोट - मैं Ondrej Svejdar के उत्तर से प्रेरित हूं। लेकिन इस समाधान में बेहतर प्रदर्शन और कम अस्पष्ट है

Answer 25

आप मूल रूप से ऑब्जेक्ट में प्रत्येक संपत्ति के माध्यम से लूप करना चाहते हैं।

JSFiddle

var Dictionary = {
  If: {
    you: {
      can: '',
      make: ''
    },
    sense: ''
  },
  of: {
    the: {
      sentence: {
        it: '',
        worked: ''
      }
    }
  }
};

function Iterate(obj) {
  for (prop in obj) {
    if (obj.hasOwnProperty(prop) && isNaN(prop)) {
      console.log(prop + ': ' + obj[prop]);
      Iterate(obj[prop]);
    }
  }
}
Iterate(Dictionary);

Comments

obj(prop)<- TypeError: obj एक फंक्शन नहीं है

— le_m

@le_m मेरा बुरा। मुझे गलती से hasOwnPropertyविशेषता निकालनी चाहिए। यह अब काम करना चाहिए।

— होवित्च

Answer 26

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

मान लीजिए कि आपके पास JSON ऑब्जेक्ट है जैसे:

var example = {
    "prop1": "value1",
    "prop2": [ "value2_0", value2_1"],
    "prop3": {
         "prop3_1": "value3_1"
    }
}

इसके 'गुणों' के माध्यम से पुनरावृति करने का गलत तरीका:

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        recursivelyIterateProperties(jsonObject[prop]);
    }
}

आप कंसोल लॉगिंग को देखने का हैरानी हो सकती है 0, 1आदि जब बार-बार दोहराना के गुणों के माध्यम से prop1और prop2और की prop3_1। वे ऑब्जेक्ट सीक्वेंस हैं, और अनुक्रम का अनुक्रम जावास्क्रिप्ट में उस ऑब्जेक्ट के गुण हैं।

JSON ऑब्जेक्ट प्रॉपर्टी के माध्यम से पुनरावृत्ति करने का एक बेहतर तरीका यह है कि पहले यह जांचा जाए कि वह ऑब्जेक्ट अनुक्रम है या नहीं:

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        if (!(typeof(jsonObject[prop]) === 'string')
            && !(jsonObject[prop] instanceof Array)) {
                recursivelyIterateProperties(jsonObject[prop]);

            }

     }
}

Answer 27

स्वीकार किए गए उत्तर को और अधिक परिष्कृत करने के लिए यह ध्यान देने योग्य है कि यदि आप किसी वस्तु को तत्कालिक रूप से टाइप करते हैं var object = Object.create(null)तो object.hasOwnProperty(property)वह TypeError को ट्रिगर करेगा। तो सुरक्षित पक्ष पर होने के लिए, आपको इसे इस तरह से प्रोटोटाइप से कॉल करना होगा:

for (var property in object) {
    if (Object.prototype.hasOwnProperty.call(object, property)) {
        // do stuff
    }
}

Answer 28

इस लिंक की जाँच करें यह https://www.w3schools.com/jsref/tryit.asp?filename=tryjsref_state_forin मदद करेगा

var person = {fname:"John", lname:"Doe", age:25}; 

  var text = "";
  var x;
  for (x in person) {
    text += person[x] + " "; // where x will be fname,lname,age
   }
Console.log(text);