Чи є в JavaScript оператор “null coalescing”?

Чи є в Javascript нульовий оператор згортання?

Наприклад, у C # я можу це зробити:

String someString = null;
var whatIWant = someString ?? "Cookies!";

Найкраще наближення, яке я можу зрозуміти для Javascript, - це використання умовного оператора:

var someString = null;
var whatIWant = someString ? someString : 'Cookies!';

Що таке своєрідне ІМХО. Чи можу я зробити краще?

Оновлення

Тепер JavaScript підтримує нульовий оператор злиття (??) . Він повертає його правого операнда, коли його лівий операнд - nullабо undefined, інакше повертає його лівий операнд.

Перевірте сумісність перед її використанням.

Еквівалент JavaScript оператора ??з’єднання C # null ( ) використовує логічний АБО ( ||):

var whatIWant = someString || "Cookies!";

Є випадки (пояснено нижче), що поведінка не відповідає поведінці C #, але це загальний, нетривалий спосіб призначення значень за замовчуванням / альтернативою в JavaScript.

Уточнення

Незалежно від типу першого операнда, якщо приведення його до булевих результатів при falseпризначенні використовуватиме другий операнд. Остерігайтеся всіх випадків нижче:

alert(Boolean(null)); // false
alert(Boolean(undefined)); // false
alert(Boolean(0)); // false
alert(Boolean("")); // false
alert(Boolean("false")); // true -- gotcha! :)

Це означає:

var whatIWant = null || new ShinyObject(); // is a new shiny object
var whatIWant = undefined || "well defined"; // is "well defined"
var whatIWant = 0 || 42; // is 42
var whatIWant = "" || "a million bucks"; // is "a million bucks"
var whatIWant = "false" || "no way"; // is "false"

function coalesce() {
    var len = arguments.length;
    for (var i=0; i<len; i++) {
        if (arguments[i] !== null && arguments[i] !== undefined) {
            return arguments[i];
        }
    }
    return null;
}

var xyz = {};
xyz.val = coalesce(null, undefined, xyz.val, 5);

// xyz.val now contains 5

це рішення працює як функція змикання SQL, воно приймає будь-яку кількість аргументів і повертає нуль, якщо жоден з них не має значення. Він поводиться як C # ?? оператора в тому сенсі, що "", false і 0 вважаються НЕ НУЛЬНИМ і тому вважаються фактичними значеннями. Якщо ви походите з .net фону, це буде найбільш природним рішенням почуттів.

Так, це скоро. Дивіться пропозицію тут та статус реалізації тут .

Це виглядає приблизно так:

x ?? y

Приклад

const response = {
  settings: {
    nullValue: null,
    height: 400,
    animationDuration: 0,
    headerText: '',
    showSplashScreen: false
  }
};

const undefinedValue = response.settings?.undefinedValue ?? 'some other default'; // result: 'some other default'
const nullValue = response.settings?.nullValue ?? 'some other default'; // result: 'some other default'
const headerText = response.settings?.headerText ?? 'Hello, world!'; // result: ''
const animationDuration = response.settings?.animationDuration ?? 300; // result: 0
const showSplashScreen = response.settings?.showSplashScreen ?? true; // result: false

Якщо ||замість C # ??у вашому випадку недостатньо хороша, оскільки вона проковтує порожні рядки та нулі, ви завжди можете написати власну функцію:

 function $N(value, ifnull) {
    if (value === null || value === undefined)
      return ifnull;
    return value;
 }

 var whatIWant = $N(someString, 'Cookies!');

Тут ніхто не згадав про потенціал NaN, який, для мене, також є нульовим значенням. Отже, я думав, що додам свої два центи.

Для даного коду:

var a,
    b = null,
    c = parseInt('Not a number'),
    d = 0,
    e = '',
    f = 1
;

Якщо ви хочете скористатися ||оператором, ви отримаєте перше неправдиве значення:

var result = a || b || c || d || e || f; // result === 1

Якщо ви використовуєте типовий метод злиття, який розміщено тут , ви отримаєте c, який має значення:NaN

var result = coalesce(a,b,c,d,e,f); // result.toString() === 'NaN'

Жодне з них мені не здається правильним. У моєму власному маленькому світі зв'язаної логіки, який може відрізнятися від вашого світу, я вважаю невизначеним, нульовим і NaN як усі "недійсними". Отже, я б розраховував повернутися d(нуль) методом коалесценції.

Якщо мозок когось працює як мій, і ви хочете виключити NaN, то цей метод досягне цього:

function coalesce() {
    var i, undefined, arg;

    for( i=0; i < arguments.length; i++ ) {
        arg = arguments[i];
        if( arg !== null && arg !== undefined
            && (typeof arg !== 'number' || arg.toString() !== 'NaN') ) {
            return arg;
        }
    }
    return null;
}

Для тих, хто хоче, щоб код був максимально коротким і не мав уваги з невеликою недостатністю ясності, ви також можете використовувати це, як запропонував @impinball. Це використовує той факт, що NaN ніколи не дорівнює NaN. Більше про це можна прочитати тут: Чому NaN не дорівнює NaN?

function coalesce() {
    var i, arg;

    for( i=0; i < arguments.length; i++ ) {
        arg = arguments[i];
        if( arg != null && arg === arg ) { //arg === arg is false for NaN
            return arg;
        }
    }
    return null;
}

остерігайтеся конкретного JavaScript-визначення. є два визначення для "без значення" в JavaScript. 1. Null: коли змінна null, це означає, що вона не містить в ній даних, але змінна вже визначена в коді. подобається це:

var myEmptyValue = 1;
myEmptyValue = null;
if ( myEmptyValue === null ) { window.alert('it is null'); }
// alerts

у такому випадку тип вашої змінної насправді є Object. перевірити його.

window.alert(typeof myEmptyValue); // prints Object

2. Не визначено: коли змінна раніше не була визначена в коді, і як очікувалося, вона не містить жодного значення. подобається це:

   if ( myUndefinedValue === undefined ) { window.alert('it is undefined'); }
   // alerts

якщо такий випадок, тип вашої змінної є "невизначеним".

зауважте, що якщо ви використовуєте оператор порівняння, що конвертує тип (==), JavaScript буде діяти однаково для обох цих порожніх значень. щоб розрізняти їх, завжди використовуйте оператор порівняння суворих типів (===).

Прочитавши ваше пояснення, у відповіді @Ates Goral вказано, як виконати ту саму операцію, яку ви робите в C # в JavaScript.

@ Відповідь Gumbo забезпечує найкращий спосіб перевірити наявність нуля; однак важливо відзначити різницю ==порівняно ===з JavaScript, особливо коли мова йде про питання перевірки undefinedта / або null.

Там дійсно хороша стаття про різницю в двох доданків тут . В основному, розумійте, що якщо ви використовуєте ==замість ===, JavaScript намагатиметься зв'язати значення, які ви порівнюєте, і повернути результат результату порівняння після цього зближення.

Зауважте, що create-react-appланцюжок інструментів React підтримує поєднання нуля з версії 3.3.0 (випущена 5.12.2019) . З приміток до випуску:

Необов'язкові оператори ланцюгового та нульового з'єднання

Зараз ми підтримуємо необов'язкові оператори ланцюгової та нульової з’єднання!

// Optional chaining
a?.(); // undefined if `a` is null/undefined
b?.c; // undefined if `b` is null/undefined

// Nullish coalescing
undefined ?? 'some other default'; // result: 'some other default'
null ?? 'some other default'; // result: 'some other default'
'' ?? 'some other default'; // result: ''
0 ?? 300; // result: 0
false ?? true; // result: false

Це сказано, якщо ви використовуєте create-react-appверсію 3.3.0+, ви можете почати використовувати оператор null-coalesce вже сьогодні у своїх програмах React.

Так, і його пропозиція зараз є етапом 4 . Це означає, що пропозиція готова до включення до формального стандарту ECMAScript. Ви вже можете використовувати його в останніх настільних версіях Chrome, Edge та Firefox, але нам доведеться почекати трохи довше, поки ця функція не досягне стабільності перехресного веб-переглядача.

Подивіться на наступний приклад, щоб продемонструвати його поведінку:

// note: this will work only if you're running latest versions of aforementioned browsers
const var1 = undefined;
const var2 = "fallback value";

const result = var1 ?? var2;
console.log(`Nullish coalescing results in: ${result}`);

Попередній приклад еквівалентний:

const var1 = undefined;
const var2 = "fallback value";

const result = (var1 !== null && var1 !== undefined) ?
    var1 :
    var2;
console.log(`Nullish coalescing results in: ${result}`);

Зверніть увагу , що nullish коалесцирует буде НЕ загроза falsy значення то , як ||оператор зробив (він тільки перевіряє undefinedчи nullзначення), отже , наступний фрагмент коду буде діяти наступним чином :

// note: this will work only if you're running latest versions of aforementioned browsers
const var1 = ""; // empty string
const var2 = "fallback value";

const result = var1 ?? var2;
console.log(`Nullish coalescing results in: ${result}`);

Для користувачів TypesScript, починаючи з TypeScript 3.7 , ця функція також доступна зараз.

Будемо сподіватися, що незабаром він стане доступним у Javascript, оскільки він знаходиться у фазі пропозицій станом на квітень 2020 року. Ви можете відстежувати стан тут щодо сумісності та підтримки - https://developer.mozilla.org/en-US/docs/Web/ JavaScript / Довідка / Оператори / Nullish_coalescing_operator

Для людей , що використовують машинопис, ви можете використовувати nullish оператор коалесцирует з машинопису 3.7

З документів -

Ви можете подумати про цю функцію - ??оператор - як про спосіб «відкинутись» до значення за замовчуванням при роботі з nullабо undefined. Коли ми пишемо код, як

let x = foo ?? bar();

це новий спосіб сказати, що значення fooбуде використовуватися, коли воно є "присутнє"; але коли це nullчи undefined, обчисліть bar()на його місці.

Добре відповідь

Чи існує він у JavaScript? Так. АЛЕ Наразі це стадіон 2020-02-06 на етапі 3 та ще не підтримується скрізь.Перейдіть за посиланням у URL-адресі нижче та перейдіть до заголовків "Технічні характеристики" та "Сумісність веб-переглядачів", щоб отримати докладнішу інформацію про те, де він знаходиться.

Цитата від: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator

Нульовий оператор злиття (??) - це логічний оператор, який повертає правий бік операнда, коли його лівий операнд є нульовим або невизначеним, а в іншому випадку повертає його лівий операнд.

На відміну від логічного оператора АБО (||), лівий операнд повертається, якщо це хибне значення, яке не є нульовим або невизначеним. Іншими словами, якщо ви використовуєте || щоб надати деяке значення за замовчуванням для іншої змінної foo, ви можете зіткнутися з несподіваною поведінкою, якщо вважаєте деякі хибні значення як придатні (наприклад, '' або 0). Нижче див. Додаткові приклади.

Хочете приклади? Перейдіть за посиланням, яке я опублікував, у ньому є все.

Тепер він має повну підтримку в останній версії основних браузерів, таких як Chrome, Edge, Firefox, Safari тощо. Ось порівняння між оператором null та Nullish Coalescing Operator

const response = {
        settings: {
            nullValue: null,
            height: 400,
            animationDuration: 0,
            headerText: '',
            showSplashScreen: false
        }
    };
    /* OR Operator */
    const undefinedValue = response.settings.undefinedValue || 'Default Value'; // 'Default Value'
    const nullValue = response.settings.nullValue || 'Default Value'; // 'Default Value'
    const headerText = response.settings.headerText || 'Hello, world!'; //  'Hello, world!'
    const animationDuration = response.settings.animationDuration || 300; //  300
    const showSplashScreen = response.settings.showSplashScreen || true; //  true
    /* Nullish Coalescing Operator */
    const undefinedValue = response.settings.undefinedValue ?? 'Default Value'; // 'Default Value'
    const nullValue = response.settings.nullValue ?? ''Default Value'; // 'Default Value'
    const headerText = response.settings.headerText ?? 'Hello, world!'; // ''
    const animationDuration = response.settings.animationDuration ?? 300; // 0
    const showSplashScreen = response.settings.showSplashScreen ?? true; //  false