javascript - समझ - मैं जावास्क्रिप्ट ऑब्जेक्ट के माध्यम से लूप या गणना कैसे करूं?




प्रपत्र एचटीएमएल (20)

ऑब्जेक्ट.कीज (ओबीजे): ऐरे

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

इसलिए यह कुंजी की एक ही सूची देता है जैसा कि आप हैऑनप्रोपर्टी के साथ प्रत्येक ऑब्जेक्ट कुंजी का परीक्षण करके करना चाहते हैं। आपको 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.");

मेरे फ़ायरफ़ॉक्स में मेरे पास निम्नलिखित परिणाम हैं

  • ऑब्जेक्ट.कीस दृष्टिकोण ने 40.21101451665163 मिलीसेकंड लिया।
  • के लिए ... in / hasOwnProperty दृष्टिकोण 98.26163508463651 मिलीसेकंड ले लिया।

पुनश्च। क्रोम पर अंतर भी बड़ा है http://codepen.io/dsheiko/pen/JdrqXa

पीएस 2: ईएस 6 (एक्मास्क्रिप्ट 2015) में आप पुन: प्रयोज्य ऑब्जेक्ट निसर को पुन: सक्रिय कर सकते हैं:

let map = new Map().set('a', 1).set('b', 2);
for (let pair of map) {
    console.log(pair);
}

// OR 
let map = new Map([
    [false, 'no'],
    [true,  'yes'],
]);
map.forEach((value, key) => {
    console.log(key, value);
});

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

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

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

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


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

var obj = { first: "John", last: "Doe" };

Object.keys(obj).forEach(function(key) {
    console.log(key, obj[key]);
});

ECMAScript 6 के लिए जोड़ता for...of :

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

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

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

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


आप दूसरों के द्वारा दिखाए गए 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.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);
});

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


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

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

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

आप साधारण ऑब्जेक्ट एसोसिएशन को फिर से बना सकते हैं! फैंसी के प्रत्यक्ष उपयोग के साथ Map तरह व्यवहार for...of
DEMO क्रोम और एफएफ में काम कर रहा है (मैं केवल ईएस 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() तब कॉल करें;

//no prototype manipulation
function getObjIterator(obj) {
    //create a dummy object instead of adding functionality to all objects
    var iterator = new Object();

    //give it what the shim does but as its own local property
    iterator[Symbol.iterator] = function() {
        var keys = Object.keys(obj)[Symbol.iterator]();
        var output;

        return {next:function() {
            if (!(output = keys.next()).done)
                output.value = [output.value, obj[output.value]];
            return output;
        }};
    };

    return iterator;
}

अब आप इसे सामान्य कार्य के रूप में बुला सकते हैं, और कुछ भी प्रभावित नहीं होता है

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

या

for (let pair of getObjIterator(ordinaryObject))

ऐसा कोई कारण नहीं है कि यह काम नहीं करेगा।

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


किसी ऑब्जेक्ट के माध्यम से पुनरावृत्ति करने का एक और तरीका यहां दिया गया है।

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


Object.keys(p).forEach(key => { console.log(key, p[key]) })


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

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
}

प्रस्तावना:

  • ऑब्जेक्ट गुणों का स्वामित्व हो सकता है (संपत्ति ऑब्जेक्ट पर ही है) या विरासत में मिली (ऑब्जेक्ट पर नहीं, इसके प्रोटोटाइप में से एक पर)।
  • ऑब्जेक्ट गुण संख्यात्मक या गैर-गणना योग्य हो सकते हैं। गैर-संख्यात्मक गुणों को बहुत से संपत्ति गणना / सरणी से बाहर रखा गया है।
  • संपत्ति के नाम तार या प्रतीक हो सकते हैं। जिन गुणों के नाम प्रतीक हैं, वे संपत्ति गणना / सरणी से बहुत दूर हैं।

यहां 2018 में, किसी ऑब्जेक्ट के गुणों के माध्यम से लूपिंग के लिए आपके विकल्प हैं:

  1. for-in [ MDN , spec ] - एक लूप संरचना जो किसी ऑब्जेक्ट की समृद्ध गुणों के नामों से गुजरती है, जिसमें विरासत वाले व्यक्ति शामिल हैं, जिनके नाम स्ट्रिंग हैं
  2. Object.keys [ Object.keys , spec ] - एक कार्य किसी ऑब्जेक्ट के नाम, नामांकित गुणों के नामों की सरणी प्रदान करता है जिनके नाम तार हैं।
  3. Object.values [ Object.values , spec ] - एक फ़ंक्शन किसी ऑब्जेक्ट के मूल्यों , माननीय गुणों के मानों की सरणी प्रदान करता है।
  4. Object.entries [ Object.entries , spec ] - एक कार्य किसी ऑब्जेक्ट के नाम, मूल्यवान गुणों के नामों और मानों की सरणी प्रदान करता है।
  5. Object.getOwnPropertyNames [ MDN , spec ] - एक फ़ंक्शन किसी ऑब्जेक्ट के गुणों (यहां तक ​​कि गैर-गणना करने वाले) के नामों की सरणी प्रदान करता है जिसका नाम तार हैं।
  6. Object.getOwnPropertySymbols [ MDN , spec ] - एक कार्य किसी ऑब्जेक्ट के गुणों (यहां तक ​​कि गैर-गणना करने वाले) के नामों की सरणी प्रदान करता है जिनके नाम प्रतीक हैं।
  7. Reflect.ownKeys [ MDN , spec ] - एक फ़ंक्शन किसी ऑब्जेक्ट के गुणों (यहां तक ​​कि गैर-गणना करने योग्य) के नामों की सरणी प्रदान करता है, चाहे वे नाम स्ट्रिंग या सिंबल हों।
  8. यदि आप किसी ऑब्जेक्ट की सभी संपत्तियों को गैर-गणित विरासत वाले लोगों सहित चाहते हैं, तो आपको एक लूप और Object.getPrototypeOf [ MDN , spec ] का उपयोग करने और ऑब्जेक्ट. Object.getOwnPropertyNames , Object.getOwnPropertySymbols , या Reflect.ownKeys उपयोग प्रत्येक ऑब्जेक्ट पर करने की आवश्यकता है प्रोटोटाइप श्रृंखला (इस उत्तर के नीचे उदाहरण)।

उनमें से सभी को छोड़कर, आप सरणी पर किसी प्रकार के लूपिंग निर्माण का उपयोग करेंगे (के for , के for-of , आदि के लिए)।

उदाहरण:

for-in :

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name in o) {
    const value = o[name];
    console.log(`${name} = ${value}`);
}

Object.keys (लूप के लिए, लेकिन आप किसी भी लूपिंग निर्माण का उपयोग कर सकते हैं) :

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name of Object.keys(o)) {
    const value = o[name];
    console.log(`${name} = ${value}`);
}

Object.values :

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const value of Object.values(o)) {
    console.log(`${value}`);
}

Object.entries :

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const [name, value] of Object.entries(o)) {
    console.log(`${name} = ${value}`);
}

Object.getOwnPropertyNames :

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name of Object.getOwnPropertyNames(o)) {
    const value = o[name];
    console.log(`${name} = ${value}`);
}

Object.getOwnPropertySymbols :

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name of Object.getOwnPropertySymbols(o)) {
    const value = o[name];
    console.log(`${String(name)} = ${value}`);
}

Reflect.ownKeys :

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name of Reflect.ownKeys(o)) {
    const value = o[name];
    console.log(`${String(name)} = ${value}`);
}

विरासत रहित गैर-समेकित समेत सभी गुण :

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (let depth = 0, current = o; current; ++depth, current = Object.getPrototypeOf(current)) {
    for (const name of Reflect.ownKeys(current)) {
        const value = o[name];
        console.log(`[${depth}] ${String(name)} = ${String(value)}`);
    }
}
.as-console-wrapper {
  max-height: 100% !important;
}


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

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

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

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

Object.keys(p).map((key)=> console.log(key + "->" + p[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

ES06 के बाद से आप ऑब्जेक्ट के मान सरणी के रूप में प्राप्त कर सकते हैं

let arrValues = Object.values( yourObject) ;

यह ऑब्जेक्ट मानों की एक सरणी लौटाता है और यह प्रोटोटाइप से मूल्य निकालने नहीं देता है !!

एमडीएन डॉक्स ऑब्जेक्ट.वल्यूज ()

और चाबियों के लिए (यहां पहले से ही मेरे सामने जवाब दिया गया है)

let arrKeys   = Object.keys(yourObject);

ईएस 6 में हमारे पास कुछ पूर्व आंतरिक तरीकों का पर्दाफाश करने के लिए जाने-माने प्रतीक हैं, आप इसका उपयोग इस ऑब्जेक्ट के लिए कैसे काम करते हैं यह परिभाषित करने के लिए कर सकते हैं:

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

[...p] //["p1", "p2", "p3"]

यह es6 लूप में ... के लिए उपयोग के रूप में एक ही परिणाम देगा।

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

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


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

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

चरण 2. एक खाली सरणी बनाएँ। यह वह जगह है जहां सभी संपत्तियां जीने जा रही हैं, क्योंकि आपका नया एनजीफ़ोर लूप इस सरणी को इंगित करने जा रहा है, हमें उन्हें सभी को पकड़ना होगा। चरण 3. सभी चाबियाँ फेंक दें, और प्रत्येक को आपके द्वारा बनाए गए सरणी में धक्का दें। यहां बताया गया है कि यह कोड में कैसा दिखता है।

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

मूल पोस्ट का एक लिंक यहां दिया गया है। https://medium.com/@papaponmx/looping-over-object-properties-with-ngfor-in-angular-869cd7b2ddcc


नवीनतम ईएस स्क्रिप्ट में, आप ऐसा कुछ कर सकते हैं:

Object.entries(p);

    var p =[{"username":"ordermanageadmin","user_id":"2","resource_id":"Magento_Sales::actions"},
{"username":"ordermanageadmin_1","user_id":"3","resource_id":"Magento_Sales::actions"}]
for(var value in p) {
    for (var key in value) {
        if (p.hasOwnProperty(key)) {
            console.log(key + " -> " + p[key]);
        }
    }
}


अगर किसी को स्थिति के साथ 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");
      }
   }
}


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

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)

for (let o of Object.getOwnPropertyNames(Math)) {
  console.log(o);
}

मैं कभी-कभी सरल इनपुट और आउटपुट वाले ऑब्जेक्ट्स पर सभी फ़ंक्शंस का परीक्षण करने के लिए इसका उपयोग करता हूं।


शुद्ध जावास्क्रिप्ट का उपयोग करते समय लूप बहुत दिलचस्प हो सकते हैं। ऐसा लगता है कि केवल ईसीएमए 6 (नया 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 में, ईसीएमएस्क्रिप्ट 5.1 ने forEachकेवल Arrays के लिए विधि जोड़ा जो मूल रूप से पुराने वर्बोज़ और भ्रमित forलूप के साथ गैर-पुनरावृत्त वस्तुओं को छोड़कर सरणी के माध्यम से लूप करने के लिए एक नया बेहतर तरीका बनाया गया । लेकिन अजीब बात यह है कि यह नई forEachविधि का समर्थन नहीं करता है breakजिससे अन्य सभी समस्याओं का सामना करना पड़ता है।

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

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

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

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






each