如果有人在搜索Typescript方法，我这样写:

const arrayToObject = <T extends Record<K, any>, K extends keyof any>(
  array: T[] = [],
  getKey: (item: T) => K,
) =>
  array.reduce((obj, cur) => {
    const key = getKey(cur)
    return ({...obj, [key]: cur})
  }, {} as Record<K, T>)

它将:

强制第一个参数为对象数组 帮助选择键 强制该键为所有数组项的键

例子:

// from:
const array = [
    { sid: 123, name: 'aaa', extra: 1 },
    { sid: 456, name: 'bbb' },
    { sid: 789, name: 'ccc' }
];
// to:
{
  '123': { sid: 123, name: 'aaa' },
  '456': { sid: 456, name: 'bbb' },
  '789': { sid: 789, name: 'ccc' }
}

用法:

const obj = arrayToObject(array, item => item.sid) // ok
const obj = arrayToObject(array, item => item.extra) // error

这是一个演示。

初始数组，并将转换为一个对象的键，这将是一个数组的唯一元素，键的值将是具体的键将重复多少次

var jsTechs = ['angular', 'react', 'ember', 'vanilaJS', 'ember', 'angular', 'react', 'ember', 'vanilaJS', 'angular', 'react', 'ember', 'vanilaJS', 'ember', 'angular', 'react', 'ember', 'vanilaJS', 'ember', 'angular', 'react', 'ember', 'vanilaJS', 'ember', 'react', 'react', 'vanilaJS', 'react', 'vanilaJS', 'vanilaJS'] var initialValue = { java : 4 } var reducerFunc = function reducerFunc (initObj, jsLib) { if (!initObj[jsLib]) { initObj[jsLib] = 1 } else { initObj[jsLib] += 1 } return initObj } var finalResult = jsTechs.reduce(reducerFunc, initialValue) console.log(finalResult)

你可以使用累加器，也就是减少。

['a','b','c'].reduce(function(result, item, index, array) {
  result[index] = item; //a, b, c
  return result;
}, {}) //watch out the empty {}, which is passed as "result"

传递一个空对象{}作为起始点;然后递增地“增大”该对象。 在迭代结束时，结果将是{"0":"a"， "1": "b"， "2": "c"}

如果数组是键值对对象的集合:

[{ a: 1},{ b: 2},{ c: 3}].reduce(function(result, item) {
  var key = Object.keys(item)[0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {});

将产生:{a: 1, b: 2, c: 3}

为了完整起见，reduceRight允许你以相反的顺序遍历数组:

[{ a: 1},{ b: 2},{ c: 3}].reduceRight(/* same implementation as above */)

将产生:{c:3, b:2, a:1}

你的蓄能器可以为你的特定用途的任何类型。例如，为了交换数组中对象的键和值，传递[]:

[{ a: 1},{ b: 2},{ c: 3}].reduce(function(result, item, index) {
  var key = Object.keys(item)[0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push(obj);
  return result;
}, []); //an empty array

将产生:[{1:"a"}， {2: "b"}， {3: "c"}]

与map不同，reduce不能用作1-1映射。您可以完全控制要包含或排除的项。因此，reduce可以实现过滤器的功能，这使得reduce非常通用:

[{ a: 1},{ b: 2},{ c: 3}].reduce(function(result, item, index) {
  if(index !== 0) { //skip the first item
    result.push(item);
  }
  return result;
}, []); //an empty array

将产生:[{2:"b"}， {3: "c"}]

警告:减少和对象。关键是ECMA第5版的一部分;你应该为不支持它们的浏览器(尤其是IE8)提供一个polyfill。

请参阅Mozilla的默认实现。

我会使用下划线，但如果没有的话我会使用reduce，初始值为空对象{}

>>> ['a', 'b', 'c'].reduce(function(p, c, i) {p[i] = c; return p}, {})
Object { 0="a", 1="b", 2="c"}

reduce应该在今天的大多数浏览器中广泛使用，参见MDN

更多的浏览器支持和更灵活的方法是使用一个正常的循环，比如:

const arr = ['a', 'b', 'c'],
obj = {};

for (let i=0; i<arr.length; i++) {
   obj[i] = arr[i];
}

但现代的方法也可以使用展开运算符，比如:

{...arr}

或对象赋值:

Object.assign({}, ['a', 'b', 'c']);

两者都会返回:

{0: "a", 1: "b", 2: "c"}

一个快速而肮脏的问题:

var obj = {},
  arr = ['a','b','c'],
  l = arr.length; 

while( l && (obj[--l] = arr.pop() ) ){};