Une seule ligne pour prendre certaines propriétés de l'objet dans ES 6

Comment écrire une fonction qui ne prend que peu d'attributs de la manière la plus compacte dans ES6?

J'ai trouvé une solution utilisant la déstructuration + un littéral d'objet simplifié, mais je n'aime pas que la liste de champs soit répétée dans le code.

Existe-t-il une solution encore plus mince?

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

Voici quelque chose de plus mince, même si cela n'évite pas de répéter la liste des champs. Il utilise la «déstructuration des paramètres» pour éviter le besoin du vparamètre.

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

(Voir un exemple exécutable dans cette autre réponse ).

La solution de @ EthanBrown est plus générale. En voici une version plus idiomatique qui utilise Object.assignet calcule des propriétés (la [p]partie):

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

Si nous voulons conserver les attributs des propriétés, tels que configurableet les getters et les setters, tout en omettant également les propriétés non énumérables, alors:

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)})))
    );
}

Je ne pense pas qu'il y ait un moyen de le rendre beaucoup plus compact que votre réponse (ou celle de torazburo), mais essentiellement ce que vous essayez de faire est d'imiter le pickfonctionnement de Underscore . Il serait assez facile de réimplémenter cela dans ES6:

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

Ensuite, vous avez une fonction réutilisable pratique:

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

L'astuce pour résoudre ce problème en une seule ligne est d'inverser l'approche adoptée: au lieu de partir de l'objet d'origine orig, on peut partir des clés qu'ils veulent extraire.

En utilisant Array#reduceon peut alors stocker chaque clé nécessaire sur l'objet vide qui est passé en tant que initialValuepour ladite fonction.

Ainsi:

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"}

Une solution un peu plus courte utilisant l'opérateur virgule:

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

console.log(
  pick({ name: 'John', age: 29, height: 198 }, 'name', 'age')
)  

La proposition de propriétés de repos / propagation d'objet de TC39 rendra cette jolie astuce:

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

(Cela présente l'inconvénient de créer les variables xet ydont vous n'avez peut-être pas besoin.)

Vous pouvez utiliser la déstructuration d'objets pour décompresser les propriétés de l'objet existant et les affecter à des variables avec des noms différents - des champs d'un nouvel objet initialement vide.

const person = {
  fname: 'tom',
  lname: 'jerry',
  aage: 100,
}

let newPerson = {};

({fname: newPerson.fname, lname: newPerson.lname} = person);

console.log(newPerson);

ES6 était la dernière spécification au moment où la question a été écrite. Comme expliqué dans cette réponse , la sélection des clés est nettement plus courte dans ES2019 que dans ES6:

Object.fromEntries(
  Object.entries(obj)
  .filter(([key]) => ['foo', 'bar'].includes(key))
)

Il existe actuellement une proposition de paille pour améliorer la syntaxe abrégée des objets JavaScript, qui permettrait de "sélectionner" les propriétés nommées sans répétition:

const source = {id: "68646", genre: "crime", title: "Scarface"};
const target = {};
Object.assign(target, {source.title, source.id});

console.log(picked);
// {id: "68646", title: "Scarface"}

Malheureusement, la proposition ne semble pas aller nulle part de si tôt. Dernière modification en juillet 2017 et toujours un brouillon à l' étape 0 , suggérant que l'auteur l'a peut-être abandonné ou oublié.

ES5 et versions antérieures (mode non strict)

Le raccourci le plus concis possible auquel je puisse penser implique une fonctionnalité de langue ancienne que personne n'utilise plus:

Object.assign(target, {...(o => {
    with(o) return { id, title };
})(source)});

withles instructions sont interdites en mode strict, ce qui rend cette approche inutile pour 99,999% du JavaScript moderne. Un peu dommage, car c'est la seule utilisation à moitié décente que j'ai trouvée pour la withfonctionnalité. 😀

J'ai similaire à la solution d'Ethan Brown, mais encore plus courte - pickfonction. Une autre fonction pick2est un peu plus longue (et plus lente), mais permet de renommer les propriétés de la même manière que 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
}, {}) 

Voici l'exemple d'utilisation:

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" }

J'avais besoin de cette solution mais je ne savais pas si les clés proposées étaient disponibles. Donc, j'ai pris la réponse @torazaburo et je me suis amélioré pour mon cas d'utilisation:

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' }

inspiré de l'approche de réduction de https://stackoverflow.com/users/865693/shesek :

const pick = (orig, ...keys) => keys.reduce((acc, key) => ({...acc, [key]: orig[key]}), {})

usage:

pick({ model : 'F40', manufacturer: 'Ferrari', productionYear: 1987 }, 'model', 'productionYear') résulte en: {model: "F40", productionYear: 1987}