Javascript сравнить с undefined

undefined

undefined возвращается, если переменная была объявлена, но значение переменной не было установлено.
Например:

В логе мы видим undefined :

undefined также может возникнуть, если свойство объекта не существует.

или функция имеет отсутствующий параметр:

undefined — примитивный тип данных в Javascript:

Проверить тип можно с помощью ключевого слова typeof :

undefined может быть задан явно:

null — это тип данных в Javascript, который не определяет значение или несуществующее значение. null может рассматриваться как преднамеренное отсутствие значения какого-либо объекта.

Схожие черты

Давайте посмотрим на их сходства.

И то, и другое — это ложные (false) значения.

null и undefined типы всегда преобразуется в значение false . Они относятся к числу ложных значений в JS:

• null
• undefined
• false
• 0
• Пустая строка -> «»
• NaN

Если они находятся в условии оператора if-else , оператор else всегда будет выполняться:

Вышеприведенное выведет Нет.

также выведет Нет.

Оба являются примитивными значениями

В Javascript есть сложные и примитивные типы данных, null и undefined — среди примитивных типов данных:

• null
• undefined
• Symbol
• String
• Number
• Boolean

Примитивные типы данных обрабатываются по значению.

Различия

null и undefined означают нет значения , но имееют разные значения в определении типа:

Вы ожидали, что тип null вернет «null«? Правда? Это ошибка в JS существует уже на протяжении почти двух десятилетий, но дело в том, что она не может быть исправлена. Потому, что тысячи сайтов зависят от такого неправильного поведения, исправление которого приведет к их поломке.

null — это назначаемое значение, т.е. должно быть явно назначено программистом. Если переменная не назначена, она становится undefined :

в отличие от undefined , которые могут быть явно назначены или не назначены:

Тесты для null

Как мы уже видели, undefined преобразовывается в » undefined «, а null преобразовывается в » object «.

Мы можем легко проверить на undefined:

Для null, мы не можем этого сделать:

typeof null возвращает » object «, и у нас может возникнуть соблазн переписать все вышеперечисленное следующим образом:

Но многие сложные типы данных возвращают объекты, тип может быть проверен через typeof :

Таким образом, он не сработает, потому что массив или объект может быть значением test . Теперь, как правильно проверить на null, поскольку null — это значение false , мы объединим его проверку с проверкой на тип.

Давайте посмотрим, что происходит, когда строгое и не строгое равенство выполняется для обоих типов.

Сравнение равенств

Не строгое сравнение:

• Если x равен null, а y undefined, возвращается true.
• Если x undefined, а y равен null, возвращается true.

Строгое сравнение:

Сравнение x === y , где x и y являются значениями, дает true или false. Такое сравнение выполняется следующим образом:

1. Если тип(x) отличается от типа(y), то возвращается false.
2. Если тип(x) равно Number, то:
   • Если x — NaN, возвращается false
   • Если y — NaN, то возвращайтся false.
   • Если x равно значению того же числа, что и y, то возвращается true
   • Если x равно +0, а y равно -0, то возвращается true
   • Если x равно -0, а y равно +0, то возвращается true

Здесь будет false , потому что типы являются object и undefined , видно, что они разные, поэтому возвращается false .

будет false. Почему? Потому, что null => object не тот же тип, что и undefined => undefined.

Поймите, оператор !== спрашивает, не строго ли совпадает x c y ? Итак, в нашем случае да (true) объект x (null => object) не является строго равным y (undefined => undefined).

Тут проверяется, не совпадает ли x с y . В данном случае нет (возвращает false ), так как они равны, потому что Javascript возвращает true, если x является либо null , либо undefined и y является либо null , либо undefined .

Передача null и undefined в качестве аргумента функции

Мы должны быть осторожны при объявлении значения аргумента по умолчанию таким образом:

Эта функция просто возвращает переданное ей имя, видим, что имя аргумента имеет значение по умолчанию test_name , аргумент будет принимать test_name в качестве значения, когда функция вызывается без параметров:

Можно сказать так, когда имя аргумента не определено, он принимает значение test_name . Так что если мы передадим неопределенное значение в testFunc имя будет test_name :

А что будет, если мы перейдем в функцию null ? Как вы думаете, он будет выводить test_name , потому что null означает отсутствие значения, или он будет записывать null, потому что null — это значение? Посмотрим:

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

Если вы пытаетесь проверить на null аргумент, помните, так лучше не делать:

или вы можете делегировать функции проверку на null:

вы можете использовать функцию isNull в любом месте вашей программы:

Заключение

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

Источник

undefined

Сводка

Значение глобального свойства undefined представляет значение undefined . Это одно из примитивных значений JavaScript.

Атрибуты свойства undefined
Записываемое	нет
Перечисляемое	нет
Настраиваемое	нет

The source for this interactive example is stored in a GitHub repository. If you’d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

Синтаксис

Описание

undefined является свойством глобального объекта, то есть, это переменная в глобальной области видимости. Начальным значением undefined является примитивное значение undefined .

В современных браузерах (JavaScript 1.8.5 / Firefox 4+), undefined является ненастраиваемым и незаписываемым свойством, в соответствии со спецификацией ECMAScript 5. Даже когда это не так, избегайте его переопределения.

Переменная, не имеющая присвоенного значения, обладает типом undefined . Также undefined возвращают метод или инструкция, если переменная, участвующая в вычислениях, не имеет присвоенного значения. Функция возвращает undefined , если она не возвращает какого-либо значения.

Поскольку undefined не является зарезервированным словом (en-US) , он может использоваться в качестве идентификатора (имени переменной) в любой области видимости, за исключением глобальной.

Примеры

Пример: строгое сравнение и undefined

Вы можете использовать undefined и операторы строгого равенства или неравенства для определения того, имеет ли переменная значение. В следующем коде переменная x не определена и инструкция if вычисляется в true .

Обратите внимание: здесь используется оператор строгого равенства (идентичности) вместо простого оператора равенства, поскольку x == undefined также проверяет, является ли x равным null , в то время как оператор идентичности этого не делает. null не эквивалентен undefined . Для более подробной информации смотрите операторы сравнения (en-US) .

Пример: оператор typeof и undefined

В качестве альтернативы можно использовать оператор typeof :

Одной из причин использования оператора typeof может быть та, что он не выбрасывает ошибку, если переменная не была определена.

Однако, уловки такого рода должны избегаться. JavaScript является языком со статической областью видимости, так что узнать, была ли переменная определена, можно путём просмотра, была ли она определена в охватывающем контексте. Единственным исключением являет глобальная область видимости, но глобальная область видимости привязана к глобальному объекту, так что проверка существования переменной в глобальном контексте может быть осуществлена путём проверки существования свойства глобального объекта (например, используя оператор in ).

Пример: оператор void и undefined

Третьей альтернативой является оператор void .

Источник

Форум

Справочник

undefined

Обозначает неопределенное значение

Описание, примеры

Эта глобальная переменная содержит элементарное неопределенное значение — то, которое имеет переменная, значение которой не указано.

Например, функция без директивы return возвращает undefined .

Обращение к несуществующему свойству объекта также даст undefined .

Как видно из примеров, определить, является ли значение undefined , можно строгим (тройным) знаком равенства.

Например, можно проверить, существует ли глобальная переменная:

Обратите внимание — при сравнении идет обращение к свойству через заведомо существующий объект window . Поэтому интерпретатор не выдаст ошибку даже если свойства somevar не существует.

Также заметим, что нужен именно строгий оператор сравнения, т.к x==undefined возвратит true также если x является (null), а это уже другое значение.

Строгое сравнение является лучшей альтернативой использованию typeof:

Заметим, что нужен именно строгий оператор сравнения, т.к x==undefined верно также если x является null, а это уже другое значение.

Вопрос непонятен.. Там пример именно с typeof дан в конце статьи.

строгий оператор сравнения null === undefined — false
обычное сравнение null == undefined — true!
Что не понятного?

В общем, если в статье что-то неверно или непонятно — напишите Как я понял — в статье все ок

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

Так ведь объект test определён — он равен null. Поэтому строгое сравнение с undefined и дает false. Вот если бы без первой строчки.

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

function test(a) <
if (a===undefined) alert(‘a is not defined’);
>
test();

undefined это что?

значит «значение не присвоено»

спасибо за сайт, добавлю себе в избранное =)

Классно, typeof мне никогда не нравился. Заменю на ===. Причем фишку с == тоже можно использовать, чтобы определить, что в переменной содержится хоть какое-то значение:

if (obj.Field === undefined || obj.Field == null)
меняется на
if (obj.Field == undefined)

Стоило бы написать, что несуществующую переменную сравниванием с этой переменной проверять нельзя, потому что возникнет ошибка

Илья, просьба замечание Петра внести в статью, так как оно очень важное. Спасибо!

не вижу ничего важного. Это основа, которую обязан знать каждый.

Ну тогда можно все статьи снести что кажутся основой. Этож должен знать каждый. melky, ты глупость сказал

undefined можно использовать в качестве идентификатора, так как значение не является зарезервированным словом.

Также для проверки значения переменной на undefined можно проверить с помощью void:

Источник

7 советов по обработке undefined в JavaScript

7 советов по обработке undefined в JavaScript

undefined в JavaScript — настоящий кошмар начинающего фронтендера. В чём отличие undefined и null , если даже сравнение null == undefined выводит true , и как обрабатывать ошибку undefined ? Давайте разбираться.

Примечание Вы читаете улучшенную версию некогда выпущенной нами статьи.

Что такое undefined в JavaScript

undefined является специальным значением. Согласно спецификации ECMAScript, undefined в JavaScript можно получить при доступе к неинициализированным переменным, несуществующим свойствам объекта, несуществующим элементам массива, etc. Пример:

Как видим, undefined выводится при попытке доступа к:

• неинициализированной переменной number ;
• несуществующему свойству объекта movie.year ;
• несуществующему элементу массива movies[3] .

Оператор typeof возвращает строку undefined для неопределённого значения:

Оператор typeof отлично подходит для проверки значения undefined в JavaScript:

Как избежать undefined в JavaScript

Неинициализированная переменная

Объявленная переменная, которая еще не имеет значения (не инициализирована), по умолчанию undefined . Пример:

Переменная myVariable уже объявлена, но ещё не имеет присвоенного значения. Попытка обратиться к ней закончится выводом undefined . Чтобы это исправить, достаточно присвоить переменной значение. Чем меньше переменная существует в неинициализированном состоянии, тем лучше.

Ниже приведены способы решения проблемы.

1. const и let вместо var

Объявленные таким образом объекты и переменные находятся в области видимости, ограниченной текущим блоком кода, и находятся во временной мёртвой зоне до момента присвоения им значения.

При использовании неизменяемых данных (констант) рекомендуется инициализировать их как const :

Константа не подвергается неинициализированному состоянию, и получить значение undefined в этом случае невозможно.

27 марта в 12:00, Онлайн, Беcплатно

Если вам нужно менять значение переменной, то обозначьте её как let и также присваивайте ей начальное значение:

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

В этом случае переменная myVariable содержит undefined до получения значения:

Если же переменную объявить как let , она останется недоступной до момента присвоения ей значения. Таким образом, использование const или let снизит риск получения значения undefined в JavaScript.

2. Усиление связности

Связность характеризует степень взаимосвязи элементов модуля (пространства имён, класса, метода, блока кода). Сильная связность предпочтительнее, поскольку предполагает, что элементы модуля должны фокусироваться исключительно на одной задаче. Это поможет модулю быть:

• сфокусированным и понятным;
• легко поддерживаемым и поддающимся рефакторингу;
• многоразовым;
• простым для тестирования.

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

Вот классический пример того, как не надо делать:

index , item и length объявляются в начале функции, но используются они лишь ближе к концу. Всё время между объявлением переменной в начале и до использования её в цикле index и item не инициализируются и выводят undefined . Разумнее переместить переменные ближе к месту их применения:

Доступ к несуществующему свойству

Попытка получить доступ к несуществующему свойству объекта JavaScript заканчивается undefined . Пример:

favoriteMovie — объект с одним значением title . Доступ к несуществующему свойству actors приведёт к выводу undefined .

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

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

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

Реализуем функцию append(array, toAppend) , которая добавляет в начале и/или в конце массива новые элементы:

Поскольку объект toAppend может удалять первые или последние свойства, необходимо проверить их существование с помощью условий if(toAppend.first)<> и if(toAppend.last)<> .

Вот только undefined , как false , null , 0 , NaN и ‘ ‘ , является ложными значением, а в текущей реализации функция append() не позволяет вставлять ложные элементы:

0 и false — ложные значения, потому что if (toAppend.first)<> и if (toAppend.last)<> фактически сравниваются с ложными значениями, и эти элементы не вставляются в массив. Функция возвращает исходный массив [10] без изменений.

1. Наличие свойства

К счастью, JavaScript предлагает множество способов определить, имеет ли объект определённое свойство:

• obj.prop !== undefined в JavaScript позволяет проверить undefined , сравнив с ним объект;
• typeof obj.prop !== ‘undefined’ проверяет тип значения свойства;
• obj.hasOwnProperty(‘prop’) проверяет объект на наличие собственного свойства;
• ‘prop’ in obj проверяет объект на наличие собственного или унаследованного свойства.

Рекомендацией в этом случае будет использование оператора in , чтобы проверить, имеет ли объект определённое свойство, не обращаясь к фактическому значению этого свойства:

‘first’ in toAppend ( как и ‘last’ in toAppend ) выводит true , независимо от существующего свойства. В других случаях выводится — false .

Использование оператора in устраняет проблему со вставкой ложных элементов 0 и false . Теперь добавление элементов в начале и в конце массива [10] приводит к ожидаемому результату: [0, 10, false] .

2. Деструктуризация доступа к свойствам объекта

Деструктуризация объекта позволяет устанавливать значение по умолчанию, если свойство не существует: удобно для исключения прямого контакта с undefined :

Применяя преимущества деструктуризации объекта, реализуем quote() :

const < char = '"', skipIfQuoted = true >= config в одной строкe извлекает свойства char и skipIfQuoted из объекта config .

Если некоторые свойства недоступны в объекте config , деструктуризация задаёт значения по умолчанию: ‘»‘ для char и false для skipIfQuoted . К счастью, функцию можно улучшить.

Переместим деструктуризацию в раздел параметров и установим значение по умолчанию (пустой объект < >) для параметра config , чтобы пропустить второй аргумент, когда будет достаточно значений по умолчанию:

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

3. Свойство по умолчанию

Есть простой способ установить значения по умолчанию для свойств объекта, и имя ему Spread syntax:

Инициализатор объекта распространяет свойства из исходных объектов defaults и unsafeOptions . Важен порядок, в котором указаны исходные объекты: свойства более позднего исходного объекта перезаписывают более ранние. Независимо от ситуации, объект всегда содержит полный набор свойств, и появление undefined невозможно.

Параметры функции

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

При вызове функции multiply(5, 3) параметры a и b получают соответствующие значения 5 и 3 . Умножение рассчитывается как ожидаемое: 5 * 3 = 15 .

Но что происходит, когда пропускается аргумент при вызове? Параметр внутри функции получает значение undefined . Как этого избежать?

Лучшим подходом является использование параметров по умолчанию из ES2015:

Значение b = 2 в сигнатуре функции гарантирует, что если b получит значение undefined , то по умолчанию параметр изменится на 2 .

Возвращаемое значение функции

В JavaScript функция, которая не имеет оператора return , возвращает значение undefined :

То же происходит, если return присутствует, но без какого-либо выражения рядом:

Указывая значение для return , можно получить желаемый результат:

Теперь вызов функции выведет нужное значение.

Оператор void

Оператор void выполняет выражение и возвращает undefined вне зависимости от результата:

Одним из вариантов использования оператора void является переопределение результата выполнения выражения и возврат undefined в случае возникновения неожиданных результатов выполнения функции.

Значение undefined в массивах

Вы получаете undefined при попытке доступа к элементу массива с индексом вне пределов массива.

Массив colors имеет 3 элемента, поэтому корректные индексы равны 0 , 1 и 2 . Поскольку в индексах массива 5 и -1 нет элементов, значения colors[5] и colors[-1] получают значение undefined .

В JavaScript вы можете столкнуться с так называемыми разрежёнными массивами. Эти массивы имеют пробелы, то есть на некоторых индексах не определены никакие элементы. Когда делаем попытку получить доступ к пустому значению в разрежённом массиве, на выходе получаем undefined :

sparse1 создается путем вызова конструктора Array с числовым первым аргументом. Он имеет 3 пустых элемента. sparse2 создается с литералом массива, второй элемент которого отсутствует. В любом из этих массивов доступ к пустому элементу оценивается как undefined .

Отличие null и undefined в JavaScript

Основное отличие в том, что undefined представляет значение переменной, которая ещё не была инициализирована, а null — намеренное отсутствие объекта.

Допустим, переменная number определена, но ей не назначено начальное значение:

То же самое произойдёт при попытке доступа к несуществующему свойству объекта:

Или переменная должна ожидать возвращение объекта функции, но по какой-то причине создание объекта невозможно. В этом случае null является значимым индикатором недостающего объекта. Например, clone() — это функция, которая клонирует простой объект JavaScript. Ожидается, что функция вернёт объект:

Но clone() может быть вызван с пустым аргументом: 15 или null . В этом случае функция не может создать клон, поэтому возвращает null — индикатор отсутствующего объекта.

В JavaScript существуют проверки на null и undefined . Оператор typeof демонстрирует различие между двумя значениями:

Строгий оператор равенства === также отличает undefined от null :

Вам также может быть интересна наша статья про обработку ошибок в JavaScript.

Заключение

Стратегия борьбы с undefined в JavaScript:

1. Уменьшить использование неинициализированных переменных.
2. Сделать жизненный цикл переменных коротким и близким к источнику их использования.
3. Назначить начальное значение переменным.
4. Использовать const или let .
5. Проверять наличие свойств или заполнить небезопасные объекты по умолчанию.
6. Использовать значения по умолчанию для некритичных параметров функции.
7. Избегать использования разрежённых массивов.

Источник