lodash: mapowanie tablicy na obiekt

Czy istnieje wbudowana funkcja lodash, aby to zrobić:

var params = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];

I wypisz to:

var output = {
    foo: 'bar',
    baz: 'zle'
};

W tej chwili po prostu używam Array.prototype.reduce() :

function toHash(array, keyName, valueName) {
    return array.reduce(function(dictionary, next) {
        dictionary[next[keyName]] = next[valueName];
        return dictionary;
    }, {});
}

toHash(params, 'name', 'input');

Zastanawiam się, czy istnieje skrót lodash.

Inny sposób z lodash 4.17.2

_.chain(params)
    .keyBy('name')
    .mapValues('input')
    .value();

lub

_.mapValues(_.keyBy(params, 'name'), 'input')

lub z _.reduce

_.reduce(
    params,
    (acc, { name, input }) => ({ ...acc, [name]: input }),
    {}
)

Powinieneś używać _.keyBy, aby łatwo przekonwertować tablicę na obiekt.

Dokumenty tutaj

Przykładowe użycie poniżej:

var params = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];
console.log(_.keyBy(params, 'name'));

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

W razie potrzeby możesz manipulować tablicą przed użyciem _.keyBy lub obiektem po użyciu _.keyBy, aby uzyskać dokładnie pożądany wynik.

Tak, jest tutaj , używając_.reduce

var params = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];

_.reduce(params , function(obj,param) {
 obj[param.name] = param.input
 return obj;
}, {});

Wygląda na to, że jest to zadanie dla Object. assign:

const output = Object.assign({}, ...params.map(p => ({[p.name]: p.input})));

Edytowany do zawijania jako funkcja podobna do OP, wyglądałaby tak:

const toHash = (array, keyName, valueName) => 
    Object.assign({}, ...array.map(o => ({[o[keyName]]: o[valueName]})));

(Dzięki Benowi Stewardowi, dobre myślenie ...)

Możesz użyć javascript z jedną linijką z metodą redukcji tablic i destrukturyzacją ES6, aby przekonwertować tablicę par klucz-wartość na obiekt.

arr.reduce((map, { name, input }) => ({ ...map, [name]: input }), {});

Jest to prawdopodobnie bardziej szczegółowe niż chcesz, ale prosisz o nieco złożoną operację, więc może być zaangażowany rzeczywisty kod (horror).

Moje zalecenie, z zipObjecttym całkiem logiczne:

_.zipObject(_.map(params, 'name'), _.map(params, 'input'));

Inna opcja, bardziej hackerska, używając fromPairs:

_.fromPairs(_.map(params, function(val) { return [val['name'], val['input']));

Funkcja anonimowa pokazuje hacking - nie wierzę, że JS gwarantuje kolejność elementów w iteracji obiektu, więc callling .values()nie wystarczy.

Inny sposób z lodash

tworząc pary, a następnie konstruuj obiekt lub ES6 Mapłatwo

_(params).map(v=>[v.name, v.input]).fromPairs().value()

lub

_.fromPairs(params.map(v=>[v.name, v.input]))

Oto działający przykład

var params = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];

var obj = _(params).map(v=>[v.name, v.input]).fromPairs().value();

console.log(obj);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js"></script>

Może również rozwiązać problem bez użycia funkcji lodash, takiej jak ta:

let paramsVal = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];
let output = {};

paramsVal.forEach(({name, input})=>{
  output[name] = input;
})


console.log(output);