javascript - Cum să convertești un array într-un obiect?

Care este cea mai bună metodă de a converti:

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

către :

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

Răspuns #1

ECMAScript 6 introduce Object.assign, care poate fi ușor completat cu polyfill:

Metoda Object.assign() este folosită pentru a copia valorile tuturor proprietăților proprii enumerabile de la unul sau mai multe obiecte sursă către un obiect țintă. Aceasta va returna obiectul țintă.

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

Proprietatea proprie length a tabloului nu este copiată deoarece nu este enumerabilă.

De asemenea, poți folosi sintaxa spread ES8 pe obiecte pentru a obține același rezultat:

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

Pentru chei personalizate, poți folosi reduce:

['a', 'b', 'c'].reduce((a, v) => ({ ...a, [v]: v}), {}) 
// { a: "a", b: "b", c: "c" }

Răspunsul #2

Cu o funcție ca aceasta:

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

Array-ul tău este deja mai mult sau mai puțin doar un obiect, dar array-urile au un comportament „interesant” și special în ceea ce privește proprietățile numite cu întregi. Ceea ce este de mai sus îți va oferi un obiect simplu.

editează oh, de asemenea, s-ar putea să vrei să ții cont de „găuri” în matrice:

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

În mediile moderne de execuție JavaScript, poți folosi metoda .reduce():

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

Acela evită de asemenea „golurile” din array, pentru că așa funcționează .reduce().

Răspunsul #3

Ai putea folosi un acumulator, cunoscut și ca 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"

Treceți un obiect gol {} ca punct de plecare; apoi „îmbunătățiți” acel obiect treptat. La sfârșitul iterațiilor, result va fi {"0": "a", "1": "b", "2": "c"}

Dacă matricea ta este un set de obiecte pereche cheie-valoare:

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

va produce: {a: 1, b: 2, c: 3}

În scopul completitudinii, reduceRight îți permite să iterezi prin array-ul tău în ordine inversă:

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

va produce: {c:3, b:2, a:1}

Acumulatorul tău poate fi de orice tip pentru scopul tău specific. De exemplu, pentru a schimba cheia și valoarea obiectului tău într-un array, transmite []:

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

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

Spre deosebire de map, reduce nu poate fi folosit ca o mapare 1-la-1. Ai control complet asupra elementelor pe care vrei să le incluzi sau să le excluzi. Prin urmare, reduce îți permite să realizezi ceea ce face filter, ceea ce face ca reduce să fie foarte versatil:

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

va produce: [{2: "b"}, {3: "c"}]

Atenție: reduce și Object.key fac parte din ECMA a 5-a ediție; ar trebui să furnizați un polyfill pentru browserele care nu le suportă (în special IE8).

Vezi o implementare implicită realizată de Mozilla.

Răspunsul #4

Dacă folosești jquery:

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

Răspunsul #5

Pentru completitudine, răspândirea ECMAScript 2015 (ES6). Va necesita fie un transpilator (Babel), fie un mediu care rulează cel puțin ES6.

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

Răspuns #6

Nu mulți oameni aici au comentat despre Object.fromEntries, mie îmi place foarte mult, deoarece este mai curat și funcționează ușor cu TypeScript, fără să te deranjezi prea mult cu tipuri generice și alte chestii. De asemenea, permite chei personalizate cu map, dacă este nevoie. Contra: vei avea nevoie de un map suplimentar, dacă vrei o cheie personalizată. De exemplu:

const tags = [
  { name: 'AgeGroup', value: ageGroup },
  { name: 'ApparelTypes', value: apparelTypes },
  { name: 'Brand', value: brand },
  // ...
]

const objectTags = Object.fromEntries(tags.map((t) => [t.name, t.value]))

/*
{
  AgeGroup: 'Adult',
  Apparel: 'Creeper, Jacket'
  Brand: '',
  // ...
}
*/

Răspunsul #7

În cazul în care doriți să folosiți una dintre proprietățile obiectelor iterate ca cheie, de exemplu:

// from:
const arr = [
    {
        sid: 123,
        name: 'aaa'
    },
    {
        sid: 456,
        name: 'bbb'
    },
    {
        sid: 789,
        name: 'ccc'
    }
];
// to:
{
  '123': { sid: 123, name: 'aaa' },
  '456': { sid: 456, name: 'bbb' },
  '789': { sid: 789, name: 'ccc' }
}

Folosește :

const result = arr.reduce((obj, cur) => ({...obj, [cur.sid]: cur}), {})

Răspuns #8

Probabil aș scrie-o în felul acesta (deoarece foarte rar nu voi avea la îndemână biblioteca underscorejs):

var _ = require('underscore');

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

Răspunsul #9

Putem folosi funcția Object.assign și array.reduce pentru a converti un Array într-un Obiect.

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

console.log(newObj)

Răspuns #10

Iată o metodă O(1) ES2015 doar pentru completitudine.

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

Răspuns #11

Pentru ce merită, o altă abordare recentă este să folosești noul Object.fromEntries împreună cu Object.entries după cum urmează:

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

...care permite evitarea stocării elementelor unui tablou rar ca undefined sau null și păstrează cheile non-index (de exemplu, cele care nu sunt întregi pozitive sau numerice).

{ 0: "a", 1: "b", 2: "c", "-2": "d", salut: "e" }

(Același rezultat aici ca și cu răspunsul lui @Paul Draper Object.assign.)

S-ar putea dori să se adauge arr.length, totuși, deoarece acesta nu este inclus:

obj.length = arr.length;

Răspunsul #12

Dacă array-ul tău conține array-uri cu 2 elemente unde primul element este cheia și al doilea element este valoarea, poți să-l convertești ușor într-un obiect folosind reduce.

[
  ["key1","value1"], 
  ["key2", "value2"], 
  ["key3", "value3"]
]
.reduce((acc, [key, value])=>({...acc, [key]: value}), {});

Rezultat :

{  
  key1: 'value1',   
  key2: 'value2', 
  key3: 'value3'  
}  

Răspunsul #13

Folosind javascript#forEach se poate face acest lucru

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

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

Cu ECMA6:

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

Răspuns #14

Cea mai scurtă răspuns: (folosind destructurarea)

const obj = { ...input }

Exemplu :

const inputArray = ["a", "b", "c"]
const outputObj = { ...inputArray }

Răspuns #15

Dacă folosești ES6, poți folosi Object.assign și operatorul spread

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

Dacă ai un array imbricat precum

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