Як у 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));

І це працює за допомогою лодашу 3.10.1

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

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

Я сподіваюся, що це набагато ефективніший спосіб додати запис на основі умови. Для отримання додаткової інформації про те, як умовно додати записи всередині об'єкта літерали.

На це вже давно відповіли, але переглядаючи інші ідеї, я придумав цікаву похідну:

Призначте невизначені значення одній властивості та видаліть їх згодом

Створіть свій об’єкт за допомогою анонімного конструктора і завжди призначте невизначені члени тому самому манекеновому члену, який ви видалите в самому кінці. Це дасть вам один рядок (не надто складний, сподіваюся) на кожного члена + 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;
};

Ви можете додати всі невизначені значення без умови, а потім використати їх, 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
// }

Я б це зробив

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)

Я думаю, що ваш перший підхід до додавання членів умовно - це прекрасно. Я не згоден з не бажаючи мати член 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)

Загорніть у масив

Або якщо ви хочете скористатися методом Джеймі Хілла і маєте дуже довгий перелік умов, тоді ви повинні написати ...синтаксис кілька разів. Щоб зробити його трохи чистішим, ви можете просто загорнути їх у масив, а потім використовувати 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& умоваC є true, тоa = { c: 5 }
2. Якщо обидва умовиB і умоваC true, значить,a = { b: 4, c: 5 }
3. Якщо обидва умовиB і умоваC false, значить,a = {}