Я хочу знать, в чем разница между null
и undefined
в JavaScript.
null
ты установил это пустым, undefined
это пусто, потому что это не было установлено. Или специально null
пусто, пока undefined
еще пусто. В основном это показывает намерение.
Я хочу знать, в чем разница между null
и undefined
в JavaScript.
null
ты установил это пустым, undefined
это пусто, потому что это не было установлено. Или специально null
пусто, пока undefined
еще пусто. В основном это показывает намерение.
Ответы:
В JavaScript undefined
означает, что переменная была объявлена, но ей еще не присвоено значение, например:
var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined
null
является значением присваивания. Он может быть присвоен переменной как представление без значения:
var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object
Из предыдущих примеров ясно, что undefined
и null
есть два разных типа: undefined
это сам тип (не определен), а null
является объектом.
null === undefined // false
null == undefined // true
null === null // true
а также
null = 'value' // ReferenceError
undefined = 'value' // 'value'
Я выбрал это отсюда
Неопределенное значение является примитивным значением, используемым, когда переменной не было присвоено значение.
Нулевое значение - это примитивное значение, представляющее пустую, пустую или несуществующую ссылку.
Когда вы объявляете переменную через var и не присваиваете ей значение, оно будет иметь значение undefined. Само по себе, если вы попытаетесь WScript.Echo () или alert () это значение, вы ничего не увидите. Однако, если вы добавите к нему пустую строку, то внезапно появится:
var s;
WScript.Echo(s);
WScript.Echo("" + s);
Вы можете объявить переменную, установить для нее значение null, и поведение будет идентичным, за исключением того, что вы увидите распечатку «null» вместо «undefined». Это небольшая разница действительно.
Вы даже можете сравнить переменную, которая не определена, со значением NULL или наоборот, и условие будет истинным:
undefined == null
null == undefined
Они, однако, считаются двумя различными типами. В то время как undefined является типом для себя самого, null считается значением специального объекта. Это можно увидеть с помощью typeof (), который возвращает строку, представляющую общий тип переменной:
var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));
Запуск вышеуказанного скрипта приведет к следующему выводу:
undefined
object
Независимо от того, являются ли они разными типами, они все равно будут действовать одинаково, если вы попытаетесь получить доступ к члену любого из них, например, то есть они сгенерируют исключение. С WSH вы увидите страшное «varname» - ноль или не объект », и это, если вам повезет (но это тема для другой статьи).
Вы можете явно установить переменную как неопределенную, но я настоятельно рекомендую это сделать. Я рекомендую только устанавливать переменные в null и оставлять неопределенным значение для вещей, которые вы забыли установить. В то же время я настоятельно рекомендую вам всегда устанавливать каждую переменную. JavaScript имеет цепочку областей видимости, отличную от цепочки языков C, легко запутывающую даже опытных программистов, и установка переменных в null - лучший способ предотвратить ошибки на его основе.
Другой случай, когда вы увидите неопределенное всплывающее окно, - это использование оператора удаления. Те из нас, кто живет в С-мире, могут неправильно истолковывать это как уничтожение объекта, но это не так. Эта операция удаляет индекс из массива или элемент из объекта. Для массивов это не влияет на длину, скорее, этот индекс теперь считается неопределенным.
var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);
Результат приведенного выше сценария:
0.) a
1.) undefined
2.) c
Вы также получите неопределенное возвращаемое значение при чтении нижнего индекса или члена, который никогда не существовал.
Разница между null и undefined заключается в следующем: JavaScript никогда не установит ничего на null, обычно это то, что мы делаем. Хотя мы можем установить переменные на неопределенные, мы предпочитаем ноль, потому что это не то, что когда-либо делалось для нас. Когда вы отлаживаете, это означает, что все, что установлено на ноль, принадлежит вам, а не JavaScript. Кроме того, эти два специальных значения почти эквивалентны.
null - это специальное ключевое слово, которое указывает на отсутствие значения.
думать об этом как о значении, например:
Свойство undefined указывает, что переменной не было присвоено значение, включая ноль. подобно
var foo;
определенная пустая переменная имеет null
тип данныхundefined
Оба они представляют значение переменной без значения
AND
null
не представляет строку, которая не имеет значения - пустая строка-
подобно
var a = '';
console.log(typeof a); // string
console.log(a == null); //false
console.log(a == undefined); // false
Сейчас если
var a;
console.log(a == null); //true
console.log(a == undefined); //true
НО
var a;
console.log(a === null); //false
console.log(a === undefined); // true
У каждого есть свой способ использования
undefined используйте его для сравнения типа данных переменной
null использовать его для очистки значения переменной
var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object
null
Абсолютно является типом данных: msdn.microsoft.com/en-us/library/ie/7wkd9z69(v=vs.94).aspx. Тот факт, что typeof null
возвращается, object
является хорошо известной и задокументированной ошибкой в ранних версиях ECMAScript, которая осталась для обратной совместимости. Ссылка, которую вы фактически разместили в своем комментарии, говорит на полпути вниз по странице "typeof null // object (ошибка в ECMAScript, должна быть нулевой)"! Поэтому, пожалуйста, проявите усилия поиска, прежде чем комментировать
null : отсутствие значения для переменной; undefined : отсутствие самой переменной;
Переменная ..where - это символическое имя, связанное со значением.
JS может быть достаточно любезен, чтобы неявно инициировать вновь объявленные переменные с нулем , но это не так.
var a = {}; a.n = undefined;' then ..
a.hasOwnProperty ('n') == true` ... так что отсутствие самой переменной больше не правильно
Пожалуйста, внимательно прочитайте следующее. Это устранит все ваши сомнения относительно различий между нулевым и неопределенным в JavaScript. Также вы можете использовать приведенную ниже функцию полезности для точного определения типов.
В JavaScript у нас могут быть следующие типы переменных.
Следующее объясняет каждый из этих случаев один за другим
Необъявленные переменные : для необъявленных переменных верно следующее
Объявленные, но неназначенные переменные
Переменные, назначенные с литералом undefined : эти переменные обрабатываются аналогично объявленным, но неназначенным переменным .
Переменные, назначенные с литералом null
Переменные, назначенные с чем-либо, кроме undefined или null
Ниже приведен алгоритм правильной проверки типа переменной:
Вы также можете использовать следующую служебную функцию для определения типов. В настоящее время он поддерживает все типы ECMA 262 2017.
function TypeOf(o,bReturnConstructor)
{
if(typeof o==='undefined') return 'undefined'
if(o===null) return 'null'
if(typeof o!=='object') return typeof o
var type=Object.prototype.toString.call(o)
switch(type)
{
//Value types:4
case '[object Number]': type='number';break;
case '[object String]': type='string';break;
case '[object Boolean]': type='boolean';break;
case '[object Date]': type='date';break;
//Error Types:7
case '[object Error]': type='error';break;
case '[object EvalError]': type='evalerror';break;
case '[object RangeError]': type='rangeerror';break;
case '[object ReferenceError]': type='referenceerror';break;
case '[object SyntaxError]': type='syntaxerror';break;
case '[object TypeError]': type='typeerror';break;
case '[object URIError]': type='urierror';break;
//Indexed Collection and Helper Types:13
case '[object Array]': type='array';break;
case '[object Int8Array]': type='int8array';break;
case '[object Uint8Array]': type='uint8array';break;
case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
case '[object Int16Array]': type='int16array';break;
case '[object Uint16Array]': type='uint16array';break;
case '[object Int32Array]': type='int32array';break;
case '[object Uint32Array]': type='uint32array';break;
case '[object Float32Array]': type='float32array';break;
case '[object Float64Array]': type='float64array';break;
case '[object ArrayBuffer]': type='arraybuffer';break;
case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
case '[object DataView]': type='dataview';break;
//Keyed Collection Types:2
case '[object Map]': type='map';break;
case '[object WeakMap]': type='weakmap';break;
//Set Types:2
case '[object Set]': type='set';break;
case '[object WeakSet]': type='weakset';break;
//Operation Types
case '[object RegExp]': type='regexp';break;
case '[object Proxy]': type='proxy';break;
case '[object Promise]': type='promise';break;
case '[object Object]': type='object';
if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
break;
default:
type=type.split(' ')[1]
type=type.substr(0,type.length-1)
}
return type
}
Я объясню undefined
, null
и Uncaught ReferenceError
:
1 - Uncaught ReferenceError
: переменная не была объявлена в вашем скрипте, нет ссылки на эту переменную
2 - undefined
: переменная объявлена, но не инициализирована
3 - null
: переменная объявлена и является пустым значением
null и undefined - это два разных типа объектов, которые имеют следующие общие черты:
==
и !=
операторами.Однако на этом сходство заканчивается. На этот раз есть принципиальная разница в том, как реализованы ключевые слова null и undefined . Это не очевидно, но рассмотрим следующий пример:
var undefined = "foo";
WScript.Echo(undefined); // This will print: foo
undefined , NaN и Infinity - это просто имена предварительно инициализированных «суперглобальных» переменных - они инициализируются во время выполнения и могут быть переопределены обычной глобальной или локальной переменной с теми же именами.
Теперь давайте попробуем то же самое с нулем :
var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);
К сожалению! null , true и false являются зарезервированными ключевыми словами - компилятор не позволит вам использовать их в качестве имен переменных или свойств
Другое отличие состоит в том, что undefined является примитивным типом, а null является типом объекта (что указывает на отсутствие ссылки на объект). Учтите следующее:
WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object
Кроме того, есть важное различие в том, как null и undefined обрабатываются в числовом контексте:
var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1
var b = null; // the value null must be explicitly assigned
WScript.Echo(b === null); // Prints: -1
WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)
WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)
WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)
WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)
Нуль становится 0, когда используется в арифметических выражениях или числовых сравнениях - подобно ложному , это в основном просто особый вид «ноль». undefined , с другой стороны, является истинным «ничем» и становится NaN («не числом»), когда вы пытаетесь использовать его в числовом контексте.
Обратите внимание , что нуль и Неопределенные получает специальное лечение от ==
и !=
операторов, но вы можете проверить истинное числовое равенство и Ь с выражением .(a >= b && a <= b)
ТЛ; др
Используйте null
для установки переменной вы знаете, что это объект.
Используйте undefined
для установки переменной, тип которой является смешанным.
Это мое использование 5 примитивов и типа объекта, и это объясняет разницу между «вариантом использования» undefined
или null
.
строка
Если вы знаете, что переменная является только строкой, а весь жизненный цикл, по соглашению, вы можете ее инициализировать, чтобы ""
:
("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"
Число
Если вы знаете, что переменная - это всего лишь число, в то время как весь жизненный цикл, по соглашению, вы можете инициализировать ее следующим образом 0
(или, NaN
если 0
это важное значение в вашем использовании):
(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"
или
(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"
логический
Если вы знаете, что переменная только логическая, в то время как весь жизненный цикл, по соглашению, вы можете инициализировать ее, чтобы false
:
(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"
объект
Если вы знаете, что переменная является только объектом, в то время как весь жизненный цикл, по соглашению, вы можете инициализировать его, чтобы null
:
(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"
Примечание: разумное использование с нулевым значением должно быть ложной версией Объекта, потому что Объект всегда true
и потому что typeof null
возвращают object
. Это означает, что typeof myVarObject
возвращаем согласованное значение как для объекта, так и для нулевого типа.
Все
Если вы знаете, что переменная имеет смешанный тип (любой тип в течение всего жизненного цикла), то по соглашению вы можете инициализировать ее, чтобы undefined
.
null
это специальное значение, означающее «нет значения». null
это специальный объект, потому что typeof null
возвращает «объект».
С другой стороны, undefined
означает, что переменная не была объявлена или ей не было присвоено значение.
undefined
может означать, что переменная не была объявлена, но не гарантирует этого. Переменная может быть объявлена как var thing;
и будет равна undefined
.
Лучший способ понять разницу - это сначала очистить свой разум от внутренней работы JavaScript и просто понять разницу в значении между:
let supervisor = "None"
// I have a supervisor named "None"
let supervisor = null
// I do NOT have a supervisor. It is a FACT that I do not.
let supervisor = undefined
// I may or may not have a supervisor. I either don't know
// if I do or not, or I am choosing not to tell you. It is
// irrelevant or none of your business.
Существует разница в значении между этими тремя случаями, и JavaScript различает последние два случая с двумя разными значениями, null
и undefined
. Вы можете использовать эти значения явно, чтобы передать эти значения.
Итак, каковы некоторые специфичные для JavaScript проблемы, возникающие из-за этой философской основы?
Объявленная переменная без инициализатора получает значение, undefined
потому что вы никогда не говорили ничего о том, что было предполагаемым значением.
let supervisor;
assert(supervisor === undefined);
Свойство объекта, которое никогда не было установлено, оценивается, undefined
потому что никто никогда ничего не говорил об этом свойстве.
const dog = { name: 'Sparky', age: 2 };
assert(dog.breed === undefined);
null
и undefined
«похожи» друг на друга, потому что так сказал Брендан Эйх. Но они категорически не равны друг другу.
assert(null == undefined);
assert(null !== undefined);
null
и, к undefined
счастью, есть разные типы. null
принадлежит типу Null
и undefined
типу Undefined
. Это в спецификации, но вы никогда не узнаете об этом из-за typeof
странности, которую я не буду повторять здесь.
Функция, достигающая конца своего тела без явного оператора return, возвращается, undefined
так как вы ничего не знаете о том, что она возвратила.
Кстати, в JavaScript есть и другие формы "небытия" (хорошо бы изучать философию ....)
NaN
ReferenceError
let
или const
определение локальной переменной во временной мертвой зоне и получениеReferenceError
Пустые ячейки в разреженных массивах. Да, они даже undefined
не сравниваются ===
с неопределенными.
$ node
> const a = [1, undefined, 2]
> const b = [1, , 2]
> a
[ 1, undefined, 2 ]
> b
[ 1, <1 empty item>, 2 ]
undefined
, как в let supervisor = undefined
случае.
undefined
только в том случае, если оно не было объявлено или ему еще не было присвоено значение, настолько распространено, и людям очень трудно донести информацию (хотя я продолжаю пытаться). Так много людей мусор JavaScript за то, что как null
и undefined
но эти ценности действительно имеют совершенно разный смысл , и по большей части они работают хорошо с их предполагаемыми значениями (ИМХО конечно).
В JavasSript есть 5 примитивных типов данных String, Number, Boolean, null и undefined. Я попытаюсь объяснить на некотором простом примере
скажем, у нас есть простая функция
function test(a) {
if(a == null){
alert("a is null");
} else {
alert("The value of a is " + a);
}
}
также в приведенной выше функции if (a == null) совпадает с if (! a)
Теперь, когда мы вызываем эту функцию без передачи параметра а
test(); it will alert "a is null";
test(4); it will alert "The value of a is " + 4;
также
var a;
alert(typeof a);
это даст неопределенное; мы объявили переменную, но мы не присваивали ей значения; но если мы напишем
var a = null;
alert(typeof a); will give alert as object
Так что null это объект. таким образом, мы присвоили нулевое значение «а»
Для undefined
типа, существует один и только одно значение: undefined
.
Для null
типа, существует один и только одно значение: null
.
Таким образом, для них обоих метка является как ее типом, так и значением.
Разница между ними. Например:
null
это пустое значениеundefined
пропущенное значениеИли:
undefined
еще не имел значенияnull
имеет значение и больше неНа самом деле, null
это специальное ключевое слово , а не идентификатор, и, следовательно, вы не можете рассматривать его как переменную для назначения.
Тем не менее, undefined
это идентификатор . Однако в non-strict
режиме и strict
режиме вы можете создать локальную переменную с именем undefined. Но это одна ужасная идея!
function foo() {
undefined = 2; // bad idea!
}
foo();
function foo() {
"use strict";
undefined = 2; // TypeError!
}
foo();
Когда вы объявляете переменную в javascript, ей присваивается значение undefined
. Это означает, что переменная не тронута и ей может быть присвоено любое значение в будущем. Это также подразумевает, что вы не знаете значение, которое эта переменная будет содержать во время объявления.
Теперь вы можете явно назначить переменную null
. Это означает, что переменная не имеет никакого значения. Например - Некоторые люди не имеют отчества. Поэтому в таком случае лучше присвоить значение null переменной middlename объекта person.
Теперь предположим, что кто-то обращается к переменной middlename вашего объекта person, и она имеет значение undefined
. Он не знал бы, забыл ли разработчик инициализировать эту переменную или она не имеет никакого значения. Если оно имеет значение null
, то пользователь может легко сделать вывод, что middlename не имеет никакого значения и не является нетронутой переменной.
null и undefined оба используются для представления отсутствия некоторого значения.
var a = null;
А инициализируется и определяется.
typeof(a)
//object
нуль - это объект в JavaScript
Object.prototype.toString.call(a) // [object Object]
var b;
b не определено и неинициализировано
неопределенные свойства объекта также не определены. Например, «x» не определен для объекта c, и если вы попытаетесь получить доступ к cx, он вернет undefined.
Обычно мы присваиваем значение null переменным, которые не определены.
Object.prototype.toString.call(null); // "[object Null]"
Тщательная статья Пера Райана Морра на эту тему ...
«Как правило, если вам нужно присвоить ненулевое значение переменной или свойству, передать его функции или вернуть его из функции, то null - почти всегда лучший вариант. Проще говоря, JavaScript использует undefined, и программисты должны использовать ноль. "
И ноль, и неопределенный в JavaScript указывают на отсутствие значения.
var a = null; //variable assigned null value var b; // undefined
Несмотря на то, что оба существуют для отсутствия значения, но: Undefined фактически означает, что переменная не инициализирована. Функции, которые ничего не возвращают, и параметры функции, для которых не указано значение, возвращается неопределенное значение. Используйте оператор строгого равенства ===, чтобы различать пустое и неопределенное.
Ссылка: http://www.thesstech.com/javascript/null-and-undefined
Хорошо, мы можем запутаться , когда мы слышим о null
и undefined
, но давайте начнем это просто, они оба falsy и во многом похожи, но странно часть JavaScript, сделать их несколько существенных отличий, например, TypeOf null
это в 'object'
то время как TypeOf undefined
является 'undefined'
,
typeof null; //"object"
typeof undefined; //"undefined";
Но если вы проверите их, ==
как показано ниже, вы увидите, что они оба ложные :
null==undefined; //true
Также вы можете присвоить null
свойству объекта или примитиву, в то время как это undefined
может быть просто достигнуто, не назначая ничего.
Я создаю быстрое изображение, чтобы показать различия для вас с первого взгляда.
Поскольку typeof возвращает undefined, undefined - это тип, в котором инициализатор указывает на то, что null указывает, что переменная указывает на отсутствие объекта (практически все в Javascript является объектом).
В JavaScript все переменные хранятся в виде пар ключ-значение. Каждая переменная хранится как переменная_имя: переменная_значение / ссылка .
undefined означает, что переменной в памяти дан пробел, но ей не присвоено значение. Рекомендуется не использовать этот тип в качестве задания.
В таком случае, как обозначить, когда вы хотите, чтобы переменная была без значения на более позднем этапе кода? Вы можете использовать тип null , который также является типом, который используется для определения того же самого, отсутствия значения, но это не то же самое, что и undefined, так как в этом случае у вас фактически есть значение в памяти. Это значение равно нулю
Оба похожи, но использование и смысл разные.
Я хочу добавить очень тонкую разницу между ними, null
и undefined
это полезно знать, когда вы пытаетесь изучить Vanilla JavaScript (JS) с нуля:
null
является зарезервированным ключевым словом в JS, а undefined
является переменной глобального объекта среды выполнения, в которой вы находитесь.При написании кода это различие не идентифицируется как оба, null
и undefined
они всегда используются в RHS оператора JavaScript. Но когда вы используете их в LHS выражения, вы можете легко наблюдать эту разницу. Поэтому интерпретатор JS интерпретирует приведенный ниже код как ошибку:
var null = 'foo'
Это дает ниже ошибку:
Uncaught SyntaxError: неожиданный нулевой токен
Хотя приведенный ниже код работает успешно, хотя я не рекомендую делать это в реальной жизни:
var undefined = 'bar'
Это работает, потому что undefined
это переменная в глобальном объекте (объект окна браузера в случае JS на стороне клиента)
undefined='bar'
на самом деле не присваивает значение undefined
(которое является неизменным), оно просто не сбивает с толку ошибку.
Разница между undefined
и null
минимальна, но есть разница. Переменная, значение которой undefined
никогда не было инициализировано. Переменная, чье значение null
было явно задано значение null
, что означает, что переменная была явно установлена, чтобы не иметь значения. Если вы сравните undefined
и null
с помощью null==undefined
выражения, они будут равны.
null==undefined
это true
только из - за неявной (или эквивалентный термин в JS). Очевидно, null===undefined
это false
потому , что использование, когда вы используете ===
его, также сравнивает тип .
В основном, неопределенный - это глобальная переменная, которую javascript создает во время выполнения, независимо от того, означает ли null, что значение не присвоено переменной (фактически, null сам по себе является объектом).
Давайте возьмем пример:
var x; //we declared a variable x, but no value has been assigned to it.
document.write(x) //let's print the variable x
Неопределенный , что вы получите в качестве вывода.
Сейчас же,
x=5;
y=null;
z=x+y;
и вы получите 5 в качестве выхода. Это основное различие между неопределенным и нулевым
null - это значение присваивания, которое используется с переменной для представления значения (это объект).
undefined - это переменная, которой не присвоено никакого значения, поэтому JavaScript назначит ей неопределенное значение (это тип данных).
undeclared - если переменная вообще не создается, она называется undeclared.
Проверь это. Результат стоит тысячи слов.
var b1 = document.getElementById("b1");
checkif("1, no argument" );
checkif("2, undefined explicitly", undefined);
checkif("3, null explicitly", null);
checkif("4, the 0", 0);
checkif("5, empty string", '');
checkif("6, string", "string");
checkif("7, number", 123456);
function checkif (a1, a2) {
print("\ncheckif(), " + a1 + ":");
if (a2 == undefined) {
print("==undefined: YES");
} else {
print("==undefined: NO");
}
if (a2 === undefined) {
print("===undefined: YES");
} else {
print("===undefined: NO");
}
if (a2 == null) {
print("==null: YES");
} else {
print("==null: NO");
}
if (a2 === null) {
print("===null: YES");
} else {
print("===null: NO");
}
if (a2 == '') {
print("=='': YES");
} else {
print("=='': NO");
}
if (a2 === '') {
print("==='': YES");
} else {
print("==='': NO");
}
if (isNaN(a2)) {
print("isNaN(): YES");
} else {
print("isNaN(): NO");
}
if (a2) {
print("if-?: YES");
} else {
print("if-?: NO");
}
print("typeof(): " + typeof(a2));
}
function print(v) {
b1.innerHTML += v + "\n";
}
<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>
Смотрите также:
Ура!
isNaN(null)
возвращается false
- что удивило меня.
Оба специальных значения подразумевают пустое состояние.
Основное отличие состоит в том, что undefined представляет значение переменной, которая еще не была инициализирована, а null представляет намеренное отсутствие объекта.
Номер переменной определен, однако ему не присваивается начальное значение:
let number;
number; // => undefined
числовая переменная не определена, что ясно указывает на неинициализированную переменную
Та же неинициализированная концепция возникает при доступе к несуществующему свойству объекта:
const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined
Поскольку свойство lastName не существует в obj, JavaScript правильно оценивает obj.lastName как неопределенное.
В других случаях вы знаете, что переменная ожидает, чтобы содержать объект или функцию для возврата объекта. Но по какой-то причине вы не можете создать экземпляр объекта. В таком случае ноль является значимым индикатором отсутствующего объекта.
Например, clone () - это функция, которая клонирует простой объект JavaScript. Ожидается, что функция вернет объект:
function clone(obj) {
if (typeof obj === 'object' && obj !== null) {
return Object.assign({}, obj);
}
return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15); // => null
clone(null); // => null
Однако clone () может быть вызван с необъектным аргументом: 15 или null (или, как правило, примитивное значение, null или undefined). В таком случае функция не может создать клон, поэтому она возвращает ноль - индикатор отсутствующего объекта.
Оператор typeof делает различие между двумя значениями:
typeof undefined; // => 'undefined'
typeof null; // => 'object'
Оператор строгого качества === правильно отличает неопределенное от нулевого:
let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false
В дополнение к другому значению есть и другие различия:
const { a = "default" } = { a: undefined }; // a is "default"
const { b = "default" } = { b: null }; // b is null
null
но опускаетundefined
const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
console.log(json); // prints {"nullValue":null}
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" instead of "null"
Если переменная не инициализирована, то она не определена. undefined не является объектом. Пример: var MyName; console.log (typeof MyName);
Проверьте консольный журнал в инструменте разработки, он будет напечатан как неопределенный.
null - это объект. Если вы хотите, чтобы какая-либо переменная была нулевой, тогда используется значение null. Переменная null существует, но значение неизвестно. Ее следует назначать переменной программно. ноль не инициализируется автоматически.
Пример: var MyName = null; console.log (typeof MyName); Проверьте журнал csole в инструменте разработки, это будет объект.
null
в JavaScript есть значение?