如何在Javascript中对哈希表排序？_Javascript_Sorting_Hashtable

如何在Javascript中对哈希表排序？

javascript sorting

如何在Javascript中对哈希表排序？,javascript,sorting,hashtable,Javascript,Sorting,Hashtable,我有一个Javascript哈希表，如下所示： var things = [ ]; things["hello"] = {"name" : "zzz I fell asleep", "number" : 7}; things["one"] = {"name" : "something", "number" : 18}; things["two"] = {"name" : "another thing", "number" : -2}; 我想按名称对它们进行排序，因此，如果我遍历哈希表，它将按顺

我有一个Javascript哈希表，如下所示：

var things = [ ];
things["hello"] = {"name" : "zzz I fell asleep", "number" : 7};
things["one"] = {"name" : "something", "number" : 18};
things["two"] = {"name" : "another thing", "number" : -2};

我想按名称对它们进行排序，因此，如果我遍历哈希表，它将按顺序排列

another thing
something
zzz I fell asleep

我试着这样做：

function compareThings(thing1, thing2) {
    var name1 = thing1["name"].toLowerCase();
    var name2 = thing2["name"].toLowerCase();
    if (name1 < name2) {
        return -1;
        }
    if (name1 > name2) {
        return 1;
        }
    return 0;
}

things.sort(compareThings);

功能比较（第1项、第2项）{
var name1=thing1[“name”].toLowerCase（）；
var name2=thing2[“name”].toLowerCase（）；
如果（名称1<名称2）{
返回-1；
}
如果（名称1>名称2）{
返回1；
}
返回0；
}
事物。分类（比较）；

但它似乎不起作用

编辑：我突然想到，排序哈希表可能是一种矛盾修饰法。如果是这样的话，访问这里的排序列表的最佳方法是什么？

您的参数是

thing1

和

thing2

，但您引用的是一些名为

asp1

和

asp2

的变量，从您提供的源代码来看，这些变量并不存在

另外，我认为您要寻找的是一个关联数组，它不是用

[]

语法实例化的。有关更多信息，请参见此处：

编辑：我认为Javascript中没有一个数组可以让你随心所欲

您可以使用普通的旧数组，它可以让您进行自定义排序，也可以使用关联数组，它可以让您获得命名值

使用正则数组，显然可以遍历索引

使用关联数组，您可以通过执行

for（myArray中的var key）

来迭代名称，如果您希望依次迭代JavaScript中的哈希表，则创建一个数组，用哈希键填充它，然后对其排序

<html>
<body>
<pre>
  <script>
    var things = new Object ();
    things["hello"] = {"name" : "zzz I fell asleep", "number" : 7};
    things["one"] = {"name" : "something", "number" : 18};
    things["two"] = {"name" : "another thing", "number" : -2};
    var keys = [];
    for (var key in things) {
      if (things.hasOwnProperty(key)) {
        keys.push(key);
      }
    }
    keys.sort ();
    for (i in keys) {
      var key = keys[i];
      var value = things[key];
      document.write (key +"="+value+"\n");
    }
  </script>
</pre>
</body>
</html>


var things=newobject（）；
事物[“你好”]={“名字”：“我睡着了”，“号码”：7}；
事物[“一”]={“名称”：“某物”，“数字”：18}；
事物[“两”]={“名称”：“另一事物”，“数字”：-2}；
var键=[]；
for（var关键字）{
if（things.hasOwnProperty（key））{
按键。按（键）；
}
}
keys.sort（）；
用于（i在键中）{
var key=key[i]；
var值=事物[关键]；
document.write（键+“=”+值+“\n”）；
}

我的解决方案

function sortHashTableByKey(hash, key_order, remove_key)
{
    var tmp = [],
        end = [],
        f_order = null;
    remove_key = remove_key || false;
    for (var key in hash)
    {
        if (hash.hasOwnProperty(key))
        {
            tmp.push(hash[key][key_order]);
        }
    }
    if (hash && hash[0] && typeof(hash[0][key_order]) === 'number')
    {
        f_order = function (a, b) { return a - b; };
    }
    tmp.sort(f_order);
    function getHash(hash, value)
    {
        for (k in hash)
        {
            if (hash[k] && hash[k][key_order] === value)
            {
                return { key : k, hash : hash[k] };
            }
        }
    }
    for (var i = 0, l = tmp.length; i < l; i++)
    {
        tmp[i] = getHash(hash, tmp[i]);
        if (remove_key)
        {
            delete tmp[i].hash[key_order];
        }
        if (!hash.length)
        {
            end[tmp[i].key] = tmp[i].hash;
        }
        else
        {
            end.push(tmp[i].hash);
        }
    }
    return end;
}

我开发了一个函数，可以按键对哈希表进行排序，不管值是数字还是字符串。如果表是关联表，则保留键

var things = new Object ();
things["hello"] = {"name" : "zzz I fell asleep", "number" : 7};
things["one"] = {"name" : "something", "number" : 18};
things["two"] = {"name" : "another thing", "number" : -2};

things = sortHashTableByKey(things, 'name');

/*
[
  two: { name: 'another thing', number: -2 },
  one: { name: 'something', number: 18 },
  hello: { name: 'zzz I fell asleep', number: 7 }
]
*/

与eeerahul相同，带有键（）和字符串（）。localeCompare（）：

在语法上要小心。它将循环遍历所讨论对象的所有属性，其中包括数组键以外的内容。^^这是正确的，但只要它不从任何内容继承，就不应该成为问题。请注意，语句的迭代顺序可以是任意的，中没有关于属性枚举顺序的描述，它依赖于实现。。。没有保证，请小心使用…@CMS:所以我应该使用

for（var I=0；I

严格正确吗？@Kinopiko，确切地说，请查看以下文章以了解更多信息：[1]（）和[2]（）。您还可以使用对象.keys（things）
构建键
数组。在for循环的比较步骤之前存储数组长度也是一种很好的做法，因此上面的@CMS for循环可以写成for（var i=0，l=keys.length；i
。这样可以避免重复索引到未更改的值的键。length
属性。OP错误地使用数组things
，因此这不会有帮助。您既没有hastable（aka对象），也没有正确的数组。如果你想拥有一个对象，你应该用{}
而不是[]
初始化它。如果您使用[]
初始化，则您有一个数组，但不通过a[“一”]
和a[“二”]
而通过a.push（…）添加到数组中。只有在知道需要什么样的数据结构后，才能进行排序。（顺便说一句：foo[“bar”]
与foo.bar相同，使用第二个，它不会用字符串文字和大量方括号阻塞代码）@HaykSaakian，该函数如何实现？作为一个人，我真的很钦佩任何人在精神/身体问题之外努力维持状态和功能。好极了。我应该说“做这个”而不是“做这个”@ToddMorrison
var things = new Object ();
things["hello"] = {"name" : "zzz I fell asleep", "number" : 7};
things["one"] = {"name" : "something", "number" : 18};
things["two"] = {"name" : "another thing", "number" : -2};

things = sortHashTableByKey(things, 'name');

/*
[
  two: { name: 'another thing', number: -2 },
  one: { name: 'something', number: 18 },
  hello: { name: 'zzz I fell asleep', number: 7 }
]
*/

function sort_by_key(t_kv,v_kv){
  return(Object.keys(t_kv).sort(
    function(a,b){return(
      String(t_kv[a][v_kv]).localeCompare(String(t_kv[b][v_kv])))}))
}

t={two:{s:'two',n:2},three:{s:'three',n:3},one:{s:'one',n:1}}
sort_by_key(t,'n')
    ["one", "two", "three"]
sort_by_key(t,'s')
    ["one", "three", "two"]