Как проверить наличие нулевых, неопределенных или пустых значений в JavaScript

Даже то, что мы считаем само собой разумеющимся, например, прием пищи. Вы или я могли бы без раздумий проглотить любую пищу, в то время как родители нервно смотрят на своего первенца, который ест банан, и готовы ударить его по спине при первых признаках затруднений.

Проверка на наличие NULL может действовать на нервы как начинающим, так и опытным разработчикам JavaScript. Это то, что должно быть очень простым, но все равно вызывает удивление у большого количества людей.

Основная причина этого заключается в том, что в большинстве языков мы должны использовать только null. Но в JavaScript мы должны использовать как null, так и undefined. Как нам это сделать?

Как написать функцию проверки null в JavaScript

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

В наши дни, когда вы набираете в Google рецепт приготовления тостов, вы получаете эссе на 5000 слов, прежде чем автор предложит вам поставить хлеб в духовку. Давайте не будем так делать. Проверка наличия null в JavaScript может быть выполнена следующим образом.

Давайте представим наш объект тестовых данных таким образом:

var testObject = {
    empty: '',
    isNull: null,
    isUndefined: undefined,
    zero: 0
}
>

Наша функция проверки null выглядит следующим образом, где мы просто проверяем наличие null:

function isNull(value){
    if (value == null){
        return true
    }
    else{
        return false
    }
}

Чтобы протестировать эту функцию, давайте введем в нее некоторые значения и посмотрим, как это работает:

console.log(`
    testObject.empty: ${isNull(testObject.empty)}
    testObject.isNull: ${isNull(testObject.isNull)}
    testObject.isUndefined: ${isNull(testObject.isUndefined)}
    zero: ${isNull(testObject.zero)}    
    `)

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

C:\Program Files\nodejs\node.exe .\index.js

    testObject.empty: false
    testObject.isNull: true
    testObject.isUndefined: true
    zero: false    

Если объекты равны нулю или не определены, то эта функция вернет значение true.

Проверка наличия нулевой, неопределенной или пустой строки

Что, если мы хотим проверить, является ли переменная нулевой или она просто пустая? Мы можем проверить это, выполнив следующие действия:

function isNullOrEmpty(value){
    return !value;
}

Это зависит от объекта. Значения, такие как words или числа, большие нуля, вернут значение true, в то время как пустые строки вернут значение false.

Мы должны быть немного осторожны с этим приложением. Давайте рассмотрим ввод в форму. Например, если в форме была пустая строка, то можно было бы сказать, что поле не заполнено.

Однако, если пользователь указал в форме один-единственный "0", то значение "0" также будет равно "ложь". В случае проверки формы это сработает не так, как мы ожидали. Пустые массивы также будут иметь значение false, поэтому результат для несуществующего массива и для существующего массива, в котором нет никаких значений, по сути, будет одинаковым. Вероятно, это не то, что вам нужно.

Боже, это становится все сложнее. Но почему так происходит? Давайте немного углубимся в суть.

Изучение сложностей использования null и undefined в JavaScript

Вероятно, на эту тему есть сотни, если не тысячи, сообщений и записей в StackOverflow. Все просто - поведение null и undefined несколько странно для разработчиков, как новых, так и старых. Если мы делаем это неправильно, веб-сайты ломаются, или наши приложения node перестают работать. Поэтому мы действительно хотим подключить его и убедиться, что он работает так, как мы ожидаем.

Добавьте к этому, что JavaScript существует с 1995 года. Это также создает проблемы. Сегодня JavaScript используется практически на каждой веб-странице, поэтому основные функции просто невозможно переписать или реализовать заново. Если бы в одночасье были внесены изменения в то, как обрабатываются значения null или undefined в браузерах и фреймворках, таких как Node.js, бойня была бы огромной. Это, например, привело бы к перебоям в работе Crowdstrike.

Причина этого в том, что большинство языков используют только null, а undefined - это то, что используется только в JavaScript. Хотя null подходит для обозначения отсутствия значения, обычно вместо возврата undefined в других языках эти языки генерируют исключение.

Например, в C#, если бы мы написали следующее:

string testString;
Console.WriteLine(testString);

Наш код выдал бы сообщение с использованием неназначенной локальной переменной testString. Компилятор выполняет некоторый анализ и сообщает нам, что мы не можем использовать переменную, которая не была назначена. Другими словами, она не определена.

В C# (и многих других языках) мы никогда не рискуем использовать неопределенные элементы, потому что что-то выдает ошибку до того, как мы окажемся в такой ситуации. Даже если бы вы выполняли действия на других языках, которые приводили бы к выбросу, например, обращались к записи в массиве, который находится за пределами допустимых значений, C# выдал бы выборку, тогда как JavaScript просто вернул бы undefined.

Считать:

    let array = [];
    console.log(array[5])

У нас есть пустой массив, и затем мы пытаемся вывести пятый элемент из массива. Это выходит за рамки. Результат выполнения этого кода не определен.

Различие между назначенными, нулевыми и неопределенными

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

Есть три состояния, в которых может находиться наш ящик:

Значение присвоено. Независимо от того, что это за значение, мы знаем, что объекту присвоено значение, потому что оно не является нулевым или неопределенным. Из-за этого в поле/переменной присутствует объект:

Значение равно null. Поле по-прежнему на месте, но в нем ничего нет:

Значение не определено. Поле не существует.

Вывод

В большинстве случаев достаточно проверить, является ли элемент нулевым. Но поскольку у нас есть как undefined, так и null, и оба они могут означать разные вещи, всякий раз, когда мы выполняем проверку на наличие null, нам нужно подумать о том, какую именно проверку мы пытаемся выполнить, и действовать соответствующим образом.

Поскольку null - это ложное значение, может возникнуть соблазн написать код типа if (!value), чтобы что-то сделать, если переменная равна null. Но, как мы уже видели, это также может привести к тому, что пустые строки и пустые массивы не пройдут эту проверку.

Понимание этих ключевых различий может помочь нам писать высококачественный код, который не ведет себя неожиданным образом. И это то, к чему мы всегда должны стремиться, даже если это займет немного больше времени.