Есть ли в JavaScript оператор «нулевого слияния»?

Есть ли в Javascript пустой оператор слияния?

Например, в C # я могу сделать это:

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

Лучшее приближение, которое я могу выяснить для Javascript, это использование условного оператора:

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

Который является Сорти Ики ИМХО. Могу ли я сделать лучше?

Обновить

JavaScript теперь поддерживает нулевой оператор объединения (??) . Он возвращает свой правый операнд, когда его левый операнд равен nullили undefined, и в противном случае возвращает свой левый операнд.

Пожалуйста, проверьте совместимость перед использованием.

JavaScript-эквивалент оператора объединения нулей в C # ( ??) использует логическое ИЛИ ( ||):

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 считаются NOT NULL и поэтому считаются фактическими значениями. Если вы пришли из .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'

Ничто из этого не кажется мне правильным. В моем собственном маленьком мире логики слияния, который может отличаться от вашего мира, я считаю, что undefined, null и 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}`);

Обратите внимание, что нулевое объединение не будет угрожать ложным значениям так, как это ||делал оператор (он только проверяет наличие 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

Для людей, использующих Typescript, вы можете использовать нулевой оператор объединения из Typescript 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

Нулевой оператор объединения (??) - это логический оператор, который возвращает свой правый операнд, когда его левый операнд равен нулю или не определен, и в противном случае возвращает его левый операнд.

В отличие от логического оператора OR (||), левый операнд возвращается, если это ложное значение, которое не является нулевым или неопределенным. Другими словами, если вы используете || чтобы предоставить какое-либо значение по умолчанию другой переменной foo, вы можете столкнуться с неожиданным поведением, если вы считаете некоторые ложные значения пригодными для использования (например, '' или 0). Смотрите ниже для большего количества примеров.

Хотите примеры? Перейдите по ссылке, которую я разместил, там есть все.

Теперь он имеет полную поддержку в последних версиях основных браузеров, таких как Chrome, Edge, Firefox, Safari и т. Д. Вот сравнение между нулевым оператором и нулевым оператором слияния

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