One-liner per acquisire alcune proprietà dall'oggetto in ES 6

Question

Come si può scrivere una funzione, che richiede solo pochi attributi in modo più compatto in ES6?

Mi è venuta in mente una soluzione che utilizza la destrutturazione + oggetto semplificato letterale, ma non mi piace che l'elenco di campi venga ripetuto nel codice.

C'è una soluzione ancora più sottile?

(v) => { 
    let { id, title } = v; 
    return { id, title }; 
} 

Answer 1

Ecco qualcosa di più sottile, anche se non evita di ripetere l'elenco dei campi. Utilizza "destrutturazione dei parametri" per evitare la necessità del parametro v.

({id, title}) => ({id, title}) 

@ La soluzione di EthanBrown è più generale. Ecco una versione più idiomatica di esso che utilizza Object.assign, e le proprietà computerizzata (la [p] parte):

function pick(o, ...props) { 
    return Object.assign({}, ...props.map(prop => ({[prop]: o[prop]}))); 
} 

Se vogliamo conservare gli attributi le proprieta, come configurable e getter e setter, ma anche omettendo non proprietà -enumerable, allora:

function pick(o, ...props) { 
    var has = p => o.propertyIsEnumerable(p), 
     get = p => Object.getOwnPropertyDescriptor(o, p); 

    return Object.defineProperties({}, 
     Object.assign({}, ...props 
      .filter(prop => has(prop)) 
      .map(prop => ({prop: get(props)}))) 
    ); 
} 

Answer 2

non credo che ci sia alcun modo per rendere molto più compatta rispetto la risposta (o torazburo di), ma essenzialmente quello che stai cercando di fare è emulare Underscore's pick operation. Sarebbe abbastanza facile re-implementare che in ES6:

function pick(o, ...fields) { 
    return fields.reduce((a, x) => { 
     if(o.hasOwnProperty(x)) a[x] = o[x]; 
     return a; 
    }, {}); 
} 

allora si ha un portata di mano riutilizzabile funzione:

var stuff = { name: 'Thing', color: 'blue', age: 17 }; 
var picked = pick(stuff, 'name', 'age'); 

Answer 3

devo simile alla soluzione di Ethan Brown, ma ancora più brevi - pick funzione. Un'altra funzione pick2 è un po 'più lunga (e più lenta), ma consente di rinominare le proprietà in modo simile a ES6.

const pick = (o, ...props) => props.reduce((r, p) => p in o ? {...r, [p]: o[p]} : r, {}) 

const pick2 = (o, ...props) => props.reduce((r, expr) => { 
    const [p, np] = expr.split(":").map(e => e.trim()) 
    return p in o ? {...r, [np || p]: o[p]} : r 
}, {}) 

Ecco l'esempio di utilizzo:

const d = { a: "1", c: "2" } 

console.log(pick(d, "a", "b", "c"))  // -> { a: "1", c: "2" } 
console.log(pick2(d, "a: x", "b: y", "c")) // -> { x: "1", c: "2" } 

Answer 4

Il trucco per risolvere questo come una battuta è quello di capovolgere l'approccio: Invece di partire dall'oggetto originale orig, si può iniziare dalla le chiavi che vogliono estrarre.

Utilizzando Array#reduce, è possibile quindi memorizzare ciascuna chiave necessaria sull'oggetto vuoto che viene passato come initialValue per la suddetta funzione.

Come così:

const orig = { 
 
    id: 123456789, 
 
    name: 'test', 
 
    description: '…', 
 
    url: 'https://…', 
 
}; 
 

 
const filtered = ['id', 'name'].reduce((result, key) => { result[key] = orig[key]; return result; }, {}); 
 

 
console.log(filtered); // Object {id: 123456789, name: "test"}

Answer 5

TC39's object rest/spread properties proposal renderà questo abbastanza liscia:

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 }; 
z; // { a: 3, b: 4 } 

(Esso ha il lato negativo di creare le x e y variabili che si possono non è necessario.)

Answer 6

Ho richiesto questa soluzione ma non sapevo se le chiavi proposte fossero disponibili. Così, ho preso risposta @torazaburo e migliorato per il mio caso d'uso:

function pick(o, ...props) { 
    return Object.assign({}, ...props.map(prop => { 
    if (o[prop]) return {[prop]: o[prop]}; 
    })); 
} 

// Example: 
var person = { name: 'John', age: 29 }; 
var myObj = pick(person, 'name', 'sex'); // { name: 'John' } 

Answer 7

Una soluzione po 'più breve minuscola utilizzando l'operatore virgola:

const pick = (O, ...K) => K.reduce((o, k) => (o[k]=O[k], o), {})