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

«Неопределенная переменная» отличается от значения 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 (что верно ТОЛЬКО для null и undefined - на втором изображении фокус на строках / столбцах null-undefined)

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):

если

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

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

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

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

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

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

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

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

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

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 != 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
  } 
}

Самый простой способ провести тест:

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