Array in Objekt konvertieren

Mit einer Funktion wie dieser:

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

Ihr Array ist bereits mehr oder weniger nur ein Objekt, aber Arrays haben ein "interessantes" und spezielles Verhalten in Bezug auf ganzzahlige Eigenschaften. Das oben genannte gibt Ihnen ein einfaches Objekt.

edit oh Sie möchten vielleicht auch "Löcher" im Array berücksichtigen:

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

In modernen JavaScript-Laufzeiten können Sie die .reduce()-Methode verwenden:

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

Das vermeidet auch "Löcher" im Array, denn so funktioniert .reduce().

Sie könnten einen Akkumulator auch als reduce verwenden.

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

Übergeben Sie ein leeres Objekt {} als Ausgangspunkt. dann "vergrößern" Sie dieses Objekt inkrementell . Am Ende der Iterationen wird result{"0": "a", "1": "b", "2": "c"} sein.

Wenn Ihr Array ein Satz von Schlüssel-Wert-Paarobjekten ist:

[{ 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;
}, {});

produziert: {a: 1, b: 2, c: 3}

Der Vollständigkeit halber können Sie mit reduceRight das Array in umgekehrter Reihenfolge durchlaufen:

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

produziert: {c:3, b:2, a:1}

Ihr Akkumulator kann für jeden Zweck einen beliebigen Typ haben. Um beispielsweise den Schlüssel und den Wert Ihres Objekts in einem Array auszutauschen, übergeben Sie []:

[{ 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

produziert: [{1: "a"}, {2: "b"}, {3: "c"}]

Im Gegensatz zu map kann reduce nicht als 1-1-Zuordnung verwendet werden. Sie haben die vollständige Kontrolle über die Elemente, die Sie einschließen oder ausschließen möchten. Daher ermöglicht Ihnen reduce, das zu erreichen, was filter macht, was reduce sehr vielseitig macht:

[{ 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

produziert: [{2: "b"}, {3: "c"}]

Caution: reduce und Object.key sind Bestandteil von ECMA 5th edition; Sie sollten eine Polyfill für Browser bereitstellen, die diese nicht unterstützen (insbesondere IE8).

Eine Standardimplementierung finden Sie unter Mozilla .

Wenn Sie Jquery verwenden:

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

Zur Vollständigkeit Verbreitung von ECMAScript 2015 (ES6). Benötigt entweder einen Transpiler (Babel) oder eine Umgebung mit mindestens ES6.

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

Ich würde es wahrscheinlich so schreiben (da ich sehr selten die Underscore-Bibliothek nicht zur Hand habe):

var _ = require('underscore');

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

Hier ist eine O(1) ES2015-Methode nur der Vollständigkeit halber.

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

Überrascht, nicht zu sehen -

Object.assign({}, your_array)

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

Der einfache Weg in modernem JavaScript ist die Verwendung von Object.assign(), die nichts anderes tut als den Schlüssel zu kopieren: value von einem Objekt zu einem anderen. In unserem Fall spendet Array Eigenschaften an den neuen {}.

Ich habe am Ende den Object Spread Operator verwendet, da er Teil des Standards ECMAScript 2015 (ES6) ist.

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

Die folgende Geige als Beispiel gemacht.

wir können Object.assign und array.reduce verwenden, um ein Array in Object ..__ zu konvertieren.

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

console.log(newObj)

Fünf Jahre später gibt es einen guten Weg :)

Object.assign wurde in ECMAScript 2015 eingeführt.

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

sie können den Spread-Operator verwenden

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

Ein schneller und schmutziger:

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

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

Mit ES6-Syntax können Sie Folgendes tun:

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

Mit javascript#forEach kann man dies tun

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

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

Mit ECMA6:

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

Ab Lodash 3.0.0 können Sie _.toPlainObject verwenden.

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

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

Wenn Sie ES6 verwenden, können Sie Object.assign und den Spread-Operator verwenden

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

Wenn Sie ein verschachteltes Array haben

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

Schnell und schmutzig # 2:

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

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

Ich würde das einfach mit Array.of() machen. Array of hat die Fähigkeit, seinen Kontext als Konstruktor zu verwenden.

ANMERKUNG 2 Die of-Funktion ist eine absichtlich generische Fabrikmethode; es erfordert nicht, dass dieser Wert der Array-Konstruktor ist . Daher kann es auf andere Konstruktoren übertragen oder vererbt werden Das kann mit einem einzigen numerischen Argument aufgerufen werden.

So können wir Array.of() an eine Funktion binden und ein Array wie ein Objekt erzeugen.

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

Mit Array.of()kann man sogar Array-Unterklassen durchführen.

Hier ist eine rekursive Funktion, die ich gerade geschrieben habe. Es ist einfach und funktioniert gut.

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

Hier ist ein Beispiel ( 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));

Ergebnisse:

Hier ist eine Lösung in Kaffeescript

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

Auf diese Weise können Sie aus einem Array ein Objekt mit Schlüsseln generieren, die Sie in der gewünschten Reihenfolge definieren. 

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); gibt "Paint" aus, die Funktion muss gleich lange Arrays haben oder Sie erhalten ein leeres Objekt.

Hier ist eine aktualisierte Methode

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

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

[docs]

oder mehr ausführlich

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

oder

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

kürzeste mit Vanilla JS

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

etwas komplexeres Beispiel

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

noch kürzer (mit 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 ] }

[/ docs]

Wenn Sie anglejs verwenden, können Sie angle.extend verwenden, den gleichen Effekt mit $ .extend of jquery.

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

Wenn Sie Map oder Object.assign verwenden können, ist dies sehr einfach.

Erstellen Sie ein Array:

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

Die folgende Tabelle erstellt ein Objekt mit Index als Schlüssel:

Object.assign({}, languages)

Wiederholen Sie das gleiche wie oben mit Maps

Konvertiert in ein indexbasiertes Objekt {0 : 'css'} etc ...

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

Konvertieren Sie in ein Wertobjekt {css : 'css is great'} etc ...

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

Sie könnten eine Funktion wie diese verwenden:

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

Dieser sollte mit spärlichen Arrays effizienter umgehen.

let i = 0;
let myArray = ["first", "second", "third", "fourth"];

const arrayToObject = (arr) =>
    Object.assign({}, ...arr.map(item => ({[i++]: item})));

console.log(arrayToObject(myArray));

Oder verwenden

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

Es ist nicht direkt relevant, aber ich kam hier her und suchte nach einem Einzeiler, um verschachtelte Objekte wie 

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

Die Lösung besteht darin, eine Kombination aus Verkleinerung und Objektverbreitung zu verwenden:

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

Ich habe dieses Problem mehrmals angetreten und beschlossen, eine möglichst generische Funktion zu schreiben. Schauen Sie sich um und fühlen Sie sich frei, alles zu ändern

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

Verwenden Sie die Javascript-Lodash-Bibliothek. Es gibt eine einfache Methode _.mapKeys(object, [iteratee=_.identity]) das kann die Konvertierung tun. 

Ich würde Unterstriche dafür verwenden, aber wenn das nicht verfügbar ist, würde ich mit dem anfänglichen Wert von empty object {} zum Einsatz kommen.

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

reduzieren sollte in den meisten Browsern heute allgemein verfügbar sein, siehe MDN

Mehr Browser unterstützt die Art und Weise, dies zu tun, ist eine normale Schleife, so etwas wie:

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

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

Aber auch der moderne Weg könnte sein, den Spread Operator zu benutzen, wie:

{...arr}

Oder Objekt zuweisen:

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

Beide werden return:

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

Es ist einfach, Javascript zu verwenden:

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

Sie können einen Blick auf Array.prototype.reduce (), https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce werfen.

FWIW, ein anderer neuer Ansatz besteht darin, den neuen Object.fromEntries zusammen mit Object.entries wie folgt zu verwenden:

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

..., wodurch vermieden werden kann, spärliche Array-Elemente als undefined oder null zu speichern, und nicht-indische (z. B. nicht-positive ganze/nicht-numerische) Schlüssel beibehalten.

Vielleicht möchten Sie arr.length hinzufügen, da dies nicht enthalten ist:

obj.length = arr.length;

ES5 - Lösung:

Mit Array Prototypfunktion 'Push' und 'apply' können Sie das Objekt mit den Array-Elementen füllen.

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

anfängliches Array und konvertiert in ein Objekt mit Schlüsseln, das das eindeutige Element eines Arrays ist, und der Schlüsselwert gibt an, wie oft sich die betreffenden Schlüssel wiederholen

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)

Die Methode unten würde ein Array in ein Objekt mit einem bestimmten Schlüssel konvertieren.

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

Für Ex -

[{Name: 'Test'}, {Name: 'Test1'}]. ArrayToObject ('Name');

würde geben 

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

und der Incase-Schlüssel wird nicht als Parameter für die Methode bereitgestellt

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

würde geben 

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

Am einfachsten ist dies folgendermaßen: 

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

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

Auf diese Weise wird es nur ausgeführt, wenn es sich um ein Array handelt. Sie können dies jedoch mit der globalen Objektvariable let oder ohne ausführen. Dies liegt an Ihnen. Wenn Sie ohne let ausführen, führen Sie einfach Object.assign ({}, arr) aus. 

Wenn Sie Oneliner mögen und IE8 kein Problem mehr ist (wie es sein sollte)

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

Versuchen Sie es auf der Browserkonsole

Es kann so viel ausführlicher sein:

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

Aber IE8 noch ausschließen. Wenn IE8 ein Muss ist, können Sie lodash/Unterstrich so verwenden:

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