ජාවාස්ක්‍රිප්ට් වස්තුවක ගුණාංග ලැයිස්තුගත කරන්නේ කෙසේද?

මම මෙසේ වස්තුවක් නිර්මාණය කළ බව පවසන්න:

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

දේපල නම් ලැයිස්තුවක් ලබා ගැනීමට හොඳම ක්‍රමය කුමක්ද? එනම් විචල්ය යතුරු කිහිපයක් සමඟ අවසන් කිරීමට මම කැමතියි:

keys == ["ircEvent", "method", "regex"]

නවීන බ්‍රව්සර් වලදී (IE9 +, FF4 +, Chrome5 +, Opera12 +, Safari5 +) ඔබට ගොඩනගා ඇති Object.keys ක්‍රමය භාවිතා කළ හැකිය :

var keys = Object.keys(myObject);

ඉහත සම්පූර්ණ පොලිෆිල් එකක් ඇති නමුත් සරල කළ අනුවාදයක් නම්:

var getKeys = function(obj){
   var keys = [];
   for(var key in obj){
      keys.push(key);
   }
   return keys;
}

විකල්පයක් ලෙස වෙනුවට var getKeysසමග Object.prototype.keysඔබ කතා කිරීමට ඉඩ .keys()ඕනෑම වස්තුවක් මත. මූලාකෘතිය දීර් ing කිරීමෙන් අතුරු ආබාධ ඇති අතර එය සිදු කිරීම මම නිර්දේශ නොකරමි.

ලෙස slashnick පෙන්වා, ඔබ එහි විශේෂණය නම් සඳහා වස්තුවක් කෙරෙහි වඩාත් කැපීපෙනේ කිරීමට ඉදිකිරීමක් "තුළ සඳහා" භාවිතා කළ හැක. කෙසේ වෙතත් ඔබ වස්තුවේ මූලාකෘති දාමයේ ඇති සියලුම ගුණාංග නාමයන් නැවත කියනු ඇත. ඔබට වස්තුවේ ගුණාංග මත පමණක් නැවත යෙදීමට අවශ්‍ය නම් , ඔබට වස්තුව # hasOwnProperty () ක්‍රමය භාවිතා කළ හැකිය. මේ අනුව පහත සඳහන් දේ ඇත.

for (var key in obj) {
    if (obj.hasOwnProperty(key)) {
        /* useful code here */
    }
}

සෑම් ඩටන් පිළිතුරු දුන් පරිදි, මේ සඳහාම නව ක්‍රමයක් ECMAScript 5 වන සංස්කරණයේ හඳුන්වා දී ඇත. Object.keys()ඔබට අවශ්‍ය දේ කරනු ඇති අතර එය ෆයර්ෆොක්ස් 4 , ක්‍රෝම් 6, සෆාරි 5 සහ අයිඊ 9 හි සහය දක්වයි .

ඔබට සහාය නොදක්වන බ්‍රව්සර් තුළද මෙම ක්‍රමය ඉතා පහසුවෙන් ක්‍රියාත්මක කළ හැකිය. කෙසේ වෙතත්, එහි ක්‍රියාත්මක කිරීම් සමහරක් ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් සමඟ සම්පුර්ණයෙන්ම අනුකූල නොවේ. මෙන්න වඩාත් අනුකූල විසඳුමක්:

Object.keys = Object.keys || (function () {
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !{toString:null}.propertyIsEnumerable("toString"),
        DontEnums = [ 
            'toString', 'toLocaleString', 'valueOf', 'hasOwnProperty',
            'isPrototypeOf', 'propertyIsEnumerable', 'constructor'
        ],
        DontEnumsLength = DontEnums.length;

    return function (o) {
        if (typeof o != "object" && typeof o != "function" || o === null)
            throw new TypeError("Object.keys called on a non-object");

        var result = [];
        for (var name in o) {
            if (hasOwnProperty.call(o, name))
                result.push(name);
        }

        if (hasDontEnumBug) {
            for (var i = 0; i < DontEnumsLength; i++) {
                if (hasOwnProperty.call(o, DontEnums[i]))
                    result.push(DontEnums[i]);
            }   
        }

        return result;
    };
})();

දැනට පිළිගත් පිළිතුරට hasOwnProperty () සඳහා චෙක්පතක් ඇතුළත් නොවන අතර මූලාකෘති දාමය හරහා උරුම වූ දේපල නැවත ලබා දෙන බව සලකන්න . ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හි සුප්‍රසිද්ධ ඩොන්ට්එනම් දෝෂය සඳහා ද එය හේතු නොවේ, එහිදී මූලාකෘති දාමයේ ගණන් කළ නොහැකි ගුණාංග දේශීයව ප්‍රකාශයට පත් කරන ලද දේපල එකම නමක් සහිත ඩොන්ට්එනම් ගුණාංගයට උරුම වීමට හේතු වේ.

Object.keys () ක්‍රියාත්මක කිරීමෙන් ඔබට වඩාත් ශක්තිමත් විසඳුමක් ලැබෙනු ඇත.

සංස්කරණය කරන්න: මූලාකෘති සඳහා සුප්‍රසිද්ධ දායකයෙකු වන කැන්ගක්ස් සමඟ මෑතකදී කළ සාකච්ඡාවකින් පසුව , ඩොන්ට්එනම් දෝෂය සඳහා වන Object.forIn()ක්‍රියාකාරිත්වය මෙහි ඇති කේතයේ කේතය මත පදනම්ව ක්‍රියාත්මක කළෙමි .

Object.keys සහ අනෙකුත් ECMAScript 5 ක්‍රම සඳහා ෆයර්ෆොක්ස් 4, ක්‍රෝම් 6, සෆාරි 5, අයිඊ 9 සහ ඊට ඉහළින් සහාය දක්වන බව සලකන්න.

උදාහරණයක් වශයෙන්:

var o = {"foo": 1, "bar": 2}; 
alert(Object.keys(o));

ECMAScript 5 අනුකූලතා වගුව: http://kangax.github.com/es5-compat-table/

නව ක්‍රම පිළිබඳ විස්තරය: http://markcaudill.com/index.php/2009/04/javascript-new-features-ecma5/

Object.getOwnPropertyNames(obj)

මෙම ශ්‍රිතය මඟින් පෙන්වන ලද ඒවාට අමතරව ගණන් කළ නොහැකි ගුණාංග ද පෙන්වයි Object.keys(obj).

JS හි, සෑම දේපලකටම බූලියන් ඇතුළු දේපල කිහිපයක් තිබේ enumerable.

පොදුවේ ගත් කල, ගණනය කළ නොහැකි ගුණාංග වඩාත් "අභ්‍යන්තර" වන අතර අඩු වාර ගණනක් භාවිතා වේ, නමුත් ඇත්ත වශයෙන්ම සිදුවන්නේ කුමක්ද යන්න බැලීමට සමහර විට ඒවා සොයා බැලීම බුද්ධිමත් ය.

උදාහරණයක්:

var o = Object.create({base:0})
Object.defineProperty(o, 'yes', {enumerable: true})
Object.defineProperty(o, 'not', {enumerable: false})

console.log(Object.getOwnPropertyNames(o))
// [ 'yes', 'not' ]

console.log(Object.keys(o))
// [ 'yes' ]

for (var x in o)
    console.log(x)
// yes, base

කෙසේද යන්නත් සටහන් කරන්න:

• Object.getOwnPropertyNamesහා Object.keys නෑ සොයා ගැනීමට පතිරූපක දාම යන්නbase
• for in කරයි

මෙහි ඇති මූලාකෘති දාමය පිළිබඳ වැඩි විස්තර: https://stackoverflow.com/a/23877420/895245

මම ඩම්ප් ශ්‍රිතයේ විශාල රසිකයෙක්.

http://ajaxian.com/archives/javascript-variable-dump-in-coldfusion

පහත පරිදි jQuery සමඟ එය කළ හැකිය:

var objectKeys = $.map(object, function(value, key) {
  return key;
});

ඔබ මූලද්‍රව්‍ය පමණක් ලබා ගැනීමට උත්සාහ කරන නමුත් කාර්යයන් නොවේ නම් මෙම කේතය ඔබට උදව් වනු ඇත

this.getKeys = function() {

    var keys = new Array();
    for(var key in this) {

        if( typeof this[key] !== 'function') {

            keys.push(key);
        }
    }
    return keys;
}

මෙය මම හැෂ්මැප් ක්‍රියාත්මක කිරීමේ කොටසක් වන අතර මට අවශ්‍ය වන්නේ යතුරු පමණි, "මෙය" යනු යතුරු අඩංගු හැෂ්මැප් වස්තුවයි

IE8 හි පවා බොහෝ බ්‍රව්සර් වල මෙය ක්‍රියාත්මක වන අතර කිසිදු ආකාරයක පුස්තකාල අවශ්‍ය නොවේ. var i ඔබේ යතුරයි.

var myJSONObject =  {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"}; 
var keys=[];
for (var i in myJSONObject ) { keys.push(i); }
alert(keys);

Js 1.8 සඳහා සහය දක්වන බ්‍රව්සර් යටතේ:

[i for(i in obj)]

එය සහාය නොදක්වන බ්‍රව්සරයක එය කරන්නේ කෙසේද යන්න පිළිබඳ සම්පූර්ණ ක්‍රියාත්මක කිරීමේ තොරතුරු මොසිල්ලා සතුව ඇත .

if (!Object.keys) {
  Object.keys = (function () {
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
        dontEnums = [
          'toString',
          'toLocaleString',
          'valueOf',
          'hasOwnProperty',
          'isPrototypeOf',
          'propertyIsEnumerable',
          'constructor'
        ],
        dontEnumsLength = dontEnums.length;

    return function (obj) {
      if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object');

      var result = [];

      for (var prop in obj) {
        if (hasOwnProperty.call(obj, prop)) result.push(prop);
      }

      if (hasDontEnumBug) {
        for (var i=0; i < dontEnumsLength; i++) {
          if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i]);
        }
      }
      return result;
    };
  })();
}

ඔබ කැමති ආකාරයට එය ඇතුළත් කළ හැකිය, නමුත් සමහර විට extensions.jsඔබේ ස්ක්‍රිප්ට් තොගයේ ඉහළින් ඇති කිසියම් ගොනුවක.

භාවිත Reflect.ownKeys()

var obj = {a: 1, b: 2, c: 3};
Reflect.ownKeys(obj) // ["a", "b", "c"]

Object.keys හා Object.getOwnPropertyNames ලබා ගැනීමට නොහැකි -ගණ්ය නොවන ගුණ. ගණනය කළ නොහැකි දේපල සඳහා පවා එය ක්‍රියා කරයි.

var obj = {a: 1, b: 2, c: 3};
obj[Symbol()] = 4;
Reflect.ownKeys(obj) // ["a", "b", "c", Symbol()]

දේශීය දේපල සඳහා IE (i obj) සඳහා සහය නොදක්වයි. මෙන්න මට සොයා ගත හැකි සියලුම මුක්කු ලැයිස්තුවක්.

ස්ටැක් ඕවර් ප්‍රවාහය මෝඩ පෙරනයක් කරන බව පෙනේ.

මෙම ගූගල් කණ්ඩායම් පෝස්ටයේ පහළින් ලැයිස්තුව ලබා ගත හැකිය: - https://groups.google.com/group/hackvertor/browse_thread/thread/a9ba81ca642a63e0

සෑම ව්‍යාපෘතියකම පාහේ මම underscore.js භාවිතා කරන බැවින්, මම keysශ්‍රිතය භාවිතා කරමි :

var obj = {name: 'gach', hello: 'world'};
console.log(_.keys(obj));

එහි ප්‍රතිදානය වනුයේ:

['name', 'hello']

පිළිගත් පිළිතුර මත ගොඩනැගීම.

වස්තුවට ගුණාංග තිබේ නම් ඔබට අමතන්න .Properties () උත්සාහ කරන්න!

var keys = Object.keys(myJSONObject);

for (var j=0; j < keys.length; j++) {
  Object[keys[j]].properties();
}

විසඳුම මගේ නඩු සහ හරස් බ්‍රව්සරය මත ක්‍රියා කරයි:

var getKeys = function(obj) {
    var type = typeof  obj;
    var isObjectType = type === 'function' || type === 'object' || !!obj;

    // 1
    if(isObjectType) {
        return Object.keys(obj);
    }

    // 2
    var keys = [];
    for(var i in obj) {
        if(obj.hasOwnProperty(i)) {
            keys.push(i)
        }
    }
    if(keys.length) {
        return keys;
    }

    // 3 - bug for ie9 <
    var hasEnumbug = !{toString: null}.propertyIsEnumerable('toString');
    if(hasEnumbug) {
        var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

        var nonEnumIdx = nonEnumerableProps.length;

        while (nonEnumIdx--) {
            var prop = nonEnumerableProps[nonEnumIdx];
            if (Object.prototype.hasOwnProperty.call(obj, prop)) {
                keys.push(prop);
            }
        }

    }

    return keys;
};