преобразовать объект массива в объект javascript

Question

У меня есть объект, включающий в себя массивы массивов, как показано ниже

objArray= { hh:[['a','b'],['c','d']],jj:[['x','y'],['z','w']]}

, и здесь я хочу изменить массив на объект:

convertObject

{
  hh:[
      {id:'a', name:'b'},
      {id:'c', name:'d'}
    ],
  jj:[
      {id:'x', name:'y'},
      {id:'z', name:'w'}
    ],
}

Я написал 2 функции для этого, но для этого нужно немного изменить

function convertToObjects(arr) {
  return Object.values(arr).map(e => {
    return { id: e[0], name: e[1] };
  });
}

function convertChoicesToObjects(choicesArray) {
   return Object.keys(choicesArray).map((key) => (convertToObjects(choicesArray[key])));
}

const convertedObject=convertChoicesToObjects(objArray)

Вывод моей функции:

{
  0:[
      {id:'a', name:'b'},
      {id:'c', name:'d'}
    ],
  1:[
      {id:'x', name:'y'},
      {id:'z', name:'w'}
    ],
}

Answer 1

перебирайте ключи и используйте map

const objArray = {"hh": [["a", "b"], ["c", "d"]], "jj": [["x", "y"], ["z", "w"]]};

const output = {};
Object.keys(objArray).forEach(key => {
  output[key] = objArray[key].map(item => ({"id": item[0], "name": item[1]}));
});
console.log(output);

Answer 2

Вы можете построить новый объект с помощью Object.fromEntries.

. Этот подход использует другой массив для требуемых ключей объектов.

var data = { a: [['a', 'b'],['c','d']],b:[['x','y'],['z','w']]},
    keys = ['id', 'name'],
    result = Object.fromEntries(
        Object
            .entries(data)
            .map(([k, v]) => [
                k,
                v.map(a => Object.fromEntries(keys.map((k, i) => [k, a[i]])))
            ])
    );

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 3

Вы можете использовать reduce()

const objArray = { a:[['a','b'],['c','d']],b:[['x','y'],['z','w']]};

const data = Object.keys(objArray).reduce((prev, key) => {
   prev[key] = objArray[key].reduce((res, arr) => {
     res.push({id: arr[0], name: arr[1] });
     return res;
   }, []);
   return prev;
}, {});

console.log(data);

Answer 4

Выход можно получить с помощью простого for...in l oop и с использованием .map() метода массивов:

const input = {
  a: [['a', 'b'], ['c', 'd']],
  b: [['x', 'y'],['z', 'w']]
};

const transform = (input) => {
  const output = {};

  for (key in input) {
    output[key] = input[key].map(([id, name]) => ({id, name}));
  }

  return output;
};

console.log(transform(input));

Answer 5

Вы можете использовать map и forEach методы.

objArray= { a:[['a','b'],['c','d']],b:[['x','y'],['z','w']]}
Object.keys(objArray).forEach((key) => {
  objArray[key] = objArray[key].map(([id, name]) => ({id, name}));
});

console.log(objArray);

Answer 6

Вы можете писать программы, такие как маленькие истории, используя prgm -

const myConvert = (o = {}) =>
  prgm                   // given input object, o
    ( o                  // starting with o
    , Object.entries     // get its entries
    , map (convert1)     // then map over them using convert1
    , Object.fromEntries // then make a new object
    )

const convert1 = ([ key, values ]) =>
  prgm                                        // given input key and values
    ( values                                  // starting with values
    , map (([ id, name ]) => ({ id, name }))  // map over arrays creating objs
    , r => [ key, r ]                         // then create a key/result pair
    )

const input =
  { a: [ ['a','b']
       , ['c','d']
       ]
  , b: [ ['x','y']
       , ['z','w']
       ]
  }

console.log
  ( myConvert (input)
  )

// => { ... }

Чтобы сделать это возможным, нам нужно -

const prgm = (x, ...fs) =>
  fs .reduce ((r, f) => f (r), x)

const map = f => xs =>
  xs .map (x => f (x))

Но, возможно, лучшее название для myConvert это objectMap. Чтобы сделать его обобщенным c, мы сделаем функцию преобразования convert1 параметром. И поскольку нет необходимости изменять ключи входного объекта, мы будем вызывать функцию преобразования только для значений объекта -

const identity = x =>
  x

const objectMap = (f = identity) => (o = {}) => 
  prgm                                 // given mapper, f, and object, o
    ( o                                // starting with o
    , Object.entries                   // get its entries
    , map (([ k, v ]) => [ k, f (v) ]) // transform each v using f
    , Object.fromEntries               // then make a new object
    )

Теперь, используя generi c function objectMap, мы можем написать myConvert как специализация. Это изолирует уникальную сущность вашей трансформации и распутывает ее от остальной части вашей программы -

const myConvert =
  objectMap                                  // using generic objectMap
    ( map (([ id, name ]) => ({ id, name })) // convert arrays to objects
    )

const input =
  { a: [ ['a','b']
       , ['c','d']
       ]
  , b: [ ['x','y']
       , ['z','w']
       ]
  }

console.log
  ( myConvert (input)
  )

// => { ... }

Надеюсь, это показывает силу мышления о ваших программах с разных точек зрения. Запустите фрагмент ниже, чтобы подтвердить результаты в вашем браузере -

const prgm = (x, ...fs) =>
  fs .reduce ((r, f) => f (r), x)

const map = f => xs =>
  xs .map (x => f (x))

const identity = x =>
  x

const objectMap = (f = identity) => (o = {}) =>
  prgm
    ( o
    , Object.entries
    , map (([ k, v ]) => [ k, f (v) ])
    , Object.fromEntries
    )

// ---

const myConvert =
  objectMap
    ( map (([ id, name ]) => ({ id, name }))
    )

const input =
  { a: [ ['a','b']
       , ['c','d']
       ]
  , b: [ ['x','y']
       , ['z','w']
       ]
  }

console.log
  ( myConvert (input)
  )