Mit Karte und reduzieren Array von Objekten erhalten

Question

I

var c = [{name: 'John'}, {name: 'John'}, {name: 'Tom'}]; 

eine Reihe von habe ich mag, dass die Methode reduzieren verwenden und die Landkarte folgende Ergebnisse zu erhalten:

result = [ 
    { name: "John", occurence: 2 }, 
    { name: "Tom", occurence: 1 } 
    ] 

Hier ein ist Versuch ich habe es versucht aber immer noch nicht ganz verstanden. https://jsfiddle.net/joeSaad/up3ddfzz/

c = [{ 
 
    name: 'John' 
 
}, { 
 
    name: 'John' 
 
}, { 
 
    name: 'Simon' 
 
}]; 
 

 
var d = c.reduce((countMap, word) => { 
 
    countMap[word.name] = ++countMap[word.name] || 1; 
 
    return countMap 
 
}, []); 
 

 
var e = c.reduce((countMap, word) => { 
 
    q = []; 
 
    countMap[word.name] = ++countMap[word.name] || 1; 
 
    var p = { 
 
    name: word.name, 
 
    occurence: countMap[word.name] 
 
    } 
 
    q.push(p); 
 
    return q 
 
}, []); 
 

 
console.log(e);

Hilfe sehr geschätzt. Vielen Dank im Voraus

Answer 1

Sie sind definitiv auf dem richtigen Weg mit reduzieren arbeiten, aber ich würde die Berechnungen in zwei Schritten

let c = [{name: 'John'}, {name: 'John'}, {name: 'Tom'}]; 
 

 
const pairs = o=> Object.keys(o).map(k=> [k, o[k]]) 
 

 
let count = c.reduce((acc, {name}) => { 
 
    if (acc[name] === undefined) 
 
    return Object.assign(acc, { [name]: 1 }) 
 
    else 
 
    return Object.assign(acc, { [name]: acc[name] + 1 }) 
 
}, {}) 
 

 
var result = pairs(count).map(([name, occurences]) => ({name, occurences})) 
 

 
console.log(result) 
 
//=> [ { name: 'John', occurences: 2 }, { name: 'Tom', occurences: 1 } ]

---

Sie könnten abstrakt diese Verhaltensweisen trennen in verschiedene Funktionen wie diese

// convert an object to [[key,value]] pairs 
 
const pairs = o=> Object.keys(o).map(k=> [k, o[k]]) 
 

 
// count unique instances of a property value in an array of objects 
 
const countBy = (prop, xs)=> { 
 
    return xs.reduce((acc, x)=> { 
 
    let y = x[prop] 
 
    if (acc[y] === undefined) 
 
     return Object.assign(acc, { [y]: 1 }) 
 
    else 
 
     return Object.assign(acc, { [y]: acc[y] + 1 }) 
 
    }, {}) 
 
} 
 

 
// your data 
 
let c = [{name: 'John'}, {name: 'John'}, {name: 'Tom'}] 
 

 
// then chain it all together 
 
let result = pairs(countBy('name', c)).map(([name, occurences]) => ({name, occurences})) 
 

 
console.log(result) 
 
//=> [ { name: 'John', occurences: 2 }, { name: 'Tom', occurences: 1 } ]

---

ES6 bietet auch Map, die dafür diese Art der Berechnung ist ziemlich gut.

Dieser Code liest sich ein bisschen netter zu mir und ist ein wenig mehr semantisch korrekt. Unser vorheriger Code hat genau dasselbe gemacht, nur mit einem einfachen Objekt. Map ist eine Datenstruktur speziell für diese key->value Daten entwickelt, so dass Map eine bessere Wahl macht.

Das einzige Problem mit diesem ist, wenn Ihre Codebasis Karten nicht irgendwie in irgendeiner Weise verwendet, könnte das Einführen sie gerade dafür der falsche Zug sein.

// convert a Map to an array of pairs 
 
const mpairs = m=> [...m.entries()] 
 

 
// countBy this time uses Map 
 
const countBy = (prop, xs)=> { 
 
    return xs.reduce((m, x)=> { 
 
    let y = x[prop] 
 
    if (m.has(y)) 
 
     return m.set(y, m.get(y) + 1) 
 
    else 
 
     return m.set(y, 1) 
 
    }, new Map) 
 
} 
 

 
// your data 
 
let c = [{name: 'John'}, {name: 'John'}, {name: 'Tom'}] 
 

 
// then chain it all together 
 
let result = mpairs(countBy('name', c)).map(([name, occurences]) => ({name, occurences})) 
 

 
console.log(result) 
 
//=> [ { name: 'John', occurences: 2 }, { name: 'Tom', occurences: 1 } ]