JavaScript数组关联和索引？JavaScript数组关联和索引？(javascript ar

可以在JS阵列是关联的，并且索引？ 我希望能够通过自己的立场或键值来查找数组中的项目..可能吗？

Answer 1:

有没有这样的事情在Javascript关联数组。 您可以使用对象的文字， 看起来像关联数组，但他们有无序性。 常规的JavaScript阵列基于整数索引，并且不能是关联的。

例如，与此对象：

var params = {
    foo: 1,
    bar: 0,
    other: 2
};

您可以访问对象的属性，例如：

params["foo"];

而且你还可以使用遍历对象for...in语句：

for(var v in params) {
    //v is equal to the currently iterated property
}

然而，财产迭代的顺序没有严格的规则 - 你的对象字面的两次迭代可以以不同的顺序返回的属性。

Answer 2:

看完后关联数组的定义维基百科 ，我会与传统的JavaScript绝杀打破，说：“是的，JavaScript并具有关联数组。” 使用JavaScript阵列，您可以添加，重新分配，删除，并通过它们的键查找值（和键可引用的字符串），这是维基百科说关联数组应该是能够做到的。

但是，你似乎会问不同的东西 - 你是否可以通过索引或键查找相同的值。 这不是关联数组的要求（见维基百科文章）。关联数组没有给你通过指数来获得一个价值的能力。

JavaScript数组是非常密切类似于JavaScript对象。

  arr=[];
  arr[0]="zero";
  arr[1]="one";
  arr[2]="two";
  arr["fancy"]="what?";

是的，这是一个数组，是的，你可以逃脱与非数字索引。 （如果你很好奇，毕竟这，arr.length为3）

在大多数情况下，我认为你应该坚持数字索引，当您使用数组。 这是大多数程序员期望的，我想。

这个链接是我的博客文章的主题。

Answer 3:

本地JS对象只接受字符串作为属性名，这是事实，即使对于数值数组索引 ; 阵列从香草对象的不同仅只要最JS实现将不同地（在实际的阵列，只要它们是致密即）存储数字索引属性和设置它们将触发额外的操作（例如，调整length属性）。

如果你正在寻找一个地图，它接受任意键，你将不得不使用一个非本地执行 。 该脚本用于快速迭代，并通过数字索引不是随机访问，所以它可能也不是你在找什么。

准系统实现地图的哪会做什么你问的可能是这样的：

function Map() {
    this.length = 0;
    this.store = {};
}

Map.prototype.get = function(key) {
    return this.store.hasOwnProperty(key) ?
        this.store[key] : undefined;
};

Map.prototype.put = function(key, value, index) {
    if(arguments.length < 3) {
        if(this.store.hasOwnProperty(key)) {
            this.store[key].value = value;
            return this;
        }

        index = this.length;
    }
    else if(index >>> 0 !== index || index >= 0xffffffff)
        throw new Error('illegal index argument');

    if(index >= this.length)
        this.length = index + 1;

    this[index] = this.store[key] =
        { index : index, key : key, value : value };

    return this;
};

该index的参数put()是可选的。

您可以在地图访问值map或者通过按键或通过指数

map.get('key').value
map[2].value

Answer 4:

的顺序对象出现在没有被定义的JavaScript阵列的缔合，并且将在不同的实施方式有所不同。 出于这个原因，你真的不能给定关联的关键计数始终是相同的索引。

编辑：

作为Perspx指出，有没有真正在JavaScript真正的关联数组。 声明foo["bar"]只是句法糖foo.bar

如果您信任的浏览器，以保持在一个对象元素的顺序，你可以写一个函数

function valueForIndex(obj, index) {

    var i = 0;
    for (var key in obj) {

        if (i++ == index)
            return obj[key];
    }
}

Answer 5:

var myArray = Array();
myArray["first"] = "Object1";
myArray["second"] = "Object2";
myArray["third"] = "Object3";

Object.keys(myArray);              // returns ["first", "second", "third"]
Object.keys(myArray).length;       // returns 3

如果你想第一个元素，那么你可以使用它像这样：

myArray[Object.keys(myArray)[0]];  // returns "Object1"

Answer 6:

var stuff = [];
stuff[0] = "foo";
stuff.bar = stuff[0]; // stuff.bar can be stuff["bar"] if you prefer
var key = "bar";
alert(stuff[0] + ", " + stuff[key]); // shows "foo, foo"

Answer 7:

我来这里是想知道这是不好的做法与否，而是发现了大量的出现不明白这个问题的人。

我想有一个受命，但可以通过按键进行索引，所以它不会要求每一个查找迭代的数据结构。

具体而言，这是很简单，但我还没有看它是否是一个可怕的做法还是没有什么。

var roygbiv = [];
var colour = { key : "red", hex : "#FF0000" };
roygbiv.push(colour);
roygbiv[colour.key] = colour;
...
console.log("Hex colours of the rainbow in order:");
for (var i = 0; i < roygbiv.length; i++) {
    console.log(roygbiv[i].key + " is " + roygbiv[i].hex);
}

// input = "red";
console.log("Hex code of input colour:");
console.log(roygbiv[input].hex);

重要的是，以不会改变数组的值[索引]或阵列[键]直接一旦对象被设置或值将不再匹配。 如果数组包含对象，你可以改变这些对象的属性，你就可以通过两种方法来访问更改的属性。

Answer 8:

虽然我的答案给出同意你实际上可以做到你说有getter和setter什么。 例如：

var a = [1];
//This makes a["blah"] refer to a[0]
a.__defineGetter__("blah", function(){return this[0]});
//This makes a["blah"] = 5 actually store 5 into a[0]
a.__defineSetter__("blah", function(val){ this[0] = val});

alert(a["blah"]); // emits 1
a["blah"] = 5;
alert(a[0]); // emits 5

这是你想要的？ 我认为那里有不同的更现代的方式做getter和setter方法，但不能记住。

Answer 9:

浪潮改变了这一点。 现在你可以做到这一点...等等！ 使用代理服务器的和谐，你可以肯定在很多方面解决这个问题。

你必须确认你的目标环境支持此与来自也许有点帮助， 和谐，反映垫片。

有一个很好的例子Mozilla开发者网络上使用代理服务器通过它找到一个数组项对象的属性这几乎总结起来。

这里是我的版本：

  var players = new Proxy(
  [{
    name: 'monkey',
    score: 50
  }, {
    name: 'giraffe',
    score: 100
  }, {
    name: 'pelican',
    score: 150
  }], {
    get: function(obj, prop) {
      if (prop in obj) {
        // default behavior
        return obj[prop];
      }
      if (typeof prop == 'string') {

        if (prop == 'rank') {
          return obj.sort(function(a, b) {
            return a.score > b.score ? -1 : 1;
          });
        }

        if (prop == 'revrank') {
          return obj.sort(function(a, b) {
            return a.score < b.score ? -1 : 1;
          });
        }

        var winner;
        var score = 0;
        for (var i = 0; i < obj.length; i++) {
          var player = obj[i];
          if (player.name == prop) {
            return player;
          } else if (player.score > score) {
            score = player.score;
            winner = player;
          }
        }

        if (prop == 'winner') {
          return winner;
        }
        return;
      }

    }
  });

  console.log(players[0]); // { name: 'monkey', score: 50 }
  console.log(players['monkey']); // { name: 'monkey', score: 50 }
  console.log(players['zebra']); // undefined
  console.log(players.rank); // [ { name: 'pelican', score: 150 },{ name: 'giraffe', score: 100 }, { name: 'monkey', score: 50 } ]
  console.log(players.revrank); // [ { name: 'monkey', score: 50 },{ name: 'giraffe', score: 100 },{ name: 'pelican', score: 150 } ]
  console.log(players.winner); // { name: 'pelican', score: 150 }

Answer 10:

是。

test = new Array();
test[0] = 'yellow';
test['banana'] = 0;
alert(test[test['banana']]);

文章来源: javascript array associative AND indexed?