En Javascript, ¿cómo agregar condicionalmente un miembro a un objeto?

Me gustaría crear un objeto con un miembro agregado condicionalmente. El enfoque simple es:

var a = {};
if (someCondition)
    a.b = 5;

Ahora, me gustaría escribir un código más idiomático. Estoy intentando:

a = {
    b: (someCondition? 5 : undefined)
};

Pero ahora, bes un miembro de acuyo valor es undefined. Este no es el resultado deseado.

¿Hay alguna solución útil?

Actualizar

Busco una solución que pueda manejar el caso general con varios miembros.

a = {
  b: (conditionB? 5 : undefined),
  c: (conditionC? 5 : undefined),
  d: (conditionD? 5 : undefined),
  e: (conditionE? 5 : undefined),
  f: (conditionF? 5 : undefined),
  g: (conditionG? 5 : undefined),
 };

En Javascript puro, no puedo pensar en nada más idiomático que su primer fragmento de código.

Sin embargo, si el uso de la biblioteca jQuery no está descartado, entonces $ .extend () debería cumplir con sus requisitos porque, como dice la documentación:

Las propiedades no definidas no se copian.

Por lo tanto, puedes escribir:

var a = $.extend({}, {
    b: conditionB ? 5 : undefined,
    c: conditionC ? 5 : undefined,
    // and so on...
});

Y obtenga los resultados que espera (si conditionBes así false, entonces bno existirá a).

Creo que @InspiredJW lo hizo con ES5, y como señaló @trincot, usar es6 es un mejor enfoque. Pero podemos agregar un poco más de azúcar, utilizando el operador de propagación y la evaluación lógica Y de cortocircuito:

const a = {
   ...(someCondition && {b: 5})
}

Con EcmaScript2015 puede usar Object.assign:

Object.assign(a, conditionB ? { b: 1 } : null,
                 conditionC ? { c: 2 } : null,
                 conditionD ? { d: 3 } : null);

var a, conditionB, conditionC, conditionD;
conditionC = true;
a = {};
Object.assign(a, conditionB ? { b: 1 } : null,
                 conditionC ? { c: 2 } : null,
                 conditionD ? { d: 3 } : null);

console.log(a);

Algunas observaciones:

• Object.assign modifica el primer argumento en el lugar, pero también devuelve el objeto actualizado: para que pueda usar este método en una expresión más grande que manipule aún más el objeto.
• En lugar de nullusted podría pasar undefinedo {}, con el mismo resultado. Incluso podría proporcionar en su 0lugar, porque los valores primitivos están envueltos, yNumber no tienen propiedades propias enumerables .

Aún más conciso

Teniendo además el segundo punto, se podría acortar la siguiente manera (como @Jamie tiene cabo puntas), como valores Falsy no tienen propiedades enumerables propias ( false, 0, NaN, null, undefined, '', excepto document.all):

Object.assign(a, conditionB && { b: 1 },
                 conditionC && { c: 2 },
                 conditionD && { d: 3 });

var a, conditionB, conditionC, conditionD;
conditionC = "this is truthy";
conditionD = NaN; // falsy
a = {};
Object.assign(a, conditionB && { b: 1 },
                 conditionC && { c: 2 },
                 conditionD && { d: 3 });
console.log(a);

const obj = {
   ...(condition) && {someprop: propvalue},
   ...otherprops
}

Demo en vivo:

const obj = {
  ...(true) && {someprop: 42},
  ...(false) && {nonprop: "foo"},
  ...({}) && {tricky: "hello"},
}

console.log(obj);

El uso de sintaxis extendida con booleano (como se sugiere aquí) no es una sintaxis válida. Spread solo se puede usar con iterables .

Sugiero lo siguiente:

const a = {
   ...(someCondition? {b: 5}: {} )
}

¿Qué pasa con el uso de propiedades de objetos mejorados y solo establece la propiedad si es verdadera, por ejemplo:

[isConditionTrue() && 'propertyName']: 'propertyValue'

Entonces, si no se cumple la condición, no crea la propiedad preferida y, por lo tanto, puede descartarla. Ver: http://es6-features.org/#ComputedPropertyNames

ACTUALIZACIÓN: es aún mejor seguir el enfoque de Axel Rauschmayer en su artículo de blog sobre agregar condicionalmente entradas dentro de literales y matrices de objetos ( http://2ality.com/2017/04/conditional-literal-entries.html ):

const arr = [
  ...(isConditionTrue() ? [{
    key: 'value'
  }] : [])
];

const obj = {
  ...(isConditionTrue() ? {key: 'value'} : {})
};

Me ayudó mucho.

más simplificado

const a = {
    ...(condition && {b: 1}) // if condition is true 'b' will be added.
}

Si el objetivo es que el objeto parezca autónomo y esté dentro de un conjunto de llaves, puede intentar esto:

var a = new function () {
    if (conditionB)
        this.b = 5;

    if (conditionC)
        this.c = 5;

    if (conditionD)
        this.d = 5;
};

Si desea hacer este lado del servidor (sin jquery), puede usar lodash 4.3.0:

a = _.pickBy({ b: (someCondition? 5 : undefined) }, _.negate(_.isUndefined));

Y esto funciona usando lodash 3.10.1

a = _.pick({ b: (someCondition? 5 : undefined) }, _.negate(_.isUndefined));

var a = {
    ...(condition ? {b: 1} : '') // if condition is true 'b' will be added.
}

Espero que esta sea la forma más eficiente de agregar una entrada en función de la condición. Para obtener más información sobre cómo agregar entradas condicionalmente dentro de un objeto literal.

Esto ha sido respondido durante mucho tiempo, pero mirando otras ideas se me ocurrió una derivada interesante:

Asigne valores indefinidos a la misma propiedad y elimínelos después

Cree su objeto utilizando un constructor anónimo y siempre asigne miembros indefinidos al mismo miembro ficticio que elimine al final. Esto le dará una sola línea (no demasiado compleja, espero) por miembro + 1 línea adicional al final.

var a = new function() {
    this.AlwaysPresent = 1;
    this[conditionA ? "a" : "undef"] = valueA;
    this[conditionB ? "b" : "undef"] = valueB;
    this[conditionC ? "c" : "undef"] = valueC;
    this[conditionD ? "d" : "undef"] = valueD;
    ...
    delete this.undef;
};

Puede agregar todos sus valores indefinidos sin condiciones y luego usar JSON.stringifypara eliminarlos todos:

const person = {
  name: undefined,
  age: 22,
  height: null
}

const cleaned = JSON.parse(JSON.stringify(person));

// Contents of cleaned:

// cleaned = {
//   age: 22,
//   height: null
// }

Yo haría esto

var a = someCondition ? { b: 5 } : {};

Editado con una versión de código de línea

Usando la biblioteca lodash, puedes usar _.omitBy

var a = _.omitBy({
    b: conditionB ? 4 : undefined,
    c: conditionC ? 5 : undefined,
}, _.IsUndefined)

Esto resulta útil cuando tiene solicitudes que son opcionales

var a = _.omitBy({
    b: req.body.optionalA,  //if undefined, will be removed
    c: req.body.optionalB,
}, _.IsUndefined)

Creo que su primer enfoque para agregar miembros condicionalmente está perfectamente bien. Realmente no estoy de acuerdo con no querer tener un miembro bde aun valor de undefined. Es bastante simple agregar un undefinedcheque con el uso de un forbucle con el inoperador. Pero de todos modos, podría escribir fácilmente una función para filtrar undefinedmiembros.

var filterUndefined = function(obj) {
  var ret = {};
  for (var key in obj) {
    var value = obj[key];
    if (obj.hasOwnProperty(key) && value !== undefined) {
      ret[key] = value;
    }
  }
  return ret;
};

var a = filterUndefined({
  b: (conditionB? 5 : undefined),
  c: (conditionC? 5 : undefined),
  d: (conditionD? 5 : undefined),
  e: (conditionE? 5 : undefined),
  f: (conditionF? 5 : undefined),
  g: (conditionG? 5 : undefined),
});

También puede usar el deleteoperador para editar el objeto en su lugar.

Envolver en un objeto

Algo como esto es un poco más limpio

 const obj = {
   X: 'dataX',
   Y: 'dataY',
   //...
 }

 const list = {
   A: true && 'dataA',
   B: false && 'dataB',
   C: 'A' != 'B' && 'dataC',
   D: 2000 < 100 && 'dataD',
   // E: conditionE && 'dataE',
   // F: conditionF && 'dataF',
   //...
 }

 Object.keys(list).map(prop => list[prop] ? obj[prop] = list[prop] : null)

Envolver en una matriz

O si desea utilizar el método de Jamie Hill y tener una lista muy larga de condiciones, debe escribir la ...sintaxis varias veces. Para hacerlo un poco más limpio, puede envolverlos en una matriz y luego usarlos reduce()para devolverlos como un solo objeto.

const obj = {
  X: 'dataX',
  Y: 'dataY',
  //...

...[
  true && { A: 'dataA'},
  false && { B: 'dataB'},
  'A' != 'B' && { C: 'dataC'},
  2000 < 100 && { D: 'dataD'},
  // conditionE && { E: 'dataE'},
  // conditionF && { F: 'dataF'},
  //...

 ].reduce(( v1, v2 ) => ({ ...v1, ...v2 }))
}

O usando la map()función

const obj = {
  X: 'dataX',
  Y: 'dataY',
  //...
}

const array = [
  true && { A: 'dataA'},
  false &&  { B: 'dataB'},
  'A' != 'B' && { C: 'dataC'},
  2000 < 100 && { D: 'dataD'},
  // conditionE && { E: 'dataE'},
  // conditionF && { F: 'dataF'},
  //...

 ].map(val => Object.assign(obj, val))

Esta es la solución más sucinta que se me ocurre:

var a = {};
conditionB && a.b = 5;
conditionC && a.c = 5;
conditionD && a.d = 5;
// ...

Defina una var por lety simplemente asigne una nueva propiedad

let msg = {
    to: "hito@email.com",
    from: "hifrom@email.com",
    subject: "Contact form",    
};

if (file_uploaded_in_form) { // the condition goes here
    msg.attachments = [ // here 'attachments' is the new property added to msg Javascript object
      {
        content: "attachment",
        filename: "filename",
        type: "mime_type",
        disposition: "attachment",
      },
    ];
}

Ahora el msgconvertido

{
    to: "hito@email.com",
    from: "hifrom@email.com",
    subject: "Contact form",
    attachments: [
      {
        content: "attachment",
        filename: "filename",
        type: "mime_type",
        disposition: "attachment",
      },
    ]
}

En mi opinión, esta es una solución muy simple y fácil.

Usando la biblioteca lodash, puedes usar _.merge

var a = _.merge({}, {
    b: conditionB ? 4 : undefined,
    c: conditionC ? 5 : undefined,
})

1. Si la condición B es falsey la condición C estrue , entoncesa = { c: 5 }
2. Si tanto la condición B como la condición C son true, entoncesa = { b: 4, c: 5 }
3. Si tanto la condición B como la condición C son false, entoncesa = {}