Kullanım Durumu

Kullanım örneği, bir nesne dizisini, karma eşlemede anahtar olarak ve bir nesnenin kendisi olarak değer olarak değerlendirmek ve kullanmak için sağlanan dizeye veya işleve dayalı bir karma haritaya dönüştürmektir. Bunu kullanmanın yaygın bir örneği, bir nesne dizisini karma nesne eşlemesine dönüştürmektir.

kod

Aşağıda, bir nesne dizisini bir nesnenin öznitelik değeriyle dizinlenmiş bir karma haritaya dönüştüren küçük bir snippet bulunmaktadır. Karma haritanın anahtarını dinamik olarak değerlendirmek için bir işlev sağlayabilirsiniz (çalışma süresi). Umarım bu gelecekte birine yardımcı olur.

function isFunction(func) {
    return Object.prototype.toString.call(func) === '[object Function]';
}

/**
 * This function converts an array to hash map
 * @param {String | function} key describes the key to be evaluated in each object to use as key for hashmap
 * @returns Object
 * @Example 
 *      [{id:123, name:'naveen'}, {id:345, name:"kumar"}].toHashMap("id")
 *      Returns :- Object {123: Object, 345: Object}
 *
 *      [{id:123, name:'naveen'}, {id:345, name:"kumar"}].toHashMap(function(obj){return obj.id+1})
 *      Returns :- Object {124: Object, 346: Object}
 */
Array.prototype.toHashMap = function(key) {
    var _hashMap = {}, getKey = isFunction(key)?key: function(_obj){return _obj[key];};
    this.forEach(function (obj){
        _hashMap[getKey(obj)] = obj;
    });
    return _hashMap;
};

Özeti burada bulabilirsiniz: Nesneler Dizisini HashMap'e dönüştürür .

Bu, aşağıdakilerle oldukça önemsizdir Array.prototype.reduce:

var arr = [
    { key: 'foo', val: 'bar' },
    { key: 'hello', val: 'world' }
];

var result = arr.reduce(function(map, obj) {
    map[obj.key] = obj.val;
    return map;
}, {});

console.log(result);
// { foo:'bar', hello:'world' }

Not: Array.prototype.reduce() IE9 + 'dır, bu nedenle eski tarayıcıları desteklemeniz gerekiyorsa çoklu doldurmanız gerekir.

ES6 Haritasını ( oldukça iyi desteklenen ) kullanarak şunları deneyebilirsiniz:

var arr = [
    { key: 'foo', val: 'bar' },
    { key: 'hello', val: 'world' }
];

var result = new Map(arr.map(i => [i.key, i.val]));

// When using TypeScript, need to specify type:
// var result = arr.map((i): [string, string] => [i.key, i.val])

// Unfortunately maps don't stringify well.  This is the contents in array form.
console.log("Result is: " + JSON.stringify([...result])); 
// Map {"foo" => "bar", "hello" => "world"}

İle lodash , bu kullanılarak yapılabilir keyBy :

var arr = [
    { key: 'foo', val: 'bar' },
    { key: 'hello', val: 'world' }
];

var result = _.keyBy(arr, o => o.key);

console.log(result);
// Object {foo: Object, hello: Object}

ES6 spread + Object.assign kullanma:

array = [{key: 'a', value: 'b', redundant: 'aaa'}, {key: 'x', value: 'y', redundant: 'zzz'}]

const hash = Object.assign({}, ...array.map(s => ({[s.key]: s.value})));

console.log(hash) // {a: b, x: y}

Forma operatörünü kullanma:

const result = arr.reduce(
    (accumulator, target) => ({ ...accumulator, [target.key]: target.val }),
    {});

JsFiddle'da kod snippet'inin gösterilmesi .

Array.prototype.reduce () ve yalnızca JavaScript Nesnesi yerine gerçek JavaScript Haritasını kullanabilirsiniz .

let keyValueObjArray = [
  { key: 'key1', val: 'val1' },
  { key: 'key2', val: 'val2' },
  { key: 'key3', val: 'val3' }
];

let keyValueMap = keyValueObjArray.reduce((mapAccumulator, obj) => {
  // either one of the following syntax works
  // mapAccumulator[obj.key] = obj.val;
  mapAccumulator.set(obj.key, obj.val);

  return mapAccumulator;
}, new Map());

console.log(keyValueMap);
console.log(keyValueMap.size);

Harita ve Nesne arasındaki fark nedir?
Daha önce, Harita JavaScript'te uygulanmadan önce, Object benzer yapıları nedeniyle Harita olarak kullanılıyordu.
Kullanım durumunuza bağlı olarak, sipariş anahtarlarına ihtiyacınız varsa, haritanın boyutuna erişmeniz veya haritadan sık sık ekleme ve çıkarma yapmanız gerekiyorsa, bir Harita tercih edilir.

MDN belgesinden alıntı :
Nesneler, anahtarları değerlere ayarlamanıza, bu değerleri almanıza, anahtarları silmenize ve bir anahtarda bir şeyin depolanıp depolanmadığını belirlemenize olanak tanıdığı için Haritalar'a benzer. Bu nedenle (ve yerleşik alternatifler olmadığından), Nesneler tarihsel olarak Haritalar olarak kullanılmıştır; ancak, bazı durumlarda bir Harita kullanmayı tercih edilen önemli farklılıklar vardır:

• Bir Nesnenin anahtarları Dizeler ve Sembollerdir, oysa işlevler, nesneler ve herhangi bir ilkel dahil bir Harita için herhangi bir değer olabilirler.
• Haritadaki anahtarlar, nesneye eklenen anahtarlar sıralanmamışken sıralanmıştır. Böylece, yinelendiğinde, bir Map nesnesi anahtarları ekleme sırasına göre döndürür.
• Bir nesnenin özelliklerinin manuel olarak belirlenmesi gerekirken, haritanın boyutunu size özelliğiyle kolayca alabilirsiniz.
• Bir Harita yinelenebilir ve bu nedenle doğrudan yinelenebilir, oysa bir Nesne üzerinde yineleme, anahtarlarının bir şekilde elde edilmesini ve bunların üzerinde yinelenmesini gerektirir.
• Bir Nesnenin bir prototipi vardır, bu nedenle haritada dikkatli değilseniz anahtarlarınızla çarpışabilecek varsayılan anahtarlar vardır. ES5'ten itibaren map = Object.create (null) kullanılarak atlanabilir, ancak bu nadiren yapılır.
• Bir Harita, anahtar çiftlerinin sık sık eklenmesini ve kaldırılmasını içeren senaryolarda daha iyi performans gösterebilir.

Yeni Object.fromEntries()yöntemi kullanabilirsiniz .

Misal:

const array = [
   {key: 'a', value: 'b', redundant: 'aaa'},
   {key: 'x', value: 'y', redundant: 'zzz'}
]

const hash = Object.fromEntries(
   array.map(e => [e.key, e.value])
)

console.log(hash) // {a: b, x: y}

es2015 sürümü:

const myMap = new Map(objArray.map(obj => [ obj.key, obj.val ]));

TypeScript'te yaptığım şey bu gibi şeyleri koyduğum küçük bir yardımcı program kütüphanem var

export const arrayToHash = (array: any[], id: string = 'id') => 
         array.reduce((obj, item) =>  (obj[item[id]] = item , obj), {})

kullanımı:

const hash = arrayToHash([{id:1,data:'data'},{id:2,data:'data'}])

veya 'id' dışında bir tanımlayıcı varsa

const hash = arrayToHash([{key:1,data:'data'},{key:2,data:'data'}], 'key')

Bunu diğer posterlerde açıklandığı gibi yapmanın daha iyi yolları vardır. Ama saf JS ve ol 'moda şekilde yapışmak istiyorsanız o zaman işte burada:

var arr = [
    { key: 'foo', val: 'bar' },
    { key: 'hello', val: 'world' },
    { key: 'hello', val: 'universe' }
];

var map = {};
for (var i = 0; i < arr.length; i++) {
    var key = arr[i].key;
    var value = arr[i].val;

    if (key in map) {
        map[key].push(value);
    } else {
        map[key] = [value];
    }
}

console.log(map);

Yeni ES6 Haritasına dönüştürmek istiyorsanız bunu yapın:

var kvArray = [['key1', 'value1'], ['key2', 'value2']];
var myMap = new Map(kvArray);

Neden bu tür bir Harita kullanmalısınız? Bu size bağlı. Bir göz atın bu .

Basit Javascript kullanma

var createMapFromList = function(objectList, property) {
    var objMap = {};
    objectList.forEach(function(obj) {
      objMap[obj[property]] = obj;
    });
    return objMap;
  };
// objectList - the array  ;  property - property as the key

İle lodash:

const items = [
    { key: 'foo', value: 'bar' },
    { key: 'hello', value: 'world' }
];

const map = _.fromPairs(items.map(item => [item.key, item.value]));

console.log(map); // { foo: 'bar', hello: 'world' }

reduceKullanımda küçük bir gelişme :

var arr = [
    { key: 'foo', val: 'bar' },
    { key: 'hello', val: 'world' }
];

var result = arr.reduce((map, obj) => ({
    ...map,
    [obj.key] = obj.val
}), {});

console.log(result);
// { foo: 'bar', hello: 'world' }

Deneyin

let toHashMap = (a,f) => a.reduce((a,c)=> (a[f(c)]=c,a),{});

let arr=[
  {id:123, name:'naveen'}, 
  {id:345, name:"kumar"}
];

let fkey = o => o.id; // function changing object to string (key)

let toHashMap = (a,f) => a.reduce((a,c)=> (a[f(c)]=c,a),{});

console.log( toHashMap(arr,fkey) );

// Adding to prototype is NOT recommented:
//
// Array.prototype.toHashMap = function(f) { return toHashMap(this,f) };
// console.log( arr.toHashMap(fkey) );

Aşağıda, nesnelerin öznitelik değeriyle dizinlenmiş nesne dizisini karma haritaya dönüştürmek için javascript'te oluşturduğum küçük snippet. Karma haritanın anahtarını dinamik olarak değerlendirmek için bir işlev sağlayabilirsiniz (çalışma süresi).

function isFunction(func){
    return Object.prototype.toString.call(func) === '[object Function]';
}

/**
 * This function converts an array to hash map
 * @param {String | function} key describes the key to be evaluated in each object to use as key for hasmap
 * @returns Object
 * @Example 
 *      [{id:123, name:'naveen'}, {id:345, name:"kumar"}].toHashMap("id")
        Returns :- Object {123: Object, 345: Object}

        [{id:123, name:'naveen'}, {id:345, name:"kumar"}].toHashMap(function(obj){return obj.id+1})
        Returns :- Object {124: Object, 346: Object}
 */
Array.prototype.toHashMap = function(key){
    var _hashMap = {}, getKey = isFunction(key)?key: function(_obj){return _obj[key];};
    this.forEach(function (obj){
        _hashMap[getKey(obj)] = obj;
    });
    return _hashMap;
};

Buradaki özü burada bulabilirsiniz: https://gist.github.com/naveen-ithappu/c7cd5026f6002131c1fa