Em Javascript, como adicionar condicionalmente um membro a um objeto?

Eu gostaria de criar um objeto com um membro adicionado condicionalmente. A abordagem simples é:

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

Agora, eu gostaria de escrever um código mais idiomático. Eu estou tentando:

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

Mas agora, bé um membro acujo valor é undefined. Este não é o resultado desejado.

Existe uma solução útil?

Atualizar

Eu procuro uma solução que possa lidar com o caso geral com vários membros.

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

No Javascript puro, não consigo pensar em nada mais idiomático do que o seu primeiro trecho de código.

Se, no entanto, o uso da biblioteca jQuery não estiver fora de questão, $ .extend () deverá atender aos seus requisitos, pois, como diz a documentação:

Propriedades indefinidas não são copiadas.

Portanto, você pode escrever:

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

E obtenha os resultados esperados (se conditionBhouver false, então bnão existirão a).

Acho que o @InspiredJW fez isso com o ES5 e, como o @trincot apontou, usar o es6 é uma abordagem melhor. Mas podemos adicionar um pouco mais de açúcar usando o operador spread e a avaliação lógica E de curto-circuito:

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

Com o EcmaScript2015, você pode 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);

Algumas observações:

• Object.assign modifica o primeiro argumento no local, mas também retorna o objeto atualizado: para que você possa usar esse método em uma expressão maior que manipule ainda mais o objeto.
• Em vez de nullvocê poderia passar undefinedou {}, com o mesmo resultado. Você pode até fornecer 0, porque os valores primitivos são quebrados e Numbernão possuem propriedades enumeráveis ​​próprias .

Ainda mais conciso

Tomando ainda mais o segundo ponto, você pode reduzi-lo da seguinte forma (como @Jamie tem fora pontas), como valores Falsas não têm próprias propriedades enumeráveis ( false, 0, NaN, null, undefined, '', com exceção 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
}

Demonstração ao vivo:

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

console.log(obj);

O uso de sintaxe de propagação com booleano (como sugerido aqui) não é uma sintaxe válida. A propagação só pode ser usada com iterables .

Sugiro o seguinte:

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

Que tal usar as Propriedades Avançadas do Objeto e definir a propriedade apenas se for verdade, por exemplo:

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

Portanto, se a condição não for atendida, ela não criará a propriedade preferida e, portanto, você poderá descartá-la. Consulte: http://es6-features.org/#ComputedPropertyNames

ATUALIZAÇÃO: É ainda melhor seguir a abordagem de Axel Rauschmayer em seu artigo de blog sobre a adição condicional de entradas em literais e matrizes de objetos ( http://2ality.com/2017/04/conditional-literal-entries.html ):

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

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

Me ajudou bastante.

mais simplificado,

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

Se o objetivo é fazer com que o objeto pareça independente e esteja dentro de um conjunto de chaves, você pode tentar o seguinte:

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

    if (conditionC)
        this.c = 5;

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

Se você deseja fazer esse lado do servidor (sem jquery), pode usar o lodash 4.3.0:

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

E isso funciona usando o 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 seja a maneira mais eficiente de adicionar uma entrada com base na condição. Para obter mais informações sobre como adicionar entradas condicionais dentro de literais de um objeto.

Isso tem sido respondido há muito tempo, mas, olhando para outras idéias, eu vim com uma derivada interessante:

Atribua valores indefinidos à mesma propriedade e exclua-a posteriormente

Criar o objeto usando um construtor anónimo e sempre atribuir membros indefinidos para o mesmo manequim membro que você remove no final. Isso fornecerá uma única linha (não muito complexa, espero) por membro + 1 linha adicional no 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;
};

Você pode adicionar todos os seus valores indefinidos sem condição e, em seguida, usar JSON.stringifypara remover todos eles:

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

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

// Contents of cleaned:

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

Eu faria isso

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

Editado com uma versão de código de linha

Usando a biblioteca lodash, você pode usar _.omitBy

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

Isso é útil quando você tem solicitações opcionais

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

Eu acho que sua primeira abordagem para adicionar membros condicionalmente é perfeitamente correta. Eu realmente não concordo com não querer ter um membro bde acom um valor de undefined. É simples o suficiente para adicionar uma undefinedverificação com o uso de um forloop com o inoperador. De qualquer forma, você pode facilmente escrever uma função para filtrar undefinedmembros.

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

Você também pode usar o deleteoperador para editar o objeto no local.

Quebrar em um objeto

Algo assim é um pouco mais limpo

 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)

Agrupar em uma matriz

Ou, se você quiser usar o método de Jamie Hill e tiver uma lista muito longa de condições, deverá escrever a ...sintaxe várias vezes. Para torná-lo um pouco mais limpo, basta envolvê-los em uma matriz e usá reduce()-los para devolvê-los como um único 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 }))
}

Ou usando a map()função

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 é a solução mais sucinta que posso encontrar:

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

Usando a biblioteca lodash, você pode usar _.merge

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

1. Se conditionB for false& conditionC fortrue , entãoa = { c: 5 }
2. Se a condiçãoB e a condiçãoC forem true , entãoa = { b: 4, c: 5 }
3. Se ambas a condiçãoB e condiçãoC foremfalse , entãoa = {}