我将使用Array.of()简单地做到这一点。Array of有能力使用它的context作为构造函数。

注2:of函数是一个有意通用的工厂方法;它 不要求它的this值是数组构造函数。 因此，它可以传递给其他构造函数或由其他构造函数继承 可以使用单个数值参数调用。

因此，我们可以将array .of()绑定到一个函数，并生成类似object的数组。

虚函数(){}; var thingy = Array.of.apply(dummy，[1,2,3,4]); console.log(页面);

通过使用array .of()，甚至可以进行数组子类化。

我曾多次遇到过这个问题，并决定编写一个尽可能通用的函数。看一看，可以随意修改吗

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

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

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

结果:

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

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

(文档)

或者更冗长

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

or

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

甚至更短(通过使用函数(e) {console.log(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 ] }

[/ docs]

用这样的函数:

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()就是这样工作的。