정렬 된 순서로 Javascript 연관 배열을 반복합니다.

Javascript 연관 배열 (일명 해시, 일명 사전)이 있다고 가정 해 보겠습니다.

var a = new Array();
a['b'] = 1;
a['z'] = 1;
a['a'] = 1;

정렬 된 순서로 키를 어떻게 반복 할 수 있습니까? 일을 단순화하는 데 도움이된다면 값도 필요하지 않습니다 (모두 숫자 1 일뿐입니다).

직접 반복 할 수는 없지만 모든 키를 찾은 다음 정렬 할 수 있습니다.

var a = new Array();
a['b'] = 1;
a['z'] = 1;
a['a'] = 1;    

function keys(obj)
{
    var keys = [];

    for(var key in obj)
    {
        if(obj.hasOwnProperty(key))
        {
            keys.push(key);
        }
    }

    return keys;
}

keys(a).sort(); // ["a", "b", "z"]

그러나 변수 'a'를 배열로 만들 필요는 없습니다. 당신은 정말로 그것을 객체로 사용하고 있으며 다음과 같이 만들어야합니다.

var a = {};
a["key"] = "value";

Object.keys 내장 메서드를 사용할 수 있습니다 .

var sorted_keys = Object.keys(a).sort()

(참고 : EcmaScript5, 특히 IE6, 7 및 8을 지원하지 않는 매우 오래된 브라우저에서는 작동하지 않습니다. 자세한 최신 통계는 이 표를 참조하십시오. )

객체에 프로토 타입을 만들 수도 있습니다.

Object.prototype.iterateSorted = function(worker)
{
    var keys = [];
    for (var key in this)
    {
        if (this.hasOwnProperty(key))
            keys.push(key);
    }
    keys.sort();

    for (var i = 0; i < keys.length; i++)
    {
        worker(this[ keys[i] ]);
    }
}

및 사용법 :

var myObj = { a:1, b:2 };
myObj.iterateSorted(function(value)
{
    alert(value);
} 

나는 Swingley의 답변에 동의하며 더 정교한 솔루션이 많이 누락되어 중요한 점이라고 생각합니다. 연관 배열의 키에만 관심이 있고 모든 값이 '1'이면 '키'를 배열의 값으로 저장하면됩니다.

대신에:

var a = { b:1, z:1, a:1 };
// relatively elaborate code to retrieve the keys and sort them

사용하다:

var a = [ 'b', 'z', 'a' ];
alert(a.sort());

한 가지 단점은 특정 키가 쉽게 설정되었는지 여부를 확인할 수 없다는 것입니다. 이 문제에 대한 답변 은 javascript function inArray에 대한 답변 을 참조하십시오 . 제시된 솔루션의 한 가지 문제 a.hasValue('key')는 a['key']. 그것은 당신의 코드에서 중요하거나 중요하지 않을 수 있습니다.

Javascript 객체의 "키"를 직접 조작하는 간결한 방법은 없습니다. 그것은 실제로 그것을 위해 설계되지 않았습니다. 일반 객체 (또는 샘플 코드에서 알 수 있듯이 배열)보다 더 나은 데이터를 자유롭게 배치 할 수 있습니까?

그렇다면 질문이 "정렬 된 순서로 키를 반복하려면 어떤 사전과 같은 객체를 사용해야합니까?"로 다시 표현 될 수 있습니다. 다음과 같은 객체를 개발할 수 있습니다.

var a = {
  keys : new Array(),
  hash : new Object(),
  set : function(key, value) {
    if (typeof(this.hash[key]) == "undefined") { this.keys.push(key); }
    this.hash[key] = value;
  },
  get : function(key) {
    return this.hash[key];
  },
  getSortedKeys : function() {
    this.keys.sort();
    return this.keys;
  }
};

// sample use
a.set('b',1);
a.set('z',1);
a.set('a',1);
var sortedKeys = a.getSortedKeys();
for (var i in sortedKeys) { print(sortedKeys[i]); }

데이터가 일반 객체에 있다는 사실을 제어 할 수없는 경우이 유틸리티는 일반 객체를 완전한 기능의 사전으로 변환합니다.

a.importObject = function(object) {
  for (var i in object) { this.set(i, object); }
};

이것은 단순성을 위해 객체 정의 (재사용 가능한 생성자 함수 대신)였습니다. 마음대로 편집하십시오.

첫 번째 for루프 에서 키를 가져 와서 정렬하고, 두 번째 for루프 에서 정렬 된 결과를 사용합니다 .

var a = new Array();
a['b'] = 1;
a['z'] = 1;
a['a'] = 1;

var b = [];
for (k in a) b.push(k);
b.sort();
for (var i = 0; i < b.length; ++i) alert(b[i]);

underscore.js 라이브러리 의 keys함수를 사용하여 키를 가져온 다음 배열 메서드를 사용하여 정렬 할 수 있습니다.sort()

var sortedKeys = _.keys(dict).sort();

keys밑줄의 소스 코드의 기능 :

// Retrieve the names of an object's properties.
// Delegates to **ECMAScript 5**'s native `Object.keys`
_.keys = nativeKeys || function(obj) {
    if (obj !== Object(obj)) throw new TypeError('Invalid object');
    var keys = [];
    for (var key in obj) if (_.has(obj, key)) keys.push(key);
    return keys;
};    

// Shortcut function for checking if an object has a given property directly
// on itself (in other words, not on a prototype).
_.has = function(obj, key) {
    return hasOwnProperty.call(obj, key);
};

<script type="text/javascript">
    var a = {
        b:1,
        z:1,
        a:1
    }; // your JS Object
    var keys = [];
    for (key in a) {
        keys.push(key);
    }
    keys.sort();
    var i = 0;
    var keyslen = keys.length;
    var str = '';
    //SORTED KEY ITERATION
    while (i < keyslen) {
        str += keys[i] + '=>' + a[keys[i]] + '\n';
        ++i;
    }
    alert(str);
    /*RESULT:
    a=>1
    b=>1
    z=>1
    */
</script>

저는 @ luke-schafer의 프로토 타입 아이디어를 정말 좋아하지만 프로토 타입 문제에 대해 그가 말하는 것도 듣습니다. 간단한 기능을 사용하는 것은 어떻습니까?

function sortKeysAndDo( obj, worker ) {
  var keys = Object.keys(obj);
  keys.sort();
  for (var i = 0; i < keys.length; i++) {
     worker(keys[i], obj[keys[i]]);
  }
}

function show( key, value ) {
  document.write( key + ' : ' + value +'<br>' );
}

var a = new Array();
a['b'] = 1;
a['z'] = 1;
a['a'] = 1;

sortKeysAndDo( a, show);

var my_object = { 'c': 3, 'a': 1, 'b': 2 };

sortKeysAndDo( my_object, show);

이것은 프로토 타입의 문제를 제거하고 여전히 객체에 대해 정렬 된 반복자를 제공하는 것처럼 보입니다. 하지만 저는 JavaScript 전문가가 아니기 때문에이 솔루션에 제가 놓친 숨겨진 결함이 있는지 알고 싶습니다.