javascript - tutorial - কিভাবে আমি একটি জাভাস্ক্রিপ্ট বস্তুর মাধ্যমে লুপ বা enumerate?




জাভাস্ক্রিপ্ট ফাংশন (20)

Object.keys (obj): অ্যারে

সমস্ত সংখ্যাসূচক নিজের (অ-উত্তরাধিকারী) বৈশিষ্ট্যগুলির সমস্ত স্ট্রিং-মূল্যবান কীগুলি পুনরুদ্ধার করে।

তাই আপনি এটিওউনপ্রোগ্রামটি দিয়ে প্রতিটি বস্তুর কী পরীক্ষা করে লক্ষ্য করে কীগুলির একই তালিকা দেয়। আপনি যে অতিরিক্ত পরীক্ষা অপারেশন এবং 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.");

আমার ফায়ারফক্সে আমার নিম্নলিখিত ফলাফল আছে

  • Object.keys পদ্ধতির 40.21101451665163 মিলিসেকেন্ড গ্রহণ করেছে।
  • জন্য ... ইন / আছেOwnProperty পদ্ধতির 98.26163508463651 মিলিসেকেন্ড গ্রহণ করেছে।

গীত। ক্রোমে পার্থক্য এমনকি বড় http://codepen.io/dsheiko/pen/JdrqXa

PS2: ES6 (EcmaScript 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 , p2 , p3 ...) মাধ্যমে লুপ করতে চান এবং তাদের কী এবং মান পেতে। আমি এটা কিভাবে করবো?

প্রয়োজন হলে আমি জাভাস্ক্রিপ্ট বস্তু পরিবর্তন করতে পারেন। আমার চূড়ান্ত লক্ষ্য কিছু মূল মান জোড়া দ্বারা লুপ এবং সম্ভব হলে আমি eval ব্যবহার এড়াতে চান।


ECMAScript 5 এ আপনার আক্ষরিক পুনরাবৃত্তি ক্ষেত্রগুলিতে নতুন পদ্ধতি রয়েছে - Object.keys

আপনি 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 বিভিন্ন বাস্তবায়নের সাথে এই পদ্ধতির কর্মক্ষমতা তুলনা করতে পারেন:

ব্রাউজার সমর্থন আপনি Kangax এর কম্প্যাট টেবিল দেখতে পারেন

পুরানো ব্রাউজারের জন্য আপনার কাছে simple এবং Object.keys() পলিফিল রয়েছে

UPD:

perfjs.info এ এই প্রশ্নে সর্বাধিক জনপ্রিয় ক্ষেত্রে কর্মক্ষমতা তুলনা:

বস্তু আক্ষরিক পুনরাবৃত্তি


অন্যদের দ্বারা দেখানো হিসাবে 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
}

আপনি সমস্ত বস্তুর জন্য প্রতিটি ফাংশনটির জন্য একটি সহজ যোগ করতে পারেন, যাতে আপনি স্বয়ংক্রিয়ভাবে কোনও বস্তুর মাধ্যমে লুপ করতে পারেন:

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 উভয়ের উপর স্পর্শ করেছে তবে তাদের কখনও মিলিত করেনি:

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() কে কুৎসিত / অক্ষম।
আমি খুশি যে বেশিরভাগ লোকের জন্য এগুলি থেকে বিরত .hasOwnProperty() for...in (চেক সহ বা চেক না করে .hasOwnProperty() ) এটি একটি বিট .hasOwnProperty() , তাই উপরের আমার উত্তর ছাড়া অন্য, আমি এখানে বলার জন্য ...

আপনি সাধারণ বস্তু সমিতি পুনরাবৃত্তি করতে পারেন! এর জন্য অভিনবতার সরাসরি ব্যবহারের সাথে Map মত আচরণ for...of
DEMO ক্রোম এবং এফএফ (আমি শুধুমাত্র ES6 অনুমান)

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() মতো কিছু বলা হলে;

//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))

যে কাজ করবে না কোন কারণ নেই।

ভবিষ্যতে স্বাগতম।


এখানে সমস্ত উত্তর সন্ধান করার পরে, আমার নিজের ব্যবহারের জন্যওওয়ানপ্রোপারি প্রয়োজন নেই কারণ আমার জson বস্তুটি পরিষ্কার; কোন অতিরিক্ত জাভাস্ক্রিপ্ট প্রক্রিয়াকরণ যোগ করার সত্যিই কোন জ্ঞান আছে। এই সব আমি ব্যবহার করছি:

for (var key in p) {
    console.log(key + ' => ' + p[key]);
    // key is key
    // value is 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

বস্তুগুলির মাধ্যমে লুপ করার জন্য বিকল্প পদ্ধতি সম্পর্কে উল্লেখ না করলে প্রশ্নটি সম্পূর্ণ হবে না।

আজকাল অনেকগুলি সুপরিচিত জাভাস্ক্রিপ্ট লাইব্রেরিগুলি সংগ্রহগুলি, অর্থাৎ অ্যারে , বস্তু এবং অ্যারের মতো বস্তুর উপর পুনরাবৃত্তি করার জন্য তাদের নিজস্ব পদ্ধতি সরবরাহ করে । এই পদ্ধতি ব্যবহার করার সুবিধাজনক এবং কোনও ব্রাউজারের সাথে সম্পূর্ণরূপে সামঞ্জস্যপূর্ণ।

  1. আপনি যদি jQuery এর সাথে কাজ করেন তবে আপনি jQuery.each() পদ্ধতিটি ব্যবহার করতে পারেন। এটি উভয় বস্তু এবং অ্যারে উপর seamlessly পুনরাবৃত্তি করার জন্য ব্যবহার করা যেতে পারে:

    $.each(obj, function(key, value) {
        console.log(key, value);
    });
    
  2. _.each() আপনি পদ্ধতিটি _.each() খুঁজে পেতে পারেন যা উপাদানগুলির একটি তালিকাতে পুনরাবৃত্তি করে, সরবরাহকৃত ফাংশনে প্রতিফলিত করে ( এটিরটি ফাংশনে আর্গুমেন্টের আদেশের দিকে মনোযোগ দিন!):

    _.each(obj, function(value, key) {
        console.log(key, value);
    });
    
  3. লো-ড্যাশ বস্তুর বৈশিষ্ট্যগুলির উপর পুনরাবৃত্তি করার জন্য বিভিন্ন পদ্ধতি সরবরাহ করে। মৌলিক _.forEach() (অথবা এটির উপনাম _.each() ) উভয় বস্তু এবং অ্যারেগুলির মাধ্যমে লুপ করার জন্য উপকারী, তবে ( length ) বস্তুর _.each() সাথে বস্তুগুলি অ্যারের মতো আচরণ করা হয় এবং এই আচরণ এড়ানোর জন্য এটি _.forIn() এবং _.forOwn() পদ্ধতিগুলি ( _.forOwn() value যুক্তি প্রথম আসছে):

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

    _.forIn() কোনও বস্তুর নিজস্ব এবং উত্তরাধিকারী _.forIn() উপর পুনরাবৃত্তি করে, যখন _.forOwn() কেবল একটি বস্তুর নিজস্ব বৈশিষ্ট্যগুলির উপর পুনরাবৃত্তি করে (মূলত hasOwnProperty ফাংশনের বিরুদ্ধে পরীক্ষা করে)। সহজ বস্তু এবং বস্তু আক্ষরিক জন্য এই পদ্ধতির কোন জরিমানা কাজ করবে।

সাধারণত সমস্ত বর্ণিত পদ্ধতির কোন সরবরাহকৃত বস্তুর সাথে একই আচরণ থাকে। for..in লুপ ব্যবহার করার পাশাপাশি jQuery.each() , যেমন jQuery.each() চেয়ে দ্রুততর হবে, এই পদ্ধতিগুলি ব্যবহার করা সহজতর, এর জন্য কম কোডিং প্রয়োজন এবং উন্নত ত্রুটি পরিচালনা প্রদান করা।


বিশুদ্ধ জাভাস্ক্রিপ্ট ব্যবহার করে Loops খুব আকর্ষণীয় হতে পারে। মনে হচ্ছে শুধুমাত্র ইসিএম 6 (নিউ 2015 জাভাস্ক্রিপ্ট স্পেসিফিকেশন) লুপগুলি নিয়ন্ত্রণে রয়েছে। দুর্ভাগ্যবশত আমি এটি লিখছি, উভয় ব্রাউজার এবং জনপ্রিয় ইন্টিগ্রেটেড ডেভেলপমেন্ট এনভায়রনমেন্ট (আইডিই) এখনও নতুন ঘন্টাধ্বনি এবং সিঁড়িগুলি সম্পূর্ণরূপে সমর্থন করার জন্য সংগ্রাম করছে।

এখানে এক নজরে ECMA6 এর আগে একটি জাভাস্ক্রিপ্ট অবজেক্ট লুপ কেমন দেখাচ্ছে:

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

এছাড়াও, আমি জানি এই প্রশ্নের সাথে এটির সুযোগ নেই কিন্তু ২011 সালে, ECMAScript 5.1 forEachএ্যারেগুলির জন্য পদ্ধতিটি যোগ করেছে যা মূলত অ্যারেগুলির মাধ্যমে লুপের জন্য একটি নতুন উন্নত উপায় তৈরি করেছে, যদিও পুরানো শব্দের এবং বিভ্রান্তিকর forলুপের সাথে অযৌক্তিক অবজেক্টগুলিকে বাদ দিচ্ছে । কিন্তু বিজোড় অংশ হল এই নতুন forEachপদ্ধতিটি সমর্থন করে না breakযা অন্যান্য সমস্যার বিভিন্ন ধরণের দিকে পরিচালিত করে।

২011 সালে মূলত জাভাস্ক্রিপ্টে লুপের মতো অনেক জনপ্রিয় লাইব্রেরির (jQuery, আন্ডারস্কোর, ইত্যাদি) পুনরায় বাস্তবায়ন করার সিদ্ধান্ত নেওয়া হয়নি।

২015 সালের মধ্যে, এখন আমাদের কোনও বস্তুর ধরন (অ্যারে এবং স্ট্রিং সহ) লুপ (এবং বিরতি) বাক্সের দিক থেকে আরও ভাল একটি উপায় রয়েছে। জাভাস্ক্রিপ্টে একটি লুপ অবশেষে যখন মূলধারার হয়ে যায় তখন এটি দেখতে হবে:

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

উল্লেখ্য, সর্বাধিক ব্রাউজার 18 জুন ২016 তারিখের উপরে কোড সমর্থন করবে না। এমনকি Chrome এও আপনাকে এটির জন্য এই বিশেষ পতাকাটি সক্ষম করতে সক্ষম হবে: chrome://flags/#enable-javascript-harmony

এটি নতুন মানদণ্ড না হওয়া পর্যন্ত, পুরানো পদ্ধতিটি এখনও ব্যবহার করা যেতে পারে তবে এই লাইব্রেরিগুলি ব্যবহার না করে এমন জনপ্রিয় লাইব্রেরির বিকল্পগুলি বা এমনকি লাইটওয়েট বিকল্পগুলির বিকল্প রয়েছে


যেহেতু es2015 আরও বেশি জনপ্রিয় হচ্ছে তাই আমি এই উত্তরটি পোস্ট করছি যা জেনারেটর এবং ইটারারটার ব্যবহারকে [key, value] জোড়াগুলির মাধ্যমে সহজে পুনরাবৃত্তি করতে অন্তর্ভুক্ত করে। উদাহরণস্বরূপ Ruby উদাহরণস্বরূপ অন্যান্য ভাষায় সম্ভব।

ঠিক আছে এখানে একটি কোড আছে:

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 অবজেক্ট.েন্ট্রিগুলিকে অন্তর্ভুক্ত করবে যা বস্তুগুলিতে [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.keys() পদ্ধতি একটি প্রদত্ত বস্তুর নিজস্ব সংখ্যাসূচক বৈশিষ্ট্যগুলির একটি অ্যারে প্রদান করে। Object.keys() এটি সম্পর্কে আরও পড়ুন

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

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


ES6 তে আমাদের কিছু পূর্ববর্তী অভ্যন্তরীণ পদ্ধতি প্রকাশ করার জন্য সুপরিচিত প্রতীক রয়েছে, আপনি এটির জন্য কীভাবে এটিরেটরগুলি কাজ করে তা নির্ধারণ করতে এটি ব্যবহার করতে পারেন:

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

কিন্তু এখনই এস 6 ব্যবহার করে আপনার দক্ষতা জানা জরুরি!


ES6 বিবেচনা করে আমি চিনির নিজের চামচ যোগ করতে চাই এবং বস্তুর বৈশিষ্ট্যগুলির উপর পুনরাবৃত্তি করার আরও একটি পদ্ধতি সরবরাহ করতে চাই।

যেহেতু প্লেইন জাতীয় অবজেক্ট নয় iterable শুধু বাক্সের বাইরে, আমরা ব্যবহার করতে সক্ষম হয় না for..ofতার কন্টেন্ট উপর iterating জন্য লুপ। কিন্তু এটি আমাদের এটিকে কার্যকর করার জন্য থামাতে পারে না

আসুন আমরা 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 চেক আউট করতে পারেন ।


যখন এটি .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

সর্বশেষ ES স্ক্রিপ্টে, আপনি এমন কিছু করতে পারেন:

Object.entries(p);

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>


আমি 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)কোনও বস্তুর উপর সরাসরি পাওয়া সমস্ত বৈশিষ্ট্যগুলির একটি সংখ্যা (সংখ্যাবহুল বা না) ফেরত দিতে ব্যবহার করতে পারেন।

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


যদি আপনি শুধুমাত্র বৈশিষ্ট্যগুলির উপর পুনরাবৃত্তি করতে চান তবে উপরের উত্তরগুলির মধ্যে একটি ব্যবহার করুন, তবে যদি আপনি ফাংশন সহ সবকিছুতে পুনরাবৃত্তি করতে চান তবে আপনি Object.getOwnPropertyNames(obj) ব্যবহার করতে চাইতে পারেন।Object.getOwnPropertyNames(obj)

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

আমি মাঝে মাঝে সহজ ইনপুট এবং আউটপুট সঙ্গে বস্তুর সব ফাংশন পরীক্ষা করার জন্য এই ব্যবহার।






each