В Javascript, как условно добавить член к объекту?

Я хотел бы создать объект с условно добавленным членом. Простой подход:

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

Теперь я хотел бы написать более идиоматический код. Я стараюсь:

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

Но теперь bявляется членом, aчья ценность undefined. Это не желаемый результат.

Есть ли удобное решение?

Обновить

Я ищу решение, которое могло бы обработать общий случай с несколькими участниками.

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

В чистом Javascript я не могу придумать ничего более идиоматического, чем ваш первый фрагмент кода.

Однако если об использовании библиотеки jQuery не может быть и речи, то $ .extend () должен соответствовать вашим требованиям, потому что, как сказано в документации:

Неопределенные свойства не копируются.

Поэтому вы можете написать:

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

И получить ожидаемые результаты (если conditionBесть false, то bне будет существовать в a).

Я думаю, что @InspiredJW сделал это с ES5, и, как указал @trincot, лучше использовать es6. Но мы можем добавить немного больше сахара, используя оператор распространения и оценку логического И короткого замыкания:

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

С EcmaScript2015 вы можете использовать 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);

Некоторые замечания:

• Object.assign изменяет первый аргумент на месте, но также возвращает обновленный объект: так что вы можете использовать этот метод в большем выражении, которое дополнительно управляет объектом.
• Вместо того, чтобы nullвы могли пройти undefinedили {}, с тем же результатом. Вы могли бы даже предоставить 0вместо этого, потому что примитивные значения упакованы и Numberне имеют собственных перечислимых свойств .

Еще более лаконично

Принимая вторую точку дальше, вы могли бы сократить его следующим образом (как @Jamie указывал), а falsy значения не имеют собственных перечислимых свойств ( false, 0, NaN, null, undefined, '', за исключением 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
}

Демонстрация в реальном времени:

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

console.log(obj);

Использование расширенного синтаксиса с логическим значением (как предлагается здесь) не является допустимым синтаксисом. Распространение можно использовать только с итерациями .

Я предлагаю следующее:

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

Как насчет использования расширенных свойств объекта и устанавливать свойство только в том случае, если оно истинно, например:

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

Таким образом, если условие не выполняется, оно не создает предпочтительное свойство, и, таким образом, вы можете отменить его. Смотрите: http://es6-features.org/#ComputedPropertyNames

ОБНОВЛЕНИЕ: еще лучше следовать подходу Акселя Раушмайера в его статье в блоге об условном добавлении записей внутри литералов и массивов объектов ( http://2ality.com/2017/04/conditional-literal-entries.html ):

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

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

Мне очень помогло.

более упрощенный,

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

Если цель состоит в том, чтобы объект казался автономным и находился в пределах одного набора скобок, вы можете попробовать это:

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

    if (conditionC)
        this.c = 5;

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

Если вы хотите сделать это на стороне сервера (без jquery), вы можете использовать lodash 4.3.0:

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

И это работает с использованием 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.
}

Я надеюсь, что это очень эффективный способ добавить запись, основанную на условии. Для получения дополнительной информации о том, как условно добавлять записи внутри литералов объекта.

Вы можете добавить все свои неопределенные значения без каких-либо условий, а затем использовать JSON.stringifyдля их удаления все:

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

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

// Contents of cleaned:

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

На это уже давно дан ответ, но, глядя на другие идеи, я придумал несколько интересных производных:

Присвойте неопределенные значения тому же свойству и удалите его впоследствии

Создайте свой объект, используя анонимный конструктор, и всегда назначайте неопределенные члены тому же фиктивному члену, который вы удаляете в самом конце. Это даст вам одну строку (надеюсь, не слишком сложную) для каждого участника + 1 дополнительную строку в конце.

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

Я бы сделал это

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

Редактируется с помощью однострочного кода

Используя библиотеку lodash, вы можете использовать _.omitBy

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

Это удобно, если у вас есть необязательные запросы

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

Определите переменную по letи просто назначьте новое свойство

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",
      },
    ];
}

Теперь msgстало

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

На мой взгляд, это очень простое и легкое решение.

Я думаю, что ваш первый подход к условному добавлению участников совершенно нормален. Я не совсем согласен с тем, что не хочу иметь членаb из aсо значением undefined. Достаточно просто добавить undefinedпроверку с использованием forцикла с inоператором. Но в любом случае вы можете легко написать функцию для фильтрации undefinedчленов.

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

Вы также можете использовать deleteоператор для редактирования объекта на месте.

Завернуть в объект

Что-то вроде этого немного чище

 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)

Завернуть в массив

Или, если вы хотите использовать метод Jamie Hill и иметь очень длинный список условий, вы должны написать ...синтаксис несколько раз. Чтобы сделать его немного чище, вы можете просто обернуть их в массив, а затем использовать reduce()для возврата их как одного объекта.

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

Или используя map()функцию

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

Это самое краткое решение, которое я могу предложить:

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

Используя библиотеку lodash, вы можете использовать _.merge

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

1. Если условие B равно false& conditionC true, тоa = { c: 5 }
2. Если оба условия B и условие C true, тоa = { b: 4, c: 5 }
3. Если оба условия В и условие С выполнены false, тоa = {}