Array in Objekt konvertieren

Was ist der beste Weg, um zu konvertieren:

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

zu:

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

ECMAScript 6 führt das leicht polyfüllbare ein Object.assign:

Die Object.assign()Methode wird verwendet, um die Werte aller aufzählbaren eigenen Eigenschaften von einem oder mehreren Quellobjekten in ein Zielobjekt zu kopieren. Das Zielobjekt wird zurückgegeben.

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

Die eigene lengthEigenschaft des Arrays wird nicht kopiert, da sie nicht aufzählbar ist.

Sie können auch die ES6- Spread-Syntax verwenden , um das gleiche Ergebnis zu erzielen:

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

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 Eigenschaften mit ganzzahligen Namen. Das Obige gibt Ihnen ein einfaches Objekt.

edit oh auch du möchtest vielleicht "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 folgende .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 .reduce()funktioniert es.

Sie könnten einen Akku aka verwenden 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"

Übergeben Sie ein leeres Objekt {}als Ausgangspunkt. dann "erweitern" Sie dieses Objekt schrittweise. Am Ende der Iterationen resultwird{"0": "a", "1": "b", "2": "c"}

Wenn Ihr Array aus einer Reihe von Schlüssel-Wert-Paar-Objekten besteht:

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

wird herstellen: {a: 1, b: 2, c: 3}

Der Vollständigkeit halber reduceRightkönnen Sie Ihr Array in umgekehrter Reihenfolge durchlaufen:

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

wird herstellen: {c:3, b:2, a:1}

Ihr Akku kann für Ihren speziellen Zweck von einem beliebigen Typ sein. 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

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

Im Gegensatz zu map, reducekann nicht als 1-1 - Mapping verwendet werden. Sie haben die volle Kontrolle über die Elemente, die Sie ein- oder ausschließen möchten. So reducekönnen Sie erreichen, was filterfunktioniert, was reducesehr 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

wird herstellen: [{2: "b"}, {3: "c"}]

Achtung : reduceund Object.keysind Teil von ECMA 5th edition; Sie sollten eine Polyfüllung für Browser bereitstellen, die diese nicht unterstützen (insbesondere IE8).

Siehe eine Standardimplementierung von Mozilla .

Wenn Sie jquery verwenden:

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

Der Vollständigkeit halber verbreitet sich ECMAScript 2015 (ES6). Benötigt entweder einen Transpiler (Babel) oder eine Umgebung mit mindestens ES6.

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

Ich würde es wahrscheinlich so schreiben (da ich sehr selten nicht die Unterstrichbibliothek 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 der Vollständigkeit halber eine O (1) ES2015-Methode.

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 -

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

Wir können verwenden Object.assignund array.reducefunktionieren, um ein Array in ein Objekt zu konvertieren.

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

console.log(newObj)

Am Ende habe ich den Object Spread Operator verwendet, da dieser Teil des ECMAScript 2015 (ES6) -Standards ist.

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

Habe die folgende Geige als Beispiel gemacht.

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

In modernem JavaScript ist es einfach, Object.assign()nur den Schlüssel zu kopieren: Wert von einem Objekt auf ein anderes. In unserem Fall Arrayspendet Immobilien an neue {}.

Spreizen Sie für ES2016 den Operator für Objekte. Hinweis: Dies ist nach ES6 und daher muss der Transpiler angepasst werden.

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

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

Mit javascript#forEacheinem kann man das machen

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

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

Mit ECMA6:

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

FWIW, ein anderer neuerer Ansatz besteht darin, das Neue Object.fromEntrieszusammen mit Object.entrieswie 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 wird, spärliche Array-Elemente als undefinedoder zu speichern nullund nicht indexierte (z. B. nicht positive Ganzzahl- / nicht numerische) Schlüssel beizubehalten.

Man kann jedoch hinzufügen arr.length, da dies nicht enthalten ist:

obj.length = arr.length;

Sie können den Spread-Operator verwenden

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

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

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

Wenn Sie Array wie verschachtelt haben

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

Eine schnelle und schmutzige:

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

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

Schnell und schmutzig # 2:

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

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

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>

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:

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

[docs]

oder ausführlicher

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 Vanille JS

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

ein 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]

Ich würde das einfach mit machen Array.of(). Array of kann den Kontext als Konstruktor verwenden.

ANMERKUNG 2 Die of-Funktion ist eine absichtlich generische Factory-Methode. Es ist nicht erforderlich, dass dieser Wert der Array-Konstruktor ist. Daher kann es an andere Konstruktoren übertragen oder von diesen geerbt werden, die mit einem einzigen numerischen Argument aufgerufen werden können.

Wir können uns also Array.of()an eine Funktion binden und ein Array-ähnliches Objekt generieren.

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

Durch die Verwendung Array.of() kann man sogar eine Array-Unterklassifizierung durchführen .

Wenn Sie Mapoder verwenden können Object.assign, ist es sehr einfach.

Erstellen Sie ein Array:

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

Im Folgenden wird ein Objekt mit Index als Schlüssel erstellt:

Object.assign({}, languages)

Replizieren Sie dasselbe wie oben mit Maps

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

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

In ein wertbasiertes Objekt konvertieren {css : 'css is great'}etc ...

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

Eine einfache und freche Methode, um ein Array von Elementen schnell in ein Objekt umzuwandeln

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

Dann benutze es so ...

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

Ausgabe:

pork pie

Überprüfen des Typs:

typeof obj
"object"

UND die Dinge wären nicht vollständig, wenn es keine Prototypmethode gäbe

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

Verwenden von like:

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

Ausgabe:

cheese whizz

* HINWEIS: Es gibt keine Benennungsroutine. Wenn Sie also bestimmte Namen haben möchten, müssen Sie die vorhandenen Methoden weiter unten verwenden.

Ältere Methode

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, muss die Funktion gleich lange Arrays haben, sonst erhalten Sie 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;
};

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

ES5 - Lösung:

Mit den Array- Prototypfunktionen '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

Eine vom Browser unterstützte und flexiblere Methode besteht darin, eine normale Schleife zu verwenden , etwa:

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

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

Aber auch die moderne Art könnte den Spread-Operator verwenden , wie:

{...arr}

Oder Objekt zuweisen :

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

Beide werden zurückkehren :

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

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 spärliche Arrays effizienter handhaben.

Hier ist eine Lösung in Coffeescript

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