vacio - si variable existe javascript

One-liner para tomar algunas propiedades del objeto en ES 6

Question

¿Cómo se puede escribir una función, que solo tiene pocos atributos en forma compacta en ES6?

He llegado a una solución usando destructuring + object literal simplificado, pero no me gusta que la lista 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 };
}

Answer 1

Aquí hay algo más delgado, aunque no evita repetir la lista de campos. Utiliza la "desestructuración de parámetros" 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 propiedades calculadas (la parte [p] ):

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

Si queremos preservar los atributos de las propiedades, como los configurable y getters y setters, y al mismo tiempo omitir las propiedades 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)})))
    );
}

Answer 2

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

Usar Array#reduce one puede almacenar cada clave necesaria en el objeto vacío que se transfiere como valor initialValue para dicha función.

Al igual que:

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 3

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.reduce((a, x) => {
        if(o.hasOwnProperty(x)) a[x] = o[x];
        return a;
    }, {});
}

Entonces tiene una práctica función reutilizable:

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

Answer 4

Requirí esta solución, pero no sabía si las claves 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'' }

Answer 5

Tengo una solución similar a la de Ethan Brown, pero aún más corta: función de pick . Otra función pick2 es un poco más larga (y más lenta), pero permite cambiar el nombre de las propiedades de manera similar 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
}, {}) 

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

Answer 6

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

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

Answer 7

La propuesta de propiedades de reposo / dispersión de objetos 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).