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

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

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

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

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

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

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

Вот мое решение. Как сказал Энди Э., отвечая на вопрос || как замена ?? не достаточно хорошо в вашем случае, потому что оно проглатывает пустые строки и нули, вы всегда можете написать свою собственную функцию:

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

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

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

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

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

Никто не упомянул здесь потенциал для 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

Если вы используете типичный метод coalesce, , как указано здесь , вы получите c, который имеет значение: NaN

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

Ни один из них не кажется мне правильным. В моем собственном маленьком мире логики слияния, который может отличаться от вашего мира, я считаю, что undefined, null и NaN — все это «ноль». Итак, я ожидал бы получить ответ Если чей-то мозг работает так же, как мой, и вы хотите исключить d (ноль) из метода coalesce.

, тогда этот метод выполнит следующее: NaN Почему NaN не равен 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. Подробнее об этом можно прочитать здесь: параметр В настоящее время нет поддержки, но процесс стандартизации JS работает над этим:

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 есть два определения «нет значения». Нуль: когда переменная равна нулю, это означает, что в ней нет данных, но переменная уже определена в коде. например: оператор массива и объекта в ES6 (объект еще не полностью поддерживается), поэтому, в основном, если вы уже определили свой реквизит, вы можете передать его своему элементу таким образом.

в таком случае тип вашей переменной на самом деле Object. Попробуй это.

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

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

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

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

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

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

@ Ответ Gumbo обеспечивает лучший способ проверки на нулевое значение ;, однако важно отметить разницу в

@ Gumbo обеспечивает лучший способ проверки на нулевое значение ;, однако важно отметить разницу в == по сравнению с === в JavaScript , особенно , когда речь заходит о проверке Есть действительно хорошая статья о разнице в двух терминах undefined Пример 2 null Глядя на вывод

, JavaScript попытается объединить сравниваемые значения и вернуть результат сравнения говорится, что . По сути, следует понимать, что если вы используете == вывод будет: === этого слияния. после возврата функции * * все локальные переменные больше не доступны, потому что стековый фрейм уничтожен. javascript — простейший пример SOAP — переполнение стека