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




loops each (25)

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

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

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

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


Answers

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

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

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

for (var key in p) {
    if (p.hasOwnProperty(key)) {
        console.log(key + " -> " + p[key]);
    }
}


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

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

इसलिए, इन-इन लूप का उपयोग करते समय, हमेशा यह निर्धारित करने के लिए 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. सभी ऑब्जेक्ट कुंजी प्राप्त करें। 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);

ईएस 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. यदि आप jQuery के साथ काम करते हैं, तो आप jQuery.each() विधि का उपयोग कर सकते हैं। इसका उपयोग दोनों वस्तुओं और सरणीओं पर निर्बाध रूप से पुनरावृत्त करने के लिए किया जा सकता है:

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

    _.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() गुणों को _.forOwn() , जबकि _.forOwn() केवल किसी ऑब्जेक्ट के अपने गुणों पर पुनरावृत्त करता है (मूल रूप से hasOwnProperty फ़ंक्शन के विरुद्ध जांच कर hasOwnProperty है)। सरल वस्तुओं और ऑब्जेक्ट अक्षर के लिए इनमें से कोई भी तरीका ठीक काम करेगा।

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


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

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
}

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

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

आप इसे इस तरह फिर से चालू कर सकते हैं:

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

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


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

Object.keys() पर आप अधिक जानकारी देख सकते हैं

मेरी पसंद ब्राउज़र के मौजूदा संस्करणों में एक तेज़ समाधान के रूप में नीचे है (क्रोम 30, आईई 10, एफएफ 25)

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 पर विभिन्न कार्यान्वयन के साथ इस दृष्टिकोण के प्रदर्शन की तुलना कर सकते हैं:

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

पुराने ब्राउज़र के लिए आपके पास simple और Object.keys() पॉलीफिल है

युपीडी:

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

वस्तु शाब्दिक पुनरावृत्ति


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

चूंकि सादा जे एस वस्तु नहीं है iterable अत्याधुनिक तरीके से, हम उपयोग करने के लिए सक्षम नहीं हैं 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 generators की शक्ति जानते हैं , तो आप निश्चित रूप से कोड को बहुत कम बना सकते हैं।

book[Symbol.iterator] = function *(){

  let properties = Object.keys(this);
  for (let p of properties){
    yield this[p];
  }

}

निश्चित रूप से, आप स्तर Objectपर पुन: प्रयोज्य बनाने के साथ सभी वस्तुओं के लिए इस तरह के व्यवहार लागू कर सकते हैं prototype

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

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

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

या आप destructuring असाइनमेंट का उपयोग कर सकते हैं :

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

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


चूंकि 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] जोड़े को फिर से अधिक आसान बना देगा। अब यह ज्ञात है कि यह ts39 चरण की जानकारी के अनुसार एक मानक का हिस्सा होगा।

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

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

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


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

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


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

let arrValues = Object.values( yourObject) ;

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

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

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

let arrKeys   = Object.keys(yourObject);

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

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


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


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

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


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 लूप में लेकिन प्रोटोटाइप श्रृंखला को अनदेखा करें । केवल ऑब्जेक्ट की अपनी समेकित गुणों को पुनरावृत्त किया जाता है।


प्रस्तावना:

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

यहां 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;
}


यदि आप केवल गुणों पर Object.getOwnPropertyNames(obj) करना चाहते हैं तो ऊपर दिए गए उत्तरों में से एक का उपयोग करें, हालांकि यदि आप कार्यों सहित सबकुछ पर Object.getOwnPropertyNames(obj) करना चाहते हैं, तो आप Object.getOwnPropertyNames(obj) का उपयोग करना चाहेंगेObject.getOwnPropertyNames(obj)

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

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


यदि आप गैर-संख्यात्मक गुणों पर भी पुनरावृत्त करना चाहते हैं , तो आप 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"
};

for (var key in p) {
    if (p.hasOwnProperty(key)) {
        console.log(key + " = " + p[key]);
    }
}
<p>
  Output:<br>
  p1 = values1<br>
  p2 = values2<br>
  p3 = values3
</p>


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

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

Object.keys(p).map((key)=> console.log(key + "->" + p[key]))


एक और समाधान, का उपयोग कर Array#reduce

var myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

myObject = Object.keys(myObject).reduce(function(obj, key) {
  if (key != "regex") {           //key you want to remove
    obj[key] = myObject[key];
  }
  return obj;
}, {});

console.log(myObject);

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

(ES6)

const myObject = {
  ircEvent: 'PRIVMSG',
  method: 'newURI',
  regex: '^http://.*',
};

const myNewObject = Object.keys(myObject).reduce((obj, key) => {
  key !== 'regex' ? obj[key] = myObject[key] : null;
  return obj;
}, {});

console.log(myNewObject);





javascript loops each