Есть ли в JavaScript оператор "нулевого слияния"? - PullRequest
1164 голосов
/ 24 января 2009

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

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

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

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

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

Что-то вроде ИМХО. Могу ли я сделать лучше?

Ответы [ 8 ]

1844 голосов
/ 24 января 2009

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"
64 голосов
/ 08 марта 2014
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 фона, это будет самое естественное решение для чувства.

43 голосов
/ 24 января 2009

Если || в качестве замены C # ?? не достаточно хорош в вашем случае, потому что он глотает пустые строки и нули, вы всегда можете написать свою собственную функцию:

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

 var whatIWant = $N(someString, 'Cookies!');
19 голосов
/ 07 мая 2018

Да, это скоро. См. предложение здесь и статус реализации здесь .

Это выглядит так:

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
12 голосов
/ 27 мая 2015

Никто не упомянул здесь потенциал для 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;
}
7 голосов
/ 17 июля 2017

В настоящее время нет поддержки, но процесс стандартизации JS работает над этим: https://github.com/tc39/proposal-optional-chaining

4 голосов
/ 24 января 2009

Остерегайтесь специфического для JavaScript определения ноля. Есть два определения «нет значения» в JavaScript. 1. Нуль: когда переменная равна нулю, это означает, что в ней нет данных, но переменная уже определена в коде. как это:

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

в таком случае тип вашей переменной - фактически Object. проверить это.

window.alert(typeof myEmptyValue); // prints Object
  1. Не определено: когда переменная не была определена ранее в коде и, как ожидается, она не содержит никакого значения. как это:

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

если такой случай, тип вашей переменной 'undefined'.

обратите внимание, что если вы используете оператор сравнения с преобразованием типов (==), JavaScript будет действовать одинаково для обоих этих пустых значений. чтобы различать их, всегда используйте оператор сравнения со строгим типом (===).

3 голосов
/ 24 января 2009

Прочитав ваше разъяснение, ответ @Ates Goral показывает, как выполнить ту же операцию, что вы делаете в C # в JavaScript.

@ Ответ Гамбо предоставляет лучший способ проверить на ноль; однако важно отметить разницу в == по сравнению с === в JavaScript , особенно , когда речь идет о проверке undefined и / или null.

Есть действительно хорошая статья о разнице в двух терминах здесь . В принципе, следует понимать, что если вы используете == вместо ===, JavaScript попытается объединить сравниваемые значения и вернуть результат сравнения после этого слияния.

...