One-liner para tomar algunas properties del object en ES 6

¿Cómo se puede escribir una function, que solo tiene pocos attributes en forma compacta en ES6?

He llegado a una solución usando destructuring + object literal simplificado, pero no me gusta que la list de campos se repita en el código.

¿Hay una solución aún más delgada?

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

Aquí hay algo más delgado, aunque no evita repetir la list de campos. Utiliza la "desestructuración de parameters" para evitar la necesidad del parámetro v .

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

La solución de @ EthanBrown es más general. Aquí hay una versión más idiomática que usa Object.assign y properties calculadas (la parte [p] ):

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

Si queremos preservar los attributes de las properties, como los configurable y getters y setters, y al mismo time omitir las properties no enumerables, entonces:

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

No creo que haya ninguna forma de hacerlo mucho más compacto que tu respuesta (o torazburo), pero esencialmente lo que estás tratando de hacer es emular la operación de pick de Underscore . Sería bastante fácil reintroducir eso en ES6:

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

Entonces tiene una práctica function reutilizable:

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

El truco para resolver esto como una línea es cambiar el enfoque adoptado: en lugar de comenzar desde el origen del object original, uno puede comenzar desde las teclas que quieren extraer.

Usar Array#networkinguce one puede almacenar cada key necesaria en el object vacío que se transfiere como valor initialValue para dicha function.

Al igual que:

 const orig = { id: 123456789, name: 'test', description: '…', url: 'https://…', }; const filtenetworking = ['id', 'name'].networkinguce((result, key) => { result[key] = orig[key]; return result; }, {}); console.log(filtenetworking); // Object {id: 123456789, name: "test"} 

La propuesta de properties de reposo / dispersión de objects de TC39 hará que esta bonita mancha:

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

(Tiene la desventaja de crear las variables y que quizás no necesite).

Tengo una solución similar a la de Ethan Brown, pero aún más corta: function de pick . Otra function pick2 es un poco más larga (y más lenta), pero permite cambiar el nombre de las properties de manera similar a ES6.

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

Aquí está el ejemplo de uso:

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

Requirí esta solución, pero no sabía si las keys propuestas estaban disponibles. Entonces, tomé respuesta @torazaburo y mejoré para mi caso de 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' } 

Una solución un poco más corta usando el operador de coma:

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