it-swarm.com.de

Array in Objekt konvertieren

Was ist der beste Weg, um zu konvertieren:

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

zu:

{
  0: 'a',
  1: 'b',
  2: 'c'
}
343
David Hellsing

ECMAScript 6 führt die leicht polyfillable Object.assign ein:

Die Object.assign()-Methode wird verwendet, um die Werte aller .__ zu kopieren. eigene Eigenschaften von einem oder mehreren Quellobjekten auf ein Ziel aufzählen Objekt. Das Zielobjekt wird zurückgegeben.

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

Die eigene length-Eigenschaft des Arrays wird nicht kopiert, da sie nicht aufgezählt werden kann.

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

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

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().

424
Pointy

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 .

217
roland

Wenn Sie Jquery verwenden:

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

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

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

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' }
43
Dave Dopson

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
22

Überrascht, nicht zu sehen -

Object.assign({}, your_array)
20
Wylliam Judd
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 {}.

16
Appeiron

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.

15
locropulenton

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)

13
KARTHIKEYAN.A

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'}
9
Paul Draper

sie können den Spread-Operator verwenden

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

Ein schneller und schmutziger:

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

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

Mit ES6-Syntax können Sie Folgendes tun:

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

5

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);
5
RIYAJ KHAN

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>

4
acontell

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]})))
4
murthy naika k

Schnell und schmutzig # 2:

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

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

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.

3
Redu

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:Recursive Array to Object

2
JVE999

Hier ist eine Lösung in Kaffeescript

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

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;
};
2
Mark Giblin
.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]

2
test30

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']);
2
Vicruz

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
2

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.

1
Pablo Cabrera

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

1

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}), {})
1
Adnan Y

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

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

0
ugwu jude

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

0
Meitham

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

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.

0
Ping.Goblue

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;
0
Brett Zamir

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

0
SridharKritha

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)

0
bvmCoder

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

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. 

0
Daniel Snell

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