JavaScript动态填充关联数组并获取值

Question

我想基于一个数组构建一个关联数组，然后获取该关联数组的值。

关联数组的结构如下：

        var myAssociativeArr = new Array();

        myAssociativeArr = [
         { id:'1',
          lname:'doe',
          fname:'john' 
        },
         { id:'2',
          lname:'smith',
          fname:'john' 
        }

        ]

我有三个长度相同的数组，我将从中构建这个关联数组，即id、lname和fname数组。

    for(var i=0; idArray.length;i++)
    {
    myAssociativeArr [id]=idArray[i];
    myAssociativeArr [lname]=lnameArray[i];
    myAssociativeArr [fname]=fnameArray[i];
    }

请告诉我上述方法是否正确，如果不是，请问我该如何构建此数组，并且如何通过循环获取此数组的值。

感谢您的帮助。

- Nomad

Answer 1

您非常接近了。首先，如果您希望使用数组下标表示法，则必须传递键本身（在您的情况下是字符串，像这样）：

var myAssociativeArr = [];
for (var i=0; i < idArray.length; i++) {
    var newElement = {};
    newElement['id'] = idArray[i];
    newElement['lname'] = lnameArray[i];
    newElement['fname'] = fnameArray[i];
    myAssociativeArr.push(newElement);
}

当键名为已知字符串时，通常最好使用完全等效的对象属性符号表示法：

var myAssociativeArr = [];
for (var i=0; i < idArray.length; i++) {
    var newElement = {};
    newElement.id = idArray[i];
    newElement.lname = lnameArray[i];
    newElement.fname = fnameArray[i];
    myAssociativeArr.push(newElement);
}

您可以使用对象字面量来更加简洁，就像在示例输出中所做的那样：

var myAssociativeArr = [];
for (var i=0; i < idArray.length; i++) {
    myAssociativeArr.push({
        id: idArray[i],
        lname: lnameArray[i],
        fname: fnameArray[i]
    });
}

编辑：修正了循环索引，避免无限。

你读取元素的方式与写入它们相同：myAssociativeArr[i]['id']等，或者myAssociativeArr[i].id等。

对于按ID查找，建立一个对象是个好主意。

var myObject = {};
for (var i=0; i < idArray.length; i++) {
    myObject[idArray[i]] = {
        id: idArray[i],
        lname: lnameArray[i],
        fname: fnameArray[i]
    };
}

查找：

myObject['2'] // => { id: '2', ... }

- Jeremy Roman

---

谢谢您的回答，那么如何从这个关联数组中获取值呢？ - Nomad

@Nomad：他已经解释了如何使用方括号符号访问对象（您既可以读取也可以写入） - hugomg

非常感谢你的时间和付出，Jeremy。真的非常感激。 - Nomad

现在，如果我想搜索ID并提取相应的数据，我该怎么做？例如，我想搜索ID号码为2，并想获取姓氏、名字和ID，我该如何做呢？谢谢。 - Nomad

在这种情况下，最好构建一个对象，其键是 id 的值。类似于：在 for 循环中使用 myObject[idArray[i]] = { id: .... };，并在此之前初始化一个空对象 {}。然后您可以在常数时间内按 ID 查找对象。答案已更新以反映此内容。 - Jeremy Roman

非常感谢您，Jeremy。您提供了很大的帮助，感谢您花费时间和精力。它正如预期的那样运作。 - Nomad

Answer 2

不太对，试试这个：

 for(var i=0; idArray.length; i++)
 {
    myAssociativeArr[i] = {
                           id: idArray[i], 
                           lname: lnameArray[i], 
                           fname: fnameArray[i]
                          };
 }

为了获取第五个元素的id：myAossociativeArr[i]['id']，我相信您能从这里想出其余部分。

- Charles Ma

---

谢谢您的回答，那么如何从这个关联数组中获取值呢？ - Nomad

非常感谢您的时间和努力，真的非常感激。 - Nomad

现在，如果我想搜索ID并提取相应的数据，我该怎么做？例如，我想搜索ID号码为2，并想获取姓氏、名字和ID，我该如何做呢？谢谢。 - Nomad

Answer 3

for(var i=0; idArray.length;i++)
    {
    myAssociativeArr [i][id]=idArray[i];
    myAssociativeArr [i][lname]=lnameArray[i];
    myAssociativeArr [i][fname]=fnameArray[i];
    }

- lovesh

---

非常感谢您的时间和努力，真的非常感激。 - Nomad

Answer 4

八年后，使用ECMAScript 2015，我们可以通过以下方式解决这个问题：

let assocArr = idArray
.map(x=>{ return {id: x}})
.map((x,index) => Object.assign({lname: lname[index]}, x))
.map((x,index) =>Object.assign({fname: fname[index]}, x) )
.reduce((assoc,obj) => {let target = {};target[obj.id] = obj; return Object.assign(target,assoc) }, {})

或者仅使用reduce：

let assocArr = idArray.reduce((assoc, x, index) => {
  let target = {};
  target[x] = { id: x, lname: lname[index], fname: fname[index] };
  return Object.assign(target, assoc);
}, {});

如果有需要的话，一个更灵活的函数可以做上述的事情。

function glue(properties) {
  let propsArrays = Object.entries(properties);
  let lookUp = properties[properties.lookUpKey];
  let propertyArrays = propsArrays.filter(
    ([key, value]) => key !== "lookUpKey"
  );
  return propertyArrays.reduce(
    (assoc, props, index) => {
      let [key, values] = [...props];
      return values.reduce((assoc, prop, j) => {
        let target = {};
        target[key] = prop;
        assoc[lookUp[j]] = Object.assign(target, assoc[lookUp[j]]);
        return assoc;
      }, assoc);
    },
    lookUp.reduce((assoc, id) => {
      assoc[id] = {};
      return assoc;
    }, {})
  );
}

你可以给它一个对象，例如

var properties = {id: idArray, lname: lname, fname: fname, lookUpKey: 'id'}

基于对象的属性名称以及查找数组的键，它将把这些属性作为对象粘合到一个数组中。该函数会将属性对象转换为一组键值对的数组形式:

let propsArrays = Object.entries(properties);

然后它提取lookUp键和实际属性，将它们粘合到各自的数组中：

let lookUp = properties[properties.lookUpKey];
let propertyArrays = propsArrays.filter(([key, value]) => key !== "lookUpKey");  

然后，它使用嵌套的reduce来将属性处理成具有正确属性的对象数组。请注意：

lookUp.reduce((assoc, id) => {
          assoc[id] = {};
          return assoc;
        }, {})

使用查找数组中的值作为键/属性，初始化最外层的reduce对象。与这些键相关联的值一开始只是空对象。然后，最内层的reduce将使用以下方法将适当的属性合并到这些对象中：

assoc[lookUp[j]] = Object.assign(target, assoc[lookUp[j]])

- Patrick Assoa Adou