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

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

විචල්‍යය proptවස්තුවේ ගුණාංග නිරූපණය කරන්නේ කෙසේද ? එය ගොඩනංවන ක්‍රමයක් හෝ දේපලක් නොවේ. වස්තුවේ ඇති සෑම දේපලක් සමඟම එය පැමිණෙන්නේ ඇයි?

දේපල ඉක්මවා යෑමට මෙම අමතර 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

ජාවාස්ක්‍රිප්ට් 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 
});

For-in loop එකක් භාවිතා කරනවාට වඩා මෙය හොඳය (සහ කියවිය හැකි).

මෙම බ්‍රව්සර් සඳහා එය සහාය දක්වයි:

• ෆයර්ෆොක්ස් (හූනා): 4 (2.0)
• Chrome: 5
• ඉන්ටර්නෙට් එක්ස්ප්ලෝරර්: 9

වැඩි විස්තර සඳහා මොසිල්ලා සංවර්ධක ජාල Object.keys () හි යොමුව බලන්න.

ගැහැණු ළමයින් සහ පිරිමි ළමයින් අපි 2019 දී සිටින අතර අපට ටයිප් කිරීමට එතරම් කාලයක් නොමැත ... එබැවින් මෙම සිසිල් නව විසිතුරු ECMAScript 2016 කිරීමට ඉඩ දෙන්න:

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

එය for...in statement( MDN , ECMAScript පිරිවිතර ) ය.

ඔබ "ලෙස කියවිය නොහැකි සඳහා සෑම දේපල IN එම objවස්තුව, එම එක් එක් දේපළ පැවරීමට PROPT අනෙක් අතට විචල්ය".

ඊඑස් යාවත්කාලීනව ක්‍රියාත්මක කිරීමේදී, ඔබට මෙය භාවිතා කළ හැකිය 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 => ...)

එය for...inපුඩුවක් පමණි. මොසිල්ලා හි ඇති ලියකියවිලි බලන්න .

ඔබේ පරිසරය ES2017 සඳහා සහය දක්වන්නේ නම් මම නිර්දේශ කරන්නේ Object.entries :

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

මොසිලස් Object.entries () ප්‍රලේඛනයේ පෙන්වා ඇති පරිදි :

මෙම Object.entries () ක්රමය සඳහා ... කේන්දුයේ (වෙනස වීම සඳහා-දී පුඩුවක් මඟින් කියවෙනුයේ අන්තර්ගතව ඇති සපයන බව මෙන් ම සඳහා, දී ඇති වස්තුව ම ගණ්ය දේපල රැසක් [යතුර, අගය] යුගල නැවත මූලාකෘති දාමයේ ගුණාංග ද).

මූලික වශයෙන් Object.entries සමඟ අපට පැරණි ... ලූප් සඳහා අවශ්‍ය වන පහත සඳහන් අමතර පියවර අත්හැර දැමිය හැකිය :

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

jquery ඔබට දැන් මෙය කිරීමට ඉඩ දෙයි:

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

ඩොමිනික්ගේ පිළිතුර පරිපූර්ණයි, කියවීමට වඩා පිරිසිදු බැවින් මම එය එසේ කිරීමට කැමැත්තෙමි:

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

    // Do stuff...
}

ඉහත පිළිතුරු ටිකක් කරදරකාරී වන්නේ ඔබ එය වස්තුවක් බව සහතික කිරීමෙන් පසුව ඔබ ලූපය තුළ කරන්නේ කුමක්ද යන්න පැහැදිලි නොකරන බැවිනි: ඔබ එය සෘජුවම ලබා නොගනී! ඔබ සැබවින්ම ලබා දෙන්නේ ඔබ OBJ වෙත අයදුම් කළ යුතු KEY පමණි:

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 ආරක්ෂිතයි. රයිනෝ වැනි කොර වූ ජේඑස් අනුවාදවල පවා ක්‍රියා කරයි;)

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 its length. At this point, it checks: 
// If it has at least one element, it means 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]);
    });
}

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 නූල්, අරා, ටයිප් කළ අරා, සිතියම සහ කට්ටලය සඳහා ජාවාස්කිප්ට්ස් හි පෙරනිමි අනුකාරක මෙන් .

JS විසින් පෙරනිමි iterator දේපල හරහා නැවත යෙදීමට උත්සාහ කරනු ඇත, එය අර්ථ දැක්විය යුතුය 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 ජූනි) අනෙක් සියලුම බ්‍රව්සර්, නමුත් අයිඊ, ආධාරක ජනක යන්ත්‍ර සහ නැවත for...ofක්‍රියාත්මක කිරීමSymbol.iterator

For ... in loop මඟින් වස්තුවක එක් එක් දේපල නිරූපණය කරන්නේ එය for for loop හා සමාන වන බැවිනි. ඔබ විසින් ... සඳහා පුඩුවක් අර්ථ දැක්වුවේ:

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

A for ... loop එකකින් වස්තුවක ගණන් කළ නොහැකි ගුණාංග හරහා නැවත ගමන් කරයි. ඔබ කුමන විචල්‍යය නිර්වචනය කළත්, හෝ ... ... ලූපයෙහි තැබූ විට, එය ඊළඟ දේපල වෙත යන සෑම අවස්ථාවකම එය වෙනස් වේ. For ... in loop හි විචල්‍යය යතුරු හරහා පුනරාවර්තනය වේ, නමුත් එහි වටිනාකම යතුරේ අගය වේ. උදාහරණයක් වශයෙන්:

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

විචල්‍යය විචල්‍යයේ අගයට වඩා වෙනස් වන්නේ කෙසේදැයි ඔබට දැක ගත හැකිය. ඊට වෙනස්ව, for ... for loop ප්‍රතිවිරුද්ධ දේ කරයි.

මම හිතනවා මේක උදව් වෙයි කියලා.

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

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

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

// a
// 3
// 2

ඔබට ලොඩාෂ් භාවිතා කළ හැකිය. ප්‍රලේඛනය

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

ඔබේ forලූපය වස්තුවේ සියලුම ගුණාංග ඉක්මවා යයි obj. proptඔබේ ලූපයේ පළමු පේළියේ අර්ථ දක්වා ඇත. එය objවස්තුවක දේපලක නමකි . ලූපයේ පළමු පුනරාවර්තනයේදී, propt"නම" වනු ඇත.

ජාවාස්ක්‍රිප්ට් හි ඇති වස්තු ගුණාංග එකතුවක් වන අතර එම නිසා සෑම ප්‍රකාශයක් සඳහාම එය ලූප කළ හැකිය.

objප්‍රධාන වටිනාකම් එකතුවක් ලෙස ඔබ සිතිය යුතුය .

වර්තමානයේ ඔබට Symbol.iterator ක්‍රමයක් එකතු කිරීමෙන් සම්මත JS වස්තුවක් නැවත ලබා ගත හැකි වස්තුවක් බවට පරිවර්තනය කළ හැකිය. එවිට ඔබට 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);

නෝඩ් ධාවනය කරන්නේ නම් මම නිර්දේශ කරමි:

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

ඉහළ ශ්‍රේණිගත කළ පිළිතුර නිවැරදි වුවත්, මෙන්න විකල්ප භාවිත අවස්ථාවකි, එනම් ඔබ වස්තුවක් හරහා නැවත ක්‍රියා කරන්නේ නම් සහ අවසානයේ අරාවක් නිර්මාණය කිරීමට අවශ්‍ය නම්. .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]
})

පුනරාවර්තන මාර්ගයද එකතු කිරීම:

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

..ඉන් ලූපය සඳහා කරන්නේ එය නව විචල්‍යයක් (var someVariable) නිර්මාණය කර දී ඇති වස්තුවේ එක් එක් දේපල මෙම නව විචල්‍යය තුළ (යම් විචල්‍යතාවයකින්) එකින් එක ගබඩා කිරීමයි. එබැවින් ඔබ block block බ්ලොක් භාවිතා කරන්නේ නම්, ඔබට නැවත යෙදිය හැකිය. පහත උදාහරණය සලකා බලන්න.

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

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

console.log(someVariable); // outputs planet

මෙන්න මම සෑම නෝඩයක්ම නැවත සකසමින් අර්ථවත් නෝඩ් නම් නිර්මාණය කරමි. ඔබ දුටුවහොත්, instanceOf Array සහ instanceOf Object එකම දේම කරයි (මගේ යෙදුමේ, මම වෙනස් තර්කනයක් ලබා දුන්නද)

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

සටහන - ඔන්ඩ්‍රෙජ් ස්වෙජ්ඩාර්ගේ පිළිතුරෙන් මා ආශ්වාදයක් ලැබීය. නමුත් මෙම විසඳුමට වඩා හොඳ කාර්ය සාධනයක් සහ අඩු අපැහැදිලි බවක් ඇත

ඔබට මූලික වශයෙන් අවශ්‍ය වන්නේ වස්තුවේ එක් එක් දේපල හරහා ලූපය.

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

ඔබට ජාවාස්ක්‍රිප්ට් වෙතින් වෙනස් අභිප්‍රායන් තිබිය හැකි නිසා ඉහත පිළිතුරු වලට එක් කිරීමට මට අවශ්‍යය. 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]);

            }

     }
}

තවදුරටත් බේරුම් කිරීමට පිළිගත් පිළිතුර එය වටිනා ඔබ සමග වස්තුව instantiate නම් බව සඳහන් var object = Object.create(null)පසුව object.hasOwnProperty(property)එය TypeError පුපුරවා හරිනු ඇත. එබැවින් ආරක්ෂිත පැත්තේ සිටීමට නම්, ඔබට එය මෙවැනි මූලාකෘතියෙන් ඇමතිය යුතුය:

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

මෙම සබැඳිය පරීක්ෂා කිරීමෙන් එය 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);

චෙක් වර්ගය

Propt විසින් වස්තු නිසි පරිදි නිරූපණය කරන්නේ කෙසේදැයි ඔබට පරීක්ෂා කළ හැකිය

typeof propt

එය හුදෙක් නූලක් (දේපල නම) බව සොයා ගැනීමට. for-inJs "ගොඩනංවන" ලූපය ක්‍රියා කරන ආකාරය නිසා එය වස්තුවේ සෑම දේපලක් සමඟම පැමිණේ .

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

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