दिलचस्प पोस्ट
UIView का फ्रेम, सीमा, केंद्र, मूल, कब उपयोग किया जाए? php त्रुटि शामिल नहीं पथ खोजना Angular.js: पृष्ठ लोड पर सेट तत्व ऊंचाई इस दोहराए जाने वाले अलार्म को कैसे रद्द करें? इस ब्लॉक में दृढ़ता से आत्म-कब्जा करने से एक बनाए रखने के चक्र की संभावना हो सकती है एएसपी.नेट ग्रिडव्यूः डाटा रिकॉर्ड्स को कैसे संपादित और हटाया जाए JQuery के प्रयोग से वर्णानुक्रमिक रूप से क्रमबद्ध विकल्पों के विकल्प इकाई फ़्रेमवर्क में इनहेरिएटेड प्रकार बदलना <Div> भरण <td> ऊंचाई कैसे करें ऐप्पकपाटव 7 – वी 21 नेविगेशन ड्रॉवर हैमबर्गर आइकन नहीं दिखा रहा है एक वेब पेज की सामग्री (AJAX कॉल के माध्यम से लोड) लाएं MKMapView अधिकतम ज़ूम स्तर को सीमित करने का कोई तरीका है? एंड्रॉइड – एक व्यू के अंदर बच्चों को मिलता है? Backbone.js नेस्टेड वस्तु विशेषता प्राप्त करें और सेट करें jquery का उपयोग कर जांच / अनचेक चेकबॉक्स?

मैं एक जावास्क्रिप्ट ऑब्जेक्ट के माध्यम से कैसे लूप कर सकता / सकती हूं?

मेरे पास जावास्क्रिप्ट ऑब्जेक्ट है जैसे निम्नलिखित:

var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; 

अब मैं सभी p तत्वों ( p1 , p1 p2 , p3 …) के माध्यम से पाश करना चाहता हूं और उनकी चाबियाँ और मूल्य प्राप्त करना चाहता हूं। मैं उसे कैसे कर सकता हूँ?

यदि आवश्यक हो तो मैं JavaScript ऑब्जेक्ट को संशोधित कर सकता हूँ मेरा अंतिम लक्ष्य कुछ प्रमुख मूल्य जोड़े के माध्यम से पाश है और यदि संभव हो तो मैं eval का उपयोग करने से बचना चाहता हूं।

Solutions Collecting From Web of "मैं एक जावास्क्रिप्ट ऑब्जेक्ट के माध्यम से कैसे लूप कर सकता / सकती हूं?"

आप दूसरों के द्वारा दिखाए गए अनुसार for-in लूप का उपयोग कर सकते हैं हालांकि, आपको यह भी सुनिश्चित करना होगा कि आप जो कुंजी प्राप्त करें वह वस्तु की वास्तविक संपत्ति है, और प्रोटोटाइप से नहीं आती है।

यहां स्निपेट है:

 var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; for (var key in p) { if (p.hasOwnProperty(key)) { console.log(key + " -> " + p[key]); } } 

Object.keys() 5 के अंतर्गत, आप Object.keys() और Array.prototype.forEach() Object.keys() को जोड़ सकते हैं:

 var obj = { first: "John", last: "Doe" }; Object.keys(obj).forEach(function(key) { console.log(key, obj[key]); }); 

ES2016 के लिए जोड़ा for...of :

 for (const key of Object.keys(obj)) { console.log(key, obj[key]); } 

ES2017 ऑब्जेक्ट जोड़ता है। Object.entries() जो मूल वस्तु में प्रत्येक मान को देखने से बचा जाता है:

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

दोनों Object.keys() और Object.entries() एक ही क्रम में गुणों को पुनरावृत्त करें for...in लूप में लेकिन प्रोटोटाइप श्रृंखला को अनदेखा करें । केवल ऑब्जेक्ट की अपनी गणना योग्य गुणों को पुनरावृत्त किया जाता है।

आपको इन-इन लूप का उपयोग करना होगा

लेकिन इस प्रकार की लूप का उपयोग करते समय बहुत सावधान रहें, क्योंकि यह प्रोटोटाइप श्रृंखला के साथ सभी गुणों को लूप करेगा।

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

 for (var prop in p) { if (!p.hasOwnProperty(prop)) { //The current property is not a direct property of p continue; } //Do your logic with the property here } 

प्रश्न पूरा नहीं होगा यदि हम ऑब्जेक्ट के माध्यम से पाशन करने के वैकल्पिक तरीकों के बारे में नहीं बताते हैं।

आजकल कई सुप्रसिद्ध जावास्क्रिप्ट लाइब्रेरी संग्रहों, यानी सरणियों , ऑब्जेक्ट्स , और सरणी-जैसी ऑब्जेक्ट्स पर पुनरावृति के लिए अपने तरीके प्रदान करते हैं । ये विधियां उपयोग करने के लिए सुविधाजनक हैं और किसी भी ब्राउज़र के साथ पूरी तरह से संगत हैं।

  1. यदि आप jQuery के साथ काम करते हैं, तो आप jQuery.each() विधि का उपयोग कर सकते हैं। यह दोनों ऑब्जेक्ट्स और एरेज़ों को एकदम से पुनरावृति करने के लिए इस्तेमाल किया जा सकता है:

     $.each(obj, function(key, value) { console.log(key, value); }); 
  2. Underscore.js में आप विधि _.each() प्राप्त कर सकते हैं, जो तत्वों की एक सूची से दोहराता है, प्रत्येक में एक आपूर्ति की गई फ़ंक्शन ( आईटरेटे फ़ंक्शन में तर्कों के आदेश पर ध्यान दें) के बदले में उपज देता है:

     _.each(obj, function(value, key) { console.log(key, value); }); 
  3. लो-डैश ऑब्जेक्ट गुणों को पुनरावृति करने के लिए कई तरीके प्रदान करता है। मूल _.forEach() (या यह उर्फ _.each() ) ऑब्जेक्ट और एरे दोनों के बीच लूपिंग के लिए उपयोगी है, फिर भी (!) length संपत्ति वाले ऑब्जेक्ट्स को एरेज़ की तरह व्यवहार किया जाता है, और इस व्यवहार से बचने के लिए इसे _.forIn() और _.forOwn() तरीकों (इन्हें भी value तर्क आ रहा है):

     _.forIn(obj, function(value, key) { console.log(key, value); }); 

    _.forIn() एक ऑब्जेक्ट के अपने खुद के और विरासत में आने योग्य गुणों पर पुनरावृत्त करता है, जबकि _.forOwn() केवल एक ऑब्जेक्ट के अपने गुणों (मूलतः hasOwnProperty फ़ंक्शन के विरुद्ध जाँच) पर hasOwnProperty करता है। सरल वस्तुओं और ऑब्जेक्ट लिटरल्स के लिए इनमें से कोई भी विधि ठीक काम करेगी।

आम तौर पर सभी वर्णित विधियों में किसी भी आपूर्ति की वस्तुओं के साथ एक ही व्यवहार होता है। मूल for..in लूप का उपयोग करने के अलावा, आमतौर पर किसी भी अमूर्त से अधिक तेज हो जाएगा, जैसे कि jQuery.each() , इन तरीकों का उपयोग करना काफी आसान है, कम कोडिंग की आवश्यकता होती है और बेहतर त्रुटि हैंडलिंग प्रदान करती है।

Object.keys 5 में आपके पास वास्तविक- Object.keys चलना क्षेत्र में नया दृष्टिकोण है

अधिक जानकारी आप एमडीएन पर देख सकते हैं

मेरी पसंद ब्राउज़र के वर्तमान संस्करणों (Chrome30, IE10, FF25) में तेज समाधान के रूप में नीचे है

 var keys = Object.keys(p), len = keys.length, i = 0, prop, value; while (i < len) { prop = keys[i]; value = p[prop]; i += 1; } 

आप jsperf.com पर विभिन्न कार्यान्वयन के साथ इस दृष्टिकोण के प्रदर्शन की तुलना कर सकते हैं:

  • कार्यान्वयन बढ़ाएं
  • ऑब्जेक्ट चाबियाँ चलना
  • ऑब्जेक्ट शाब्दिक चलना

ब्राउज़र का समर्थन है जो आप कागाक्स के कॉम्पेट टेबल पर देख सकते हैं

पुराने ब्राउज़र के लिए आपके पास सरल और पूर्ण पॉलीफिल है

युपीडी:

perfjs.info पर इस प्रश्न के सभी सबसे लोकप्रिय मामलों के लिए प्रदर्शन तुलना:

ऑब्जेक्ट शाब्दिक चलना

आप इसे बस की तरह पुनरावृति कर सकते हैं:

 for (var key in p) { alert(p[key]); } 

ध्यान दें कि key संपत्ति के मूल्य पर नहीं ले जाएगा, यह सिर्फ एक सूचकांक मूल्य है

के लिए प्रोटोटाइप के साथ के लिए (हर) जो प्रोटोटाइप श्रृंखला गुणों को छोड़ देना चाहिए:

 Object.prototype.each = function(f) { var obj = this Object.keys(obj).forEach( function(key) { f( key , obj[key] ) }); } //print all keys and values var obj = {a:1,b:2,c:3} obj.each(function(key,value) { console.log(key + " " + value) }); // a 1 // b 2 // c 3 

यहां के सभी उत्तरों को देखने के बाद, मेरे ही उपयोग के लिए हैओवनपीप्रर्टी की आवश्यकता नहीं है क्योंकि मेरा जेसन ऑब्जेक्ट साफ है; कोई अतिरिक्त जावास्क्रिप्ट प्रोसेसिंग जोड़ने में वास्तव में कोई मतलब नहीं है यह सब मैं उपयोग कर रहा हूं:

 for (var key in p) { console.log(key + ' => ' + p[key]); // key is key // value is p[key] } 

Es2015 अधिक से अधिक लोकप्रिय हो रहा है इसलिए मैं इस उत्तर पोस्ट कर रहा हूं जिसमें जनरेटर और इटरेटर का उपयोग [key, value] जोड़े के माध्यम से आसानी से पुनरावृति करने के लिए किया गया है। जैसा कि अन्य भाषाओं में संभव है रूबी उदाहरण के लिए

ठीक है यहाँ एक कोड है:

 const MyObject = { 'a': 'Hello', 'b': 'it\'s', 'c': 'me', 'd': 'you', 'e': 'looking', 'f': 'for', [Symbol.iterator]: function* () { for (const i of Object.keys(this)) { yield [i, this[i]]; } } }; for (const [k, v] of MyObject) { console.log(`Here is key ${k} and here is value ${v}`); } 

डेवलपर मोज़िला पेज पर आप इटरेटर और जनरेटर कैसे कर सकते हैं, इसके बारे में सभी जानकारी।

आशा है कि किसी ने मदद की

संपादित करें:

ES2017 में Object.entries शामिल होगा। Object.entries जो ऑब्जेक्ट्स में [key, value] जोड़ी में Object.entries [key, value] और भी आसान। यह अब ज्ञात है कि यह एसएसओएस चरण की जानकारी के अनुसार एक मानक का हिस्सा होगा।

मुझे लगता है कि अब यह मेरे जवाब को अपडेट करने का समय है क्योंकि यह अब और भी अधिक नवसिखुआ बन गया है।

 const MyObject = { 'a': 'Hello', 'b': 'it\'s', 'c': 'me', 'd': 'you', 'e': 'looking', 'f': 'for', }; for (const [k, v] of Object.entries(MyObject)) { console.log(`Here is key ${k} and here is value ${v}`); } 

आप एमडीएन पेज पर उपयोग के बारे में अधिक जानकारी प्राप्त कर सकते हैं

ऑब्जेक्ट। कुंजी (ओबीजे): ऐरे

सभी गणनायोग्य स्वयं (गैर-विरासत) गुणों की सभी स्ट्रिंग-महत्वपूर्ण कुंजी पुनर्प्राप्त करता है

तो यह उन कुंजीओं की एक ही सूची देता है, जैसा कि आप के साथ प्रत्येक ऑब्जेक्ट की जांच करने का इरादा है haswnproperty। आपको और Object.keys( obj ).forEach(function( key ){}) तुलना में उस अतिरिक्त टेस्ट ऑपरेशन की आवश्यकता नहीं है। Object.keys( obj ).forEach(function( key ){}) को तेजी से माना जाता है चलो यह साबित करें:

 var uniqid = function(){ var text = "", i = 0, possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; for( ; i < 32; i++ ) { text += possible.charAt( Math.floor( Math.random() * possible.length ) ); } return text; }, CYCLES = 100000, obj = {}, p1, p2, p3, key; // Populate object with random properties Array.apply( null, Array( CYCLES ) ).forEach(function(){ obj[ uniqid() ] = new Date() }); // Approach #1 p1 = performance.now(); Object.keys( obj ).forEach(function( key ){ var waste = obj[ key ]; }); p2 = performance.now(); console.log( "Object.keys approach took " + (p2 - p1) + " milliseconds."); // Approach #2 for( key in obj ) { if ( obj.hasOwnProperty( key ) ) { var waste = obj[ key ]; } } p3 = performance.now(); console.log( "for...in/hasOwnProperty approach took " + (p3 - p2) + " milliseconds."); 
 for(key in p) { alert( p[key] ); } 

नोट: आप यह सरणियों पर कर सकते हैं, लेकिन आप length और अन्य गुणों पर फिर से दोबारा करेंगे।

इन उत्तरों में दिलचस्प लोगों को Object.keys() और दोनों के लिए छुआ है for...of लेकिन उनका कभी जोड़ा नहीं:

 var map = {well:'hello', there:'!'}; for (let key of Object.keys(map)) console.log(key + ':' + map[key]); 

आप केवल एक Object for...of नहीं कर सकते हैं क्योंकि यह एक .forEach() नहीं है, और for...index या .forEach() लिए। Object.keys() बदसूरत / अक्षम है।
मुझे खुशी है कि ज्यादातर लोग इसके for...in से .hasOwnProperty() रहे हैं for...in (बिना या बिना जाँच के .hasOwnProperty() ) के रूप में भी थोड़ा गड़बड़ है, इसलिए मेरे उत्तर के अलावा अन्य, मैं कहने के लिए यहां हूं …


आप साधारण ऑब्जेक्ट एसोसिएशन पुनरावृत्त कर सकते हैं! के लिए कल्पना की सीधा उपयोग के साथ Map तरह व्यवहार for...of
क्रोम और एफएफ में डेमो काम (मैं केवल ईएस 6 मानता हूं)

 var ordinaryObject = {well:'hello', there:'!'}; for (let pair of ordinaryObject) //key:value console.log(pair[0] + ':' + pair[1]); //or for (let [key, value] of ordinaryObject) console.log(key + ':' + value); 

जब तक आप नीचे मेरी शिम को शामिल करते हैं:

 //makes all objects iterable just like Maps!!! YAY //iterates over Object.keys() (which already ignores prototype chain for us) Object.prototype[Symbol.iterator] = function() { var keys = Object.keys(this)[Symbol.iterator](); var obj = this; var output; return {next:function() { if (!(output = keys.next()).done) output.value = [output.value, obj[output.value]]; return output; }}; }; 

एक असली नक्शा वस्तु बनाने के बिना, जो वाकई अच्छा वाक्यविन्यास चीनी नहीं है

 var trueMap = new Map([['well', 'hello'], ['there', '!']]); for (let pair of trueMap) console.log(pair[0] + ':' + pair[1]); 

वास्तव में, इस शिम के साथ, अगर आप अभी भी मानचित्र की अन्य कार्यक्षमता का फायदा उठाना चाहते हैं (फिर भी बिना इन सब को ढंकते हुए), लेकिन फिर भी साफ ऑब्जेक्ट नोटेशन का उपयोग करना चाहते हैं, चूंकि ऑब्जेक्ट अब चलने योग्य हैं, अब आप इसे से एक नक्शा बना सकते हैं!

 //shown in demo var realMap = new Map({well:'hello', there:'!'}); 

उन लोगों के लिए जो शिम की तरह नहीं है, या सामान्य रूप में prototype साथ गड़बड़ करने के लिए, इसे खिड़की पर getObjIterator() करने के लिए बेझिझक, इसे कॉलिंग getObjIterator() जैसे कुछ;

 var realMap = new Map(getObjIterator({well:'hello', there:'!'})) 

या

 for (let pair of getObjIterator(ordinaryObject)) 

कोई कारण नहीं है कि वह काम क्यों नहीं करेगा

आने वाला कल आपका स्वागत करता है।

 var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; for (var key in p) { if (p.hasOwnProperty(key)) { alert(key + " = " + p[key]); } } --------------------------- --------------------------- Output: p1 = values1 p2 = values2 p3 = values3 

आप सभी ऑब्जेक्ट में एक फंक्शन के लिए सरल जोड़ सकते हैं, ताकि आप स्वचालित रूप से किसी ऑब्जेक्ट के माध्यम से पाश कर सकें:

 Object.defineProperty(Object.prototype, 'forEach', { value: function (func) { for (var key in this) { if (!this.hasOwnProperty(key)) { // skip loop if the property is from prototype continue; } var value = this[key]; func(key, value); } }, enumerable: false }); 

उन लोगों के लिए जो "के लिए … में " पसंद नहीं करते- विधि:

 Object.defineProperty(Object.prototype, 'forEach', { value: function (func) { var arr = Object.keys(this); for (var i = 0; i < arr.length; i++) { var key = arr[i]; func(key, this[key]); } }, enumerable: false }); 

अब, आप साधारण कॉल कर सकते हैं:

 p.forEach (function(key, value){ console.log ("Key: " + key); console.log ("Value: " + value); }); 

अगर आप दूसरे तरीकों से दूसरे के साथ संघर्ष नहीं करना चाहते हैं तो आप इसे अपने अद्वितीय नाम के साथ नाम दे सकते हैं।

मैं हर किसी के for ... in लूप for ... in obj.hasOwnerProperty को चेक करने के बजाय यह करना होगा।

 var obj = {a : 1}; for(var key in obj){ //obj.hasOwnProperty(key) is not needed. console.log(key); } //then check if anybody has messed the native object. Put this code at the end of the page. for(var key in Object){ throw new Error("Please don't extend the native object"); } 

यदि आप नॉन-एन्यूमेरेबल प्रॉपर्टी पर पुनरावृत्त करना चाहते हैं, तो आप Object.getOwnPropertyNames(obj) लिए Object.getOwnPropertyNames(obj) उपयोग कर सकते Object.getOwnPropertyNames(obj) ) किसी भी ऑब्जेक्ट पर सीधे सभी गुणों की गणना करने के लिए Object.getOwnPropertyNames(obj) या नहीं) लौटाने के लिए।

 var obj = Object.create({}, { // non-enumerable property getFoo: { value: function() { return this.foo; }, enumerable: false } }); obj.foo = 1; // enumerable property Object.getOwnPropertyNames(obj).forEach(function (name) { document.write(name + ': ' + obj[name] + '<br/>'); }); 

केवल जावास्क्रिप्ट कोड निर्भरता के बिना:

 var p = {"p1": "value1", "p2": "value2", "p3": "value3"}; keys = Object.keys(p); // ["p1", "p2", "p3"] for(i = 0; i < keys.length; i++){ console.log(keys[i] + "=" + p[keys[i]]); // p1=value1, p2=value2, p3=value3 } 

शुद्ध जावास्क्रिप्ट का प्रयोग करते समय लूप्स बहुत दिलचस्प हो सकते हैं। ऐसा लगता है कि केवल ECMA6 (नया 2015 जावास्क्रिप्ट विनिर्देश) को नियंत्रण में लूप मिला। दुर्भाग्य से, मैं यह लिख रहा हूं, दोनों ब्राउज़र्स और लोकप्रिय एकीकृत विकास पर्यावरण (आईडीई) अभी भी पूरी तरह से नई घंटियाँ और सीटी का समर्थन करने के लिए संघर्ष कर रहे हैं।

एक नज़र में यह है कि जावामैटिक इजाज लूप ईसीएमए 6 से पहले की तरह दिखता है:

 for (var key in object) { if (p.hasOwnProperty(key)) { var value = object[key]; console.log(key); // This is the key; console.log(value); // This is the value; } } 

इसके अलावा, मुझे पता है कि यह सवाल दायरे से बाहर है, लेकिन 2011 में, ECMAScript 5.1 ने केवल एरे के लिए forEach विधि को जोड़ा है, जो मूल रूप से forEach माध्यम से लूप का एक नया तरीका बनाया है जबकि अभी भी पुराने वर्बोज़ के साथ गैर इन्सुरेबल ऑब्जेक्ट्स को छोड़कर पाश के for भ्रमित for है । लेकिन अजीब हिस्सा यह है कि हर नई पद्धति के लिए यह break समर्थन नहीं करता है, जिसने सभी प्रकार की अन्य समस्याओं को जन्म दिया।

मूल रूप से 2011 में, जावास्क्रिप्ट में कई लोकप्रिय पुस्तकालयों (jQuery, अंडरस्कोर इत्यादि) के अलावा, लूप का वास्तविक ठोस तरीका फिर से लागू करने का निर्णय नहीं लिया गया है।

2015 तक, अब हमारे पास किसी भी ऑब्जेक्ट प्रकार (एरेज़ और स्ट्रिंग्स सहित) को लूप (और ब्रेक) करने के लिए बक्से से एक बेहतर तरीका है। यहां बताया गया है कि जावास्क्रिप्ट में एक लूप अंततः जब मुख्यधारा की सिफारिश की जाती है,

 for (let [key, value] of Object.entries(object)) { console.log(key); // This is the key; console.log(value); // This is the value; } 

ध्यान दें कि अधिकांश ब्राउज़र्स जून 18 2016 तक उपरोक्त कोड का समर्थन नहीं करेंगे। क्रोम में भी आपको यह काम करने के लिए इस विशेष ध्वज को सक्षम करना होगा: chrome://flags/#enable-javascript-harmony

जब तक यह नया मानक नहीं हो जाता, तब तक पुरानी विधि का उपयोग किया जा सकता है, लेकिन इन पुस्तकालयों में से किसी का उपयोग नहीं करने वाले लोगों के लिए लोकप्रिय लाइब्रेरी या हल्के विकल्प के विकल्प भी हैं।

ईएस 6 को ध्यान में रखते हुए मैं अपने स्वयं के चम्मच चीनी को जोड़ना चाहता हूं और ऑब्जेक्ट के गुणों को फिर से करने के लिए एक और दृष्टिकोण प्रदान करना चाहता हूं।

चूंकि सादे जे एस ऑब्जेक्ट बॉक्स से बाहर नहीं for..of योग्य है, हम इसकी सामग्री पर पुनरावृति के लिए लूप के लिए उपयोग नहीं कर सकते। लेकिन कोई हमें इसे पुनरावृत्त बनाने के लिए रोक नहीं सकता है

चलो हम book ऑब्जेक्ट है

 let book = { title: "Amazing book", author: "Me", pages: 3 } book[Symbol.iterator] = function(){ let properties = Object.keys(this); // returns an array with property names let counter = 0; let isDone = false; let next = () => { if(counter >= properties.length){ isDone = true; } return { done: isDone, value: this[properties[counter++]] } } return { next }; } 

चूंकि हमने इसे बनाया है इसलिए हम इसे इस तरह से उपयोग कर सकते हैं:

 for(let pValue of book){ console.log(pValue); } ------------------------ Amazing book Me 3 

या अगर आप ES6 जनरेटर की शक्ति जानते हैं, तो आप निश्चित रूप से कोड को बहुत कम ऊपर बना सकते हैं।

 book[Symbol.iterator] = function *(){ let properties = Object.keys(this); for (let p of properties){ yield this[p]; } } 

ज़रूर, आप सभी वस्तुओं के लिए ऐसे व्यवहार को लागू कर सकते हैं जिससे prototype स्तर पर Object पहचाने जाने योग्य हो।

 Object.prototype[Symbol.iterator] = function() {...} 

इसके अलावा, ऑब्जेक्ट्स जो इरेरेबल प्रोटोकॉल का अनुपालन करते हैं, उन्हें नए ES2015 फीचर स्प्रेड ऑपरेटर के साथ इस्तेमाल किया जा सकता है इसलिए हम ऑरेजेन्ट प्रॉपर्टी वैल्यू को एक सरणी के रूप में पढ़ सकते हैं।

 let pValues = [...book]; console.log(pValues); ------------------------- ["Amazing book", "Me", 3] 

या आप विध्वंस करने वाले असाइनमेंट का उपयोग कर सकते हैं:

 let [title, , pages] = book; // notice that we can just skip unnecessary values console.log(title); console.log(pages); ------------------ Amazing book 3 

आप ऊपर दिए गए सभी कोड के साथ JSFiddle को देख सकते हैं।

अगर किसी को शर्त के साथ arrayObjects के माध्यम से लूप की आवश्यकता होती है:

 var arrayObjects = [{"building":"A", "status":"good"},{"building":"B","status":"horrible"}]; for (var i=0; i< arrayObjects.length; i++) { console.log(arrayObjects[i]); for(key in arrayObjects[i]) { if (key == "status" && arrayObjects[i][key] == "good") { console.log(key + "->" + arrayObjects[i][key]); }else{ console.log("nothing found"); } } } 

Object.keys() विधि किसी दिए गए ऑब्जेक्ट की अपनी गणनायोग्य गुणों की एक सरणी देता है। इसके बारे में यहां और पढ़ें

 var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; Object.keys(p).map((key)=> console.log(key + "->" + p[key])) 

ईएस 6 में कुछ पूर्व आंतरिक विधियों को बेनकाब करने के लिए हमारे पास प्रसिद्ध ज्ञात चिह्न हैं, आप इसे परिभाषित करने के लिए उपयोग कर सकते हैं कि कैसे इस वस्तु के लिए काम करते हैं:

 var p = { "p1": "value1", "p2": "value2", "p3": "value3", *[Symbol.iterator]() { yield *Object.keys(this); } }; [...p] //["p1", "p2", "p3"] 

यह ईएस 6 लूप में … के लिए उपयोग करने के समान परिणाम देगा।

 for(var key in p) { console.log(key); } 

लेकिन इसकी क्षमताओं को जानना महत्वपूर्ण है कि अब आप es6 का उपयोग कर रहे हैं!

जब कोई ऑब्जेक्ट को .next () विधि लागू करता है, तो एक ऑब्जेक्ट एक इरेटरेटर बन जाता है

 const james = { name: 'James', height: `5'10"`, weight: 185, [Symbol.iterator]() { let properties = [] for (let key of Object.keys(james)){ properties.push(key); } index = 0; return { next: () => { let key = properties[index]; let value = this[key]; let done = index >= properties.length - 1 ; index++; return { key, value, done }; } }; } }; const iterator = james[Symbol.iterator](); console.log(iterator.next().value); // 'James' console.log(iterator.next().value); // `5'10` console.log(iterator.next().value); // 185 

ES2015 के बाद से आप सीधे लूप के उपयोग के लिए, लूप का उपयोग कर सकते हैं:

 // before ES2015 for(var key of elements){ console.log(elements[key]); } // ES2015 for(let element of elements){ console.log(element); } 

उम्मीद है कि यह किसी को मदद करता है

कांग का उपयोग करते समय मुझे एक ऐसी ही समस्या थी, यहां वह समाधान है जिसे मैंने पाया है

चरण 1. सभी वस्तु कुंजी प्राप्त करें Object.keys का उपयोग करके यह विधि किसी दिए गए ऑब्जेक्ट की अपनी गणनायोग्य गुणों की एक सरणी देता है।

चरण 2. एक खाली सरणी बनाएँ। This is an where all the properties are going to live, since your new ngFor loop is going to point to this array, we gotta catch them all. Step 3. Iterate throw all keys, and push each one into the array you created. Here's how that looks like in code.

  // Evil response in a variable. Here are all my vehicles. let evilResponse = { "car" : { "color" : "red", "model" : "2013" }, "motorcycle": { "color" : "red", "model" : "2016" }, "bicycle": { "color" : "red", "model" : "2011" } } // Step 1. Get all the object keys. let evilResponseProps = Object.keys(evilResponse); // Step 2. Create an empty array. let goodResponse = []; // Step 3. Iterate throw all keys. for (prop of evilResponseProps) { goodResponse.push(evilResponseProps[prop]); } 

Here is a link to the original post. https://medium.com/@papaponmx/looping-over-object-properties-with-ngfor-in-angular-869cd7b2ddcc

Besause the asker's [' ultimate goal is to loop through some key value pairs '] and finally don't looking for a loop.

 var p ={"p1":"value1","p2":"value2","p3":"value3"}; if('p1' in p){ var val=p['p1']; ... }