Diziyi Nesneye Dönüştür

Dönüştürmenin en iyi yolu nedir:

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

için:

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

ECMAScript 6 kolayca poli-doldurulabilir olanı sunar Object.assign:

Object.assign()Usul, bir hedef nesne, bir ya da daha fazla kaynak nesnelerden her numaralandırılabilir kendi özelliklerinin değerlerini kopyalamak için kullanılır. Hedef nesneyi döndürür.

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

Dizinin kendi lengthözelliği numaralandırılamadığından kopyalanmaz.

Ayrıca, aynı sonucu elde etmek için ES6 forma sözdizimini kullanabilirsiniz:

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

Bunun gibi bir işlevle:

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

Diziniz zaten az ya da çok sadece bir nesnedir, ancak dizilerin tamsayı olarak adlandırılan özelliklere göre bazı "ilginç" ve özel davranışları vardır. Yukarıdakiler size düz bir nesne verecektir.

düzenlemek oh ayrıca dizi "delikler" için hesap oluşturmak isteyebilirsiniz:

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

Modern JavaScript çalışma zamanlarında, .reduce()yöntemi kullanabilirsiniz :

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

Bu da dizideki "deliklerden" kaçınır, çünkü böyle .reduce()çalışır.

Bir akümülatör aka kullanabilirsiniz 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"

Boş bir nesneyi {}başlangıç ​​noktası olarak iletin; sonra bu nesneyi adım adım "büyüt". Tekrarlamalar sonunda resultolacak{"0": "a", "1": "b", "2": "c"}

Diziniz bir dizi anahtar / değer çifti nesnesiyse:

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

üretecek: {a: 1, b: 2, c: 3}

Tamlık uğruna, reduceRightdizinizi ters sırayla yinelemenizi sağlar:

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

üretecek: {c:3, b:2, a:1}

Akümülatörünüz size özel bir amaç için herhangi bir tipte olabilir. Örneğin, bir dizideki nesnenizin anahtarını ve değerini değiştirmek için şunu iletin []:

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

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

Bunun aksine map, reduce1-1 eşleme olarak kullanılamaz. Eklemek veya hariç tutmak istediğiniz öğeler üzerinde tam kontrole sahipsiniz. Bu nedenle reduce, çok yönlü filterkılan şeyleri elde etmenizi sağlar 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

üretecek: [{2: "b"}, {3: "c"}]

Dikkat : reduceve Object.keybir parçasıdır ECMA 5th edition; desteklemeyen tarayıcılar için (özellikle IE8) bir çoklu dolgu sağlamalısınız.

Mozilla'nın varsayılan uygulamasına bakın .

Jquery kullanıyorsanız:

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

Bütünlük için ECMAScript 2015 (ES6) yayılıyor. Bir transpiler (Babel) veya en az ES6 çalıştıran bir ortam gerektirir.

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

Muhtemelen bu şekilde yazardım (çok nadiren elimde underscorejs kütüphanesine sahip olmayacağım):

var _ = require('underscore');

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

İşte tamlık için O (1) ES2015 yöntemi.

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

Görmemek şaşırdı -

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

Kullanabileceğimiz Object.assignve array.reducenesne için bir dizisi dönüştürmek için çalışır.

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

console.log(newObj)

ECMAScript 2015 (ES6) standardının bir parçası olduğu için nesne yayma operatörü kullandım.

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

Aşağıdaki kemanı örnek olarak yaptık .

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

Modern JavaScript'te kolay yol, Object.assign()anahtar: değeri bir nesneden diğerine kopyalamaktan başka bir şey yapmamaktır. Bizim durumumuzda, Arrayözellikleri yenilere bağışlar {}.

ES2016 için, nesneler için işleci dağıtın. Not: Bu sonra ES6 ve transpiler ayarlanması gerekir böylece.

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

Beş yıl sonra, iyi bir yol var :)

Object.assign ECMAScript 2015'te tanıtıldı.

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

javascript#forEachBirini kullanmak bunu yapabilir

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

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

ECMA6 ile:

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

FWIW, birbirini son yaklaşım yeni kullanmaktır Object.fromEntriesbirlikte Object.entriesaşağıdaki şekilde:

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

... bu, seyrek dizi öğelerinin undefinedveya olarak saklanmasından kaçınmaya izin verir nullve dizin olmayan (örn., pozitif olmayan tamsayı / sayısal olmayan) anahtarları korur.

arr.lengthBununla birlikte, bu dahil edilmediğinden eklemek isteyebilirsiniz :

obj.length = arr.length;

forma operatörünü kullanabilirsiniz

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

ES6 kullanıyorsanız, Object.assign ve forma operatörünü kullanabilirsiniz

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

Gibi bir iç içe diziniz varsa

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

Hızlı ve kirli olanı:

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

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

Hızlı ve kirli # 2:

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

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

Lodash 3.0.0 itibariyle kullanabilirsiniz _.toPlainObject

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

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

İşte az önce yazdığım özyinelemeli bir işlev. Çok basit ve iyi çalışıyor.

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

İşte bir örnek ( 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));

Sonuçlar:

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

[Dokümanlar]

veya daha fazla ayrıntılı

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

veya

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

vanilya JS ile en kısa

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

daha karmaşık bir örnek

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

daha da kısa ( function(e) {console.log(e); return e;}=== kullanarak (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 ] }

[/ Dokümanlar]

Bunu sadece ile yapardım Array.of(). Array, bağlamını bir kurucu olarak kullanma yeteneğine sahiptir.

Not 2 - işlevi kasıtlı olarak genel bir fabrika yöntemidir; bu değerinin Dizi yapıcısı olmasını gerektirmez. Bu nedenle, tek bir sayısal argümanla çağrılabilen diğer kuruculara aktarılabilir veya devralınabilir.

Bu nedenle Array.of()bir işleve bağlanabilir ve nesne gibi bir dizi oluşturabiliriz.

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

Array.of() Hatta birini kullanarak dizi alt sınıflandırma yapabilirsiniz .

Eğer kullanabiliyorsa Mapya Object.assign, bu çok kolaydır.

Dizi oluşturun:

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

Aşağıda, anahtar olarak dizini olan bir nesne oluşturulur:

Object.assign({}, languages)

Yukarıdakiyle aynı şeyi Google Haritalar ile çoğaltın

Dizin tabanlı bir nesneye {0 : 'css'}vb. Dönüştürür.

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

Değere dayalı bir nesneye dönüştürme {css : 'css is great'}vb.

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

Bir dizi öğeyi hızla bir nesneye dönüştürmenin basit ve arsız bir yöntemi

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

Sonra böyle kullanıyor ...

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

Çıktı:

pork pie

Türü kontrol etme:

typeof obj
"object"

VE bir prototip yöntemi olmasaydı işler tamamlanmazdı

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

Gibi kullanarak:

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

Çıktı:

cheese whizz

* Bir adlandırma yordamı olmadığını unutmayın, bu nedenle belirli adlara sahip olmak istiyorsanız, aşağıdaki mevcut yöntemleri kullanmaya devam etmeniz gerekir.

Eski yöntem

Bu, bir diziden, tanımladığınız tuşları kullanarak istediğiniz sırada bir nesne oluşturmanızı sağlar.

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" çıktısı verirse, fonksiyon eşit uzunlukta dizilere sahip olmalıdır veya boş bir nesne elde edersiniz.

İşte güncellenmiş bir yöntem

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

Veya kullan

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

ES5 - Çözüm:

Kullanılması Dizi prototip işlevi push ' ve 'uygulamak' dizi öğelerinin nesneyi doldurabilirsiniz.

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

Daha fazla tarayıcı destekli ve bunu yapmanın daha esnek bir yolu, normal bir döngü kullanıyor :

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

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

Ama aynı zamanda modern yol, forma operatörünü kullanmak olabilir , örneğin:

{...arr}

Veya Nesne atama :

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

Her ikisi de geri dönecek :

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

Bunun gibi bir işlev kullanabilirsiniz:

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

Bu, seyrek dizileri daha verimli bir şekilde ele almalıdır.

İşte kahvede bir çözüm

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