JavaScript нулевая проверка

Я наткнулся на следующий код:

function test(data) {
    if (data != null && data !== undefined) {
        // some code here
    }
}

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

Вы получите ошибку, если получите доступ к неопределенной переменной в любом контексте, кроме typeof.

Обновление: ответ (цитата) выше может вводить в заблуждение. Он должен сказать «необъявленная переменная» , а не «неопределенная переменная» .

Как я выяснил, в ответах на Райана ♦ , maerics и nwellnhof , даже когда в функцию не передаются аргументы, ее переменные для аргументов всегда объявляются. Этот факт также доказывает неправильность первого пункта в списке ниже.

Насколько я понимаю, могут возникнуть следующие сценарии:

• Функция была вызвана без аргументов, создавая dataнеопределенную переменную и вызывая ошибку data != null.

• Функция была вызвана специально с null(или undefined) в качестве аргумента, и в этом случае data != nullуже защищает внутренний код, что делает его && data !== undefinedбесполезным.

• Функция была вызвана с ненулевым аргументом, в этом случае она будет тривиально передавать data != null и data !== undefined .

Q: мое понимание верно?

Я попробовал следующее в консоли Firefox:

--
[15:31:31.057] false != null
[15:31:31.061] true
--
[15:31:37.985] false !== undefined
[15:31:37.989] true
--
[15:32:59.934] null != null
[15:32:59.937] false
--
[15:33:05.221] undefined != null
[15:33:05.225] false
--
[15:35:12.231] "" != null
[15:35:12.235] true
--
[15:35:19.214] "" !== undefined
[15:35:19.218] true

Я не могу понять случай, когда data !== undefined после data != null может быть какой-либо пользы.

«Неопределенная переменная» отличается от значения undefined.

Неопределенная переменная:

var a;
alert(b); // ReferenceError: b is not defined

Переменная со значением undefined:

var a;
alert(a); // Alerts “undefined”

Когда функция принимает аргумент, этот аргумент всегда объявляется, даже если его значение равно undefined, и поэтому ошибки не будет. Вы правы в том, что != nullследует !== undefinedбесполезно.

В JavaScript nullэто специальный одноэлементный объект, который полезен для сигнализации «нет значения». Вы можете проверить это путем сравнения, и, как обычно в JavaScript, рекомендуется использовать ===оператор, чтобы избежать путаницы приведения типов:

var a = null;
alert(a === null); // true

Как отмечает @rynah, «undefined» немного сбивает с толку в JavaScript. Тем не менее, всегда безопасно проверить, typeof(x)является ли строка «undefined», даже если «x» не является объявленной переменной:

alert(typeof(x) === 'undefined'); // true

Кроме того, переменные могут иметь «неопределенное значение», если они не инициализированы:

var y;
alert(typeof(y) === 'undefined'); // true

Собрав все вместе, ваш чек должен выглядеть так:

if ((typeof(data) !== 'undefined') && (data !== null)) {
  // ...

Однако, поскольку переменная «data» всегда определяется, поскольку она является формальным параметром функции, использование оператора «typeof» не является необходимым, и вы можете безопасно сравнивать напрямую с «неопределенным значением».

function(data) {
  if ((data !== undefined) && (data !== null)) {
    // ...

Этот фрагмент означает, что "если функция была вызвана с аргументом, который определен и не является нулевым ..."

В вашем случае используйте data==null(что справедливо ТОЛЬКО для нулевого и неопределенного - на втором изображении фокусируйтесь на строках / столбцах с нулевым неопределенным значением)

function test(data) {
    if (data != null) {
        console.log('Data: ', data);
    }
}

test();          // the data=undefined
test(null);      // the data=null
test(undefined); // the data=undefined

test(0); 
test(false); 
test('something');

Здесь у вас есть все ( SRC ):

если

== (его отрицание ! = )

=== (это отрицание ! == )

Q: Функция была вызвана без аргументов, что делало данные неопределенной переменной и приводило к ошибке данных! = Null.

A: Да, dataбудет установлено неопределенное. См. Раздел 10.5. Декларация обязательности . Но доступ к неопределенному значению не вызывает ошибку. Вы, вероятно, путаете это с доступом к необъявленной переменной в строгом режиме, которая вызывает ошибку.

Q: Функция была вызвана специально с нулем (или неопределенным) в качестве аргумента, и в этом случае data! = Null уже защищает внутренний код, делая && data! == undefined бесполезным.

Q: Функция была вызвана с ненулевым аргументом, и в этом случае она будет тривиально передавать как данные! = Нуль, так и данные! == undefined.

A: Верно. Обратите внимание, что следующие тесты эквивалентны:

data != null
data != undefined
data !== null && data !== undefined

См. Раздел 11.9.3 Алгоритм сравнения абстрактного равенства и раздел 11.9.6 Алгоритм сравнения строгого равенства спецификации.

Я думаю, что тестирование переменных на значения, которые вы не ожидаете, в целом не очень хорошая идея. Потому что тест как ваш можно считать записью в черный список запрещенных значений. Но что, если вы забудете перечислить все запрещенные значения? Кто-то, даже вы, может взломать ваш код с передачей неожиданного значения. Поэтому более подходящий подход - это что-то вроде белого списка - тестирование переменных только на ожидаемые значения, а не на неожиданные. Например, если вы ожидаете, что значение данных будет строкой, вместо этого:

function (data) {
  if (data != null && data !== undefined) {
    // some code here
    // but what if data === false?
    // or data === '' - empty string?
  }
}

сделать что-то вроде этого:

function (data) {
  if (typeof data === 'string' && data.length) {
    // consume string here, it is here for sure
    // cleaner, it is obvious what type you expect
    // safer, less error prone due to implicit coercion
  } 
}

typeof foo === "undefined"отличается foo === undefined, никогда не путайте их. typeof foo === "undefined"это то, что вам действительно нужно. Кроме того, используйте !==вместо!=

Таким образом, заявление можно записать как

function (data) {
  if (typeof data !== "undefined" && data !== null) {
    // some code here
  }
}

Редактировать:

Вы не можете использовать foo === undefinedдля необъявленных переменных.

var t1;

if(typeof t1 === "undefined")
{
  alert("cp1");
}

if(t1 === undefined)
{
  alert("cp2");
}

if(typeof t2 === "undefined")
{
  alert("cp3");
}

if(t2 === undefined) // fails as t2 is never declared
{
  alert("cp4");
}

Простой способ сделать ваш тест:

function (data) {
    if (data) { // check if null, undefined, empty ...
        // some code here
    }
}

var a;
alert(a); //Value is undefined

var b = "Volvo"; 
alert(b); //Value is Volvo

var c = null;
alert(c); //Value is null