将数组转换为 Object

Question

转换的最佳方法是什么：

['a','b','c']

至：

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

Answer 1

ECMAScript 6 引入了易于填充的Object.assign ：

Object.assign()方法用于将所有可枚举自身属性的值从一个或多个源对象复制到目标对象。 它将返回目标对象。

Object.assign({}, ['a','b','c']); // {0:"a", 1:"b", 2:"c"}

数组自身的length属性不会被复制，因为它不可枚举。

此外，您可以在对象上使用 ES8 扩展语法来实现相同的结果：

{ ...['a', 'b', 'c'] }

对于自定义键，您可以使用reduce ：

['a', 'b', 'c'].reduce((a, v) => ({ ...a, [v]: v}), {}) 
// { a: "a", b: "b", c: "c" }

Answer 2

使用这样的功能：

function toObject(arr) {
  var rv = {};
  for (var i = 0; i < arr.length; ++i)
    rv[i] = arr[i];
  return rv;
}

您的数组已经或多或少只是一个对象，但数组确实有一些“有趣”和关于整数命名属性的特殊行为。 以上将为您提供一个简单的对象。

编辑哦，您可能还想考虑数组中的“孔”：

function toObject(arr) {
  var rv = {};
  for (var i = 0; i < arr.length; ++i)
    if (arr[i] !== undefined) rv[i] = arr[i];
  return rv;
}

在现代 JavaScript 运行时，您可以使用.reduce()方法：

var obj = arr.reduce(function(acc, cur, i) {
  acc[i] = cur;
  return acc;
}, {});

这也避免了数组中的“漏洞”，因为这就是.reduce()的工作原理。

Answer 3

你可以使用一个累加器，也就是reduce 。

['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"

传入一个空对象{}作为起点； 然后逐渐“增加”该对象。 在迭代结束时， 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允许您实现filter的功能，这使得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"}]

注意： reduce和Object.key是ECMA 5th edition的一部分； 你应该为不支持它们的浏览器（特别是 IE8）提供一个 polyfill。

查看Mozilla的默认实现。

Answer 4

如果您使用的是 jquery：

$.extend({}, ['a', 'b', 'c']);

Answer 5

为了完整起见，ECMAScript 2015(ES6) 传播。 将需要转译器（Babel）或至少运行 ES6 的环境。

 console.log( { ...['a', 'b', 'c'] } )

Answer 6

我可能会这样写（因为我很少手头没有 underscorejs 库）：

var _ = require('underscore');

var a = [ 'a', 'b', 'c' ];
var obj = _.extend({}, a);
console.log(obj);
// prints { '0': 'a', '1': 'b', '2': 'c' }

Answer 7

如果您想使用迭代对象的属性之一作为键，例如：

// from:
const arr = [
    {
        sid: 123,
        name: 'aaa'
    },
    {
        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 result = arr.reduce((obj, cur) => ({...obj, [cur.sid]: cur}), {})

Answer 8

没想到——

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

Answer 9

我们可以使用Object.assign和array.reduce函数将 Array 转换为 Object。

 var arr = [{a:{b:1}},{c:{d:2}}] var newObj = arr.reduce((a, b) => Object.assign(a, b), {}) console.log(newObj)

Answer 10

这是一个 O(1) ES2015 方法，只是为了完整性。

var arr = [1, 2, 3, 4, 5]; // array, already an object
Object.setPrototypeOf(arr, Object.prototype); // now no longer an array, still an object

Answer 11

我最终使用了对象扩展运算符，因为它是 ECMAScript 2015 (ES6) 标准的一部分。

const array = ['a', 'b', 'c'];
console.log({...array});
// it outputs {0:'a', 1:'b', 2:'c'}

以下面的小提琴为例。

Answer 12

对于 ES2016，对象的展开运算符。 注意：这是在ES6之后，因此需要调整转译器。

 const arr = ['a', 'b', 'c']; const obj = {...arr}; // -> {0: "a", 1: "b", 2: "c"}

Answer 13

Object.assign({}, ['one', 'two']); // {0: 'one', 1: 'two'}

现代 JavaScript 中的简单方法是使用Object.assign() ， Object.assign()将 key:value 从一个对象复制到另一个对象。 在我们的例子中， Array将属性捐赠给 new {} 。

Answer 14

FWIW，另一种最近的方法是使用新的Object.fromEntries和Object.entries ，如下所示：

const arr = ['a','b','c'];
arr[-2] = 'd';
arr.hello = 'e';
arr.length = 17;
const obj = Object.fromEntries(Object.entries(arr));

...这允许避免将稀疏数组项存储为undefined或null并保留非索引（例如，非正整数/非数字）键。

{ 0：“a”，1：“b”，2：“c”，“-2”：“d”，你好：“e”}

（这里的结果与@Paul Draper 的Object.assign答案相同。）

但是，可能希望添加arr.length ，因为它不包括在内：

obj.length = arr.length;

Answer 15

使用javascript#forEach可以做到这一点

var result = {},
    attributes = ['a', 'b','c'];

attributes.forEach(function(prop,index) {
  result[index] = prop;
});

使用 ECMA6：

attributes.forEach((prop,index)=>result[index] = prop);

Answer 16

五年后，有一个好方法:)

Object.assign是在 ECMAScript 2015 中引入的。

Object.assign({}, ['a', 'b', 'c'])
// {'0':'a', '1':'b', '2':'c'}

Answer 17

您可以使用扩展运算符

x = [1,2,3,10]
{...x} // {0:1, 1:2, 2:3, 3:10}

Answer 18

如果您使用的是 ES6，则可以使用 Object.assign 和扩展运算符

{ ...['a', 'b', 'c'] }

如果您有嵌套数组，例如

var arr=[[1,2,3,4]]
Object.assign(...arr.map(d => ({[d[0]]: d[1]})))

Answer 19

最简单的方法是使用扩展运算符。

 var arr = ["One", "Two", 3]; var obj = {...arr}; console.log(obj);

Answer 20

又快又脏#2：

var i = 0
  , s = {}
  , a = ['A', 'B', 'C'];

while( i < a.length ) { s[i] = a[i++] };

Answer 21

一个快速而肮脏的：

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

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

Answer 22

一种快速将项目数组转换为对象的简单而厚颜无耻的方法

function arrayToObject( srcArray ){
    return  JSON.parse( JSON.stringify( srcArray ) );
}

然后像这样使用它......

var p = [0,2,3,'pork','pie',6];
obj = new arrayToObject( p );
console.log( obj[3], obj[4] )
// expecting `pork pie`

输出：

pork pie

检查类型：

typeof obj
"object"

如果没有原型方法，事情就不会完整

Array.prototype.toObject =function(){
    return  JSON.parse( JSON.stringify( this ) );
}

使用类似：

var q = [0,2,3,'cheese','whizz',6];
obj = q.toObject();
console.log( obj[3], obj[4] )
// expecting `cheese whizz`

输出：

cheese whizz

*注意没有命名例程，所以如果你想有特定的名字，那么你需要继续使用下面的现有方法。

---

较旧的方法

这允许您从数组中生成一个对象，该对象具有您按照您想要的顺序定义的键。

Array.prototype.toObject = function(keys){
    var obj = {};
    var tmp = this; // we want the original array intact.
    if(keys.length == this.length){
        var c = this.length-1;
        while( c>=0 ){
            obj[ keys[ c ] ] = tmp[c];
            c--;
        }
    }
    return obj;
};

result = ["cheese","paint",14,8].toObject([0,"onion",4,99]);

console.log(">>> :" + result.onion); 将输出“paint”，该函数必须具有相等长度的数组，否则您将得到一个空对象。

这是一个更新的方法

Array.prototype.toObject = function(keys){
    var obj = {};
    if( keys.length == this.length)
        while( keys.length )
            obj[ keys.pop() ] = this[ keys.length ];
    return obj;
};

Answer 23

更多的浏览器支持和更灵活的方式是使用普通循环，例如：

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"}

Answer 24

.reduce((o,v,i)=>(o[i]=v,o), {})

[文档]

或更详细

var trAr2Obj = function (arr) {return arr.reduce((o,v,i)=>(o[i]=v,o), {});}

或者

var transposeAr2Obj = arr=>arr.reduce((o,v,i)=>(o[i]=v,o), {})

最短的带有香草 JS 的

JSON.stringify([["a", "X"], ["b", "Y"]].reduce((o,v,i)=>{return o[i]=v,o}, {}))
=> "{"0":["a","X"],"1":["b","Y"]}"

一些更复杂的例子

[["a", "X"], ["b", "Y"]].reduce((o,v,i)=>{return o[v[0]]=v.slice(1)[0],o}, {})
=> Object {a: "X", b: "Y"}

甚至更短（通过使用function(e) {console.log(e); return e;} === (e)=>(console.log(e),e) ）

 nodejs
> [[1, 2, 3], [3,4,5]].reduce((o,v,i)=>(o[v[0]]=v.slice(1),o), {})
{ '1': [ 2, 3 ], '3': [ 4, 5 ] }

[/文档]

Answer 25

从 Lodash 3.0.0 开始，您可以使用_.toPlainObject

 var obj = _.toPlainObject(['a', 'b', 'c']); console.log(obj);

 <script src="https://cdn.jsdelivr.net/lodash/4.16.4/lodash.min.js"></script>

Answer 26

如果您可以使用Map或Object.assign ，那就很容易了。

创建一个数组：

const languages = ['css', 'javascript', 'php', 'html'];

下面创建一个以索引为键的对象：

Object.assign({}, languages)

使用地图复制与上述相同的内容

转换为基于索引的对象{0 : 'css'}等...

const indexMap = new Map(languages.map((name, i) => [i, name] ));
indexMap.get(1) // javascript

转换为基于值的对象{css : 'css is great'}等...

const valueMap = new Map(languages.map(name => [name, `${name} is great!`] ));
valueMap.get('css') // css is great

Answer 27

如果有人在寻找 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>)

它会：

1. 强制第一个参数是对象数组
2. 帮助选择键
3. 强制键是所有数组项的键

例子：

// 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

这是一个演示。

Answer 28

这是我刚刚写的一个递归函数。 它很简单而且效果很好。

// Convert array to object
var convArrToObj = function(array){
    var thisEleObj = new Object();
    if(typeof array == "object"){
        for(var i in array){
            var thisEle = convArrToObj(array[i]);
            thisEleObj[i] = thisEle;
        }
    }else {
        thisEleObj = array;
    }
    return thisEleObj;
}

这是一个示例（ jsFiddle ）：

var array = new Array();
array.a = 123;
array.b = 234;
array.c = 345;
var array2 = new Array();
array2.a = 321;
array2.b = 432;
array2.c = 543;
var array3 = new Array();
array3.a = 132;
array3.b = 243;
array3.c = 354;
var array4 = new Array();
array4.a = 312;
array4.b = 423;
array4.c = 534;
var array5 = new Array();
array5.a = 112;
array5.b = 223;
array5.c = 334;

array.d = array2;
array4.d = array5;
array3.d = array4;
array.e = array3;


console.log(array);

// Convert array to object
var convArrToObj = function(array){
    var thisEleObj = new Object();
    if(typeof array == "object"){
        for(var i in array){
            var thisEle = convArrToObj(array[i]);
            thisEleObj[i] = thisEle;
        }
    }else {
        thisEleObj = array;
    }
    return thisEleObj;
}
console.log(convArrToObj(array));

结果：

Answer 29

我会简单地使用Array.of()来做到这一点。 Array of 能够将其上下文用作构造函数。

注 2 of 函数是一种有意的通用工厂方法； 它不要求它的 this 值是 Array 构造函数。 因此，它可以转移到其他构造函数或被其他构造函数继承，这些构造函数可以使用单个数字参数调用。

所以我们可以将Array.of()绑定到一个函数并生成一个类似对象的数组。

 function dummy(){}; var thingy = Array.of.apply(dummy,[1,2,3,4]); console.log(thingy);

通过利用Array.of()甚至可以进行数组子类化。

Answer 30

 let i = 0; let myArray = ["first", "second", "third", "fourth"]; const arrayToObject = (arr) => Object.assign({}, ...arr.map(item => ({[i++]: item}))); console.log(arrayToObject(myArray));

或使用

 myArray = ["first", "second", "third", "fourth"] console.log({...myArray})

Answer 31

ES5 - 解决方案：

使用数组原型函数“push”和“apply” ，您可以使用数组元素填充对象。

 var arr = ['a','b','c']; var obj = new Object(); Array.prototype.push.apply(obj, arr); console.log(obj); // { '0': 'a', '1': 'b', '2': 'c', length: 3 } console.log(obj[2]); // c

Answer 32

尝试使用反射从数组项复制到对象。

var arr =['aa:23','bb:44','cc:55']
    var obj ={}
    arr.forEach(e => {
        var ee = e.split(':')
        Reflect.set(obj,ee[0],ee[1])
    });
    console.log(obj) // { aa: '23', bb: '44', cc: '55' }

Answer 33

你可以使用这样的函数：

var toObject = function(array) {
    var o = {};
    for (var property in array) {
        if (String(property >>> 0) == property && property >>> 0 != 0xffffffff) {
            o[i] = array[i];
        }
    }
    return o;
};

这个应该更有效地处理稀疏数组。

Answer 34

它不是直接相关的，但我来这里是为了寻找一个用于合并嵌套对象的衬垫，例如

const nodes = {
    node1: {
        interfaces: {if1: {}, if2: {}}
    },
    node2: {
        interfaces: {if3: {}, if4: {}}
    },
    node3: {
        interfaces: {if5: {}, if6: {}}
    },
}

解决方案是结合使用 reduce 和 object spread：

const allInterfaces = nodes => Object.keys(nodes).reduce((res, key) => ({...res, ...nodes[key].interfaces}), {})

Answer 35

最简单的方法如下：

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

function ConvertArr(arr) { 
 if (typeof(arr) === 'array') {
 Object.assign(obj, arr);
}

这样它只有在它是一个数组时才运行，但是，你可以使用 let 全局对象变量或不使用它来运行它，这取决于你，如果你不使用 let 运行，只需执行 Object.assign({}, arr)。

Answer 36

使用 javascript lodash 库。 有一个简单的方法_.mapKeys(object, [iteratee=_.identity])可以进行转换。

Answer 37

这是咖啡脚本中的解决方案

arrayToObj = (arr) ->
  obj = {}
  for v,i in arr
    obj[i] = v if v?
  obj

Answer 38

如果您使用的是 angularjs，您可以使用 angular.extend，与 jquery 的 $.extend 效果相同。

var newObj = {};
angular.extend(newObj, ['a','b','c']);

Answer 39

如果你喜欢 oneliners，并且 IE8 不再是问题（应该如此）

['a','b','c'].reduce((m,e,i) => Object.assign(m, {[i]: e}), {});

继续在浏览器控制台上尝试

它可以像这样更冗长：

['a','b','c'].reduce(function(memo,elm,idx) {
    return Object.assign(memo, {[idx]: elm});
}, {});

但仍然排除IE8。 如果 IE8 是必须的，那么你可以像这样使用 lodash/underscore：

_.reduce(['a','b','c'], function(memo,elm,idx) {
    return Object.assign(memo, {[idx]: elm});
}, {})

Answer 40

下面的方法会将数组转换为具有特定给定键的对象。

    /**
     * Converts array to object
     * @param  {Array} array
     * @param  {string} key (optional)
     */
    Array.prototype.ArrayToObject = function(key) {
       const array = this;
       const obj = {};

       array.forEach((element, index) => {
           if(!key) {
              obj[index] = element;
           } else if ((element && typeof element == 'object' && element[key])) {
              obj[element[key]] = element;
           }
       });
    return obj;
    }

对于前 -

[{name: 'test'}, {name: 'test1'}].ArrayToObject('name');

会给

{test: {name: 'test'}, test1: {name: 'test1'}}

并且没有将密钥作为参数提供给该方法

i.e. [{name: 'test'}, {name: 'test1'}].ArrayToObject();

会给

{0: {name: 'test'}, 1: {name: 'test1'}}

Answer 41

也许如果您希望数组值也成为您的对象键

function toObject(arr) {
  var rv = {};
  for (var i = 0; i < arr.length; ++i)
    rv[arr[i]] = arr[i];
  return rv;
}

Answer 42

我会为此使用下划线，但如果那不可用，那么我会下降到使用具有空对象初始值{}的 reduce

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

reduce 现在应该在大多数浏览器中都可以广泛使用，请参阅MDN

Answer 43

使用 javascript reduce 很容易：

["a", "b", "c", "d"].reduce(function(previousValue, currentValue, index) { 
   previousValue[index] = currentValue; 
   return previousValue;
}, 
{}
);

你可以看看 Array.prototype.reduce()， https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

Answer 44

打字稿解决方案：

export const toMap = (errors: ResponseError[]) => {
  const errorMap: Record<string, string> = {};
  errors.forEach(({ field, message }) => {
    errorMap[field] = message;
  });
  return errorMap;
};

export type FieldError = {
  field: string;
  message: string;
};

Answer 45

这里没有多少人评论Object.fromEntries ，我真的很喜欢它，因为它更干净并且可以轻松地与TypeScript一起使用，而无需过多关注泛型类型和其他东西。 如果需要，它还允许带有map的自定义键。 缺点：如果您需要自定义键，则需要额外的map 。 例如：

const tags = [
  { name: 'AgeGroup', value: ageGroup },
  { name: 'ApparelTypes', value: apparelTypes },
  { name: 'Brand', value: brand },
  // ...
]

const objectTags = Object.fromEntries(tags.map((t) => [t.name, t.value]))

/*
{
  AgeGroup: 'Adult',
  Apparel: 'Creeper, Jacket'
  Brand: '',
  // ...
}
*/

Answer 46

为什么没有人尝试这个？ 在 ES6 中

let arr = ['a','b','c']
let {...obj} = arr
console.log(obj) //  {0: 'a', 1: 'b', 2: 'c'}

let {...obj2} = ['a','b','c']
console.log(obj2) //  {0: 'a', 1: 'b', 2: 'c'}

是很简单的方法吗？

Answer 47

初始数组并将转换为带有键的对象，该键将是数组的唯一元素，键值将是特定键重复的次数

 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)

Answer 48

import books from "./books.json";

export const getAllBooks = () => {
  return {
    data: books,
    // a=accoumulator, b=book (data itelf), i=index
    bookMap: books.reduce((a, book, i) => {
      // since we passed {} as initial data, initially a={}
      // {bookID1:book1, bookID2:i}
      a[book.id] = book;
      // you can add new property index
      a[book.id].index=i
      return a;
      // we are passing initial data structure
    }, {}),
  };
};

Answer 49

我多次遇到这个问题，并决定编写一个尽可能通用的函数。 看看并随意修改任何内容

function typeOf(obj) {
    if ( typeof(obj) == 'object' ) {
        if (obj.length)
            return 'array';
        else
            return 'object';
    } else
    return typeof(obj);
}

function objToArray(obj, ignoreKeys) {
    var arr = [];
    if (typeOf(obj) == 'object') {
        for (var key in obj) {
            if (typeOf(obj[key]) == 'object') {
                if (ignoreKeys)
                    arr.push(objToArray(obj[key],ignoreKeys));
                else
                    arr.push([key,objToArray(obj[key])]);
            }
            else
                arr.push(obj[key]);
        }
    }else if (typeOf(obj) == 'array') {
        for (var key=0;key<obj.length;key++) {
            if (typeOf(obj[key]) == 'object')
                arr.push(objToArray(obj[key]));
            else
                arr.push(obj[key]);
        }
    }
    return arr;
}

Answer 50

我的版本数组到 JS 中的 json。 Jusy 复制/粘贴并使用它。 这不是很棒吗？ 我喜欢在 StackOverflow 上找到的这类函数。

function array2json(arr) {
    var parts = [];
    var is_list = (Object.prototype.toString.apply(arr) === '[object Array]');

    for(var key in arr) {
        var value = arr[key];
        if(typeof value == "object") { //Custom handling for arrays
            if(is_list) parts.push(array2json(value)); /* :RECURSION: */
            else parts[key] = array2json(value); /* :RECURSION: */
        } else {
            var str = "";
            if(!is_list) str = '"' + key + '":';

            //Custom handling for multiple data types
            if(typeof value == "number") str += value; //Numbers
            else if(value === false) str += 'false'; //The booleans
            else if(value === true) str += 'true';
            else str += '"' + value + '"'; //All other things
            // :TODO: Is there any more datatype we should be in the lookout for? (Functions?)

            parts.push(str);
        }
    }
    var json = parts.join(",");

    if(is_list) return '[' + json + ']';//Return numerical JSON
    return '{' + json + '}';//Return associative JSON
}

Answer 51

 var finalResult = ['a','b','c'].map((item , index) => ({[index] : item})); console.log(finalResult)

Answer 52

一种更面向对象的方法：

Array.prototype.toObject = function() {
 var Obj={};

 for(var i in this) {
  if(typeof this[i] != "function") {
   //Logic here
   Obj[i]=this[i];
  }
 }

 return Obj;
}