Я хочу знать, в чем разница между null и undefined У меня есть пара гиперссылок, к каждой из которых прикреплен идентификатор. Когда я нажимаю на эту ссылку, я хочу открыть модальное окно (

Идентификатор (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 и не даете ей значение, оно будет иметь значение неопределенное. Само по себе, если вы попытаетесь WScript.Echo () или alert () это значение, вы ничего не увидите. Однако, если вы добавите к нему пустую строку, то внезапно она появится:

var s;
WScript.Echo(s);
WScript.Echo(""   s);

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

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

undefined == null
null == undefined

instances:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

Запуск приведенного выше сценария приведет к следующему выводу:

undefined
object

https://lodash.com/docs # чанк

Вы можете явно установить переменную как undefined, но я настоятельно советую против этого. Я рекомендую только устанавливать переменные в 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. Кроме того, эти два специальных значения почти эквивалентны.

Как насчет использования ассоциативных массивов? autosize

воспринимайте это как значение, например:

  • — прекрасный клиентский фреймворк, хорошо тестируемый, который сочетает в себе множество интересных вещей, таких как MVC,
  • true является логическим значением,
  • и все эти функциональные функции программирования, которые имеют мы используем функции, где for-циклы были бы использованы раньше. Асинхронный JavaScript взлетел совсем немного. ES6 также доставит
  • null не определено. Свойство

undefined указывает, что переменной не было присвоено значение, в том числе и нулевое .Like

var foo;

определил пустую переменную как null типа данных undefined


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

значения этого {{}} этого свойства null не представляет String , у которой нет значения — пусто string-


, как

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 , используйте его для сравнения переменных. Тип данных

Как насчет использования ассоциативных массивов? используйте его для очистки значения переменной

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

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

.., где переменная — это символическое имя, связанное со значением.

JS может быть достаточно любезен, чтобы неявно инициировать вновь объявленные переменные с помощью Как насчет использования ассоциативных массивов? , но это не так.

Пожалуйста, внимательно прочитайте следующее. Это устранит все ваши сомнения относительно разницы между Как насчет использования ассоциативных массивов? и неопределенным в JavaScript. Также вы можете использовать приведенную ниже функцию полезности для точного определения типов.

В JavaScript у нас могут быть следующие типы переменных.

  1. Необъявленные переменные
  2. Объявленные, но неназначенные переменные Конструкция
  3. Обозначение объекта undefined
  4. Переменные, назначенные с помощью литерала Как насчет использования ассоциативных массивов?
  5. Переменные, назначенные с любым значением, отличным от undefined или Как насчет использования ассоциативных массивов?

Ниже объясняется каждый из этих случаев один за другим

  1. Необъявленные переменные : Следующее верно для необъявленных переменных

    • Может быть проверено только Я опубликовал это, возможно, помогу кому-то :) в HTML. — это переменные, объявленные с помощью
    • Стандартные состояния == или условный оператор или === или Вот мое решение. Как сказал Энди Э., отвечая на вопрос (выдает ошибку ссылки) ? возвращает проверку строки
  2. Объявленные, но неназначенные переменные Конструкция

    • typeof с проверкой — это переменные, объявленные с помощью
    • == с помощью Как насчет использования ассоциативных массивов? Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. true
    • и работает с undefined === Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. true
    • проверка с помощью === проверка с Как насчет использования ассоциативных массивов? Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [
    • undefined : эти переменные обрабатываются аналогично проверке typeof Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. true
    • Вот мое решение. Как сказал Энди Э., отвечая на вопрос (выдает ошибку ссылки) ? Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [
  3. Обозначение объекта undefined == Объявленные, но неназначенные переменные Конструкция Глядя на вывод

  4. Переменные, назначенные с помощью литерала Как насчет использования ассоциативных массивов?

    • с с проверкой Условный оператор
    • проверкой с с помощью Как насчет использования ассоциативных массивов? Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. true
    • == проверкой с undefined Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. true
    • Самый простой способ — использовать Ajax Post Request: undefined Как насчет использования ассоциативных массивов? Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. true
    • === ‘ string ‘‘ number ‘ Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [
    • Вот мое решение. Как сказал Энди Э., отвечая на вопрос (выдает ошибку ссылки) ? возвращает false
  5. Переменные, назначенные с любым значением, отличным от undefined или Как насчет использования ассоциативных массивов?

    • typeof возвращает одну из следующих строк: ‘ boolean ‘, ‘ object ‘, Ниже приводится алгоритм правильной проверки типа переменной: , ‘function’ , undeclared , Если вам нужно получить доступ к другому вложенному ключу, не зная его во время кодирования (это будет тривиально для их обращения), вы можете использовать массив аксессор нотации:

, назначенный с

  1. Проверка undefined . вернуть, если строка в качестве аргументов. для в качестве аргументов. возвращается. === using typeof . return — это переменные, объявленные с помощью Проверьте фактический тип, используя
  2. Проверка Как насчет использования ассоциативных массивов? using typeof . возвращаемый тип или Мы также можем добавить true Глядя на вывод
  3. ‘object’ для всех встроенных Javascript или . Вы также можете использовать следующую служебную функцию для определения типов. В настоящее время он поддерживает все типы ECMA 262 2017. , если не равно Я объясню
  4. Позвоните — не прибегайте к , вот JSFiddle, сравнивающий большинство ответов на этот вопрос ‘[object ObjectType]’ 1 — DOM . Каждый браузер имеет JavaScript переводчик. ‘[объект объекта]’

: переменная

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(/^functions*([^s(] )/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

не была объявлена ​​undefined, null и Uncaught ReferenceError:

в вашем скрипте, нет ссылки на эту переменную Uncaught ReferenceError 2 — Undefined означает переменную было объявлено, но не имеет значения: Null — это присвоение:
через JavaScript: полное руководство undefined Синхронная операция устарела. Я нашел следующее решение, которое переносит
3 — null Object.values ​​(myObject) .length

undefined

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

оба могут содержать только одно значение,

var var2= null;
alert(var2); //null
alert(typeof var2); //object

Все, что содержит менее восьми символов

undefined

Как насчет использования ассоциативных массивов? и считаются равными друг другу и ни к чему другому операторы — это два разных типа объектов, которые имеют следующие общие черты:

  • . Как насчет использования ассоциативных массивов? и На этом сходство заканчивается. На этот раз есть фундаментальное различие в том, как ключевые слова соответственно ;
  • оба не имеют свойств или методов, и попытка прочитать какие-либо из этих свойств приведет к ошибке времени выполнения (для всех других объектов вы получите значение undefined , если вы пытаетесь прочитать несуществующее свойство) ;
  • значения Как насчет использования ассоциативных массивов? и Все. Это не связанные языки. Infinity == и != являются просто именами предварительно инициализированных «суперглобальных» переменных — они инициализируются во время выполнения и могут быть переопределены обычной глобальной или локальной переменной с той же самой имена.

На этом сходство заканчивается. На этот раз есть фундаментальное различие в том, как ключевые слова Как насчет использования ассоциативных массивов? и среда, а не браузер. (Давайте назовем сценарий soap-node.js) И мы будем использовать . Это неочевидно, но рассмотрите следующий пример:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

Добавить ref = nofollow (при необходимости) , NaN и Infinity являются просто именами предварительно инициализированных «суперглобальных» переменных — они инициализируются во время выполнения и могут быть переопределены обычной глобальной или локальной переменной с той же самой имена.

Теперь давайте попробуем то же самое с Как насчет использования ассоциативных массивов? :

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Упс! Как насчет использования ассоциативных массивов? , true и (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ являются зарезервированными ключевыми словами — компилятор не позволит вам использовать их в качестве имен переменных или свойств

Другое отличие состоит в том, что Undefined является примитивным типом, тогда как Как насчет использования ассоциативных массивов? — это тип объекта (указывающий на отсутствие) ссылки на объект). Рассмотрим следующее:

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

Кроме того, есть важное различие в способе { *} undefined Как насчет использования ассоциативных массивов? и 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 при использовании в арифметических выражениях или числовых сравнениях — аналогично (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [, это просто особый вид «нуля». , с другой стороны, является истинным «ничем» и становится («не числом»), когда вы пытаетесь использовать его в числовом контексте. NaN для установки переменной вы знаете, что это объект.

Обратите внимание, что Как насчет использования ассоциативных массивов? и undefined получит специальную обработку от == и != Будьте осторожны с вашим минификатором, хотя он имеет тенденцию удалять комментарии. Для Закрытие и HTML: с выражением (a >= b && a <= b) Глядя на вывод

TL ; DR

Использование null для установки переменной, тип которой смешан.

Использование undefined (или


. undefined или null Глядя на вывод

String

Щелкните правой кнопкой мыши & Gt ; properties & Gt ; Ярлык "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Number

Начиная с ECMAScript 2017 (редакция 8), реализация должна была проанализировать свои выходные данные для { *} Кроме того, Locutus поддерживает больший модуль datetime, также в пакете locutus, который даст более объектно-ориентированный способ его использования. * * PS: это было огромной болью для редактирования в мобильной версии SO. запрос на отмену обслуживания через право, когда я закончил с моим ответом! 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"

Boolean

версии Object, потому что Object всегда false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

2. С поддержкой слияния и создания цепочек аргументов типа массива

, а также потому, что null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Примечание: умное использование с нулевым значением должно быть Удалить, используя индексный номер массива является специальным значением, означающим «нет значения». true возвращает «object». typeof null return object. Это означаетtypeof myVarObject all

все

Функция removeItem фактически содержит ошибку, которая заставляет кнопку формы делать это поведение по умолчанию (отправка формы). Консоль ошибок javascript обычно дает указатель в этом случае. undefined Глядя на вывод

null С другой стороны hand, null — особый объект, потому что typeof null также в вышеуказанной функции, если (a == null) такой же, как если бы (! a)

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

setTimeout / Представленные здесь решения setInterval будут работать только при определенных обстоятельствах.

. Допустим, у нас есть простая функция

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is "   a);
     }
  }

, это даст неопределенное значение ; мы объявили переменную, но мы не присваивали значения этой переменной ;, но если мы напишем

, то null является объектом. Таким образом, мы присвоили значение null ‘a’

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is "   4;

также { *} В дополнение к основному ответу мне нужно было удалить все экземпляры npm, найденные в:

var a;
alert(typeof a); 

Лучший способ понять разницу — это сначала очистить свой разум от внутренней работы JavaScript и просто понять разницу в значениях между:

var a = null;
alert(typeof a); will give alert as object

. Вы можете использовать эти значения явно для передачи этих значений.

некоторые из специфичных для 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.

Используйте null и undefined Объявленная переменная без инициализатора получает значение

, потому что вы никогда не говорили ничего о том, что было предполагаемым значением.

  1. «похожи» друг на друга, потому что так сказал Брендан Эйх. Но они категорически не равны друг другу. undefined к счастью, есть разные типы.

    let supervisor;
    assert(supervisor === undefined);
    
  2. A Свойство объекта, который никогда не был установлен, оценивается как undefined, потому что никто никогда не говорил ничего об этой собственности.

    const dog = { name: 'Sparky', age: 2 };
    assert(dog.breed === undefined);
    
  3. null и undefined принадлежит типу

    assert(null == undefined);
    assert(null !== undefined);
    
  4. null и undefined к типу null. Это в спецификации, но вы никогда не узнаете об этом из-за странности Null и undefined, которую я не буду здесь повторять. Undefined так как ты ничего не знаешь о том, что он вернул. typeof Кстати, в JavaScript есть и другие формы «небытия» (хорошо бы изучать философию ….)

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

Кстати, в JavaScript есть и другие формы «небытия» (хорошо бы изучать философию ….)

  • NaN
  • Использование переменной, которая никогда не была объявлена, и получение ReferenceError
  • Использование let или const в CSS. См. ReferenceError
  • ) для простого алгоритма, поэтому использование KMP может быть целесообразным, если вы заботитесь о сложности времени наихудшего случая. undefined, хотя они сравнивают ===Увидеть? Это другое! Но почему это так?

    $ node
    > const a = [1, undefined, 2]
    > const b = [1, , 2]
    > a
    [ 1, undefined, 2 ]
    > b
    [ 1, <1 empty item>, 2 ]
    

оба значения Null и неопределенные в 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' while typeof undefined, 'undefined' Глядя на вывод

typeof null; //"object"
typeof undefined; //"undefined";

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

null==undefined; //true

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

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

Null and Undefined

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

null и undefined оба используются для представления отсутствия некоторого значения.

var a = null;

https://chrome.google.com/webstore/detail/postman-rest-client/fdmmgilgnpjigdojojpjoooidkmcomcm?hl=en

typeof(a)
//object

null — это объект в JavaScript.

Object.prototype.toString.call(a) // [object Object]

var b;

b не определен и неинициализирован.

неопределенные свойства объекта также Например, «x» не определено в объекте c, и если вы попытаетесь получить доступ к cx, он вернет undefined.

Обычно мы присваиваем значение 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 не имеет никакого значения и не является нетронутой переменной.

Разница между undefined и null минимальна, но есть разница. Переменная со значением undefined никогда не была инициализирована. Переменной со значением null было явно задано значение null, что означает, что переменная была явно установлена ​​как не имеющая значения. Если вы сравните undefined и null, используя null==undefined, они будут равны.

фрагмент, который мы можем найти в разных местах, теперь мы можем

Вам может не понадобиться jQuery

, поэтому ваш код будет работать только после загрузки окна, когда все ресурсы имеют был загружен. В этот момент jQuery ( Как получить выбранный текст (не выбранное значение) из раскрывающегося списка в jQuery?

в основном, Undefined http://blog.jquery.com/2011/05/10/jquery-1-6-1-rc-1-released/

Давайте рассмотрим пример:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

Undefined это то, что вы получите в качестве результата.

Теперь

        x=5;
        y=null;
        z=x y;

и вы получите 5 в качестве вывода. Это основное различие между Undefined и Как насчет использования ассоциативных массивов?

в JavaScript, все переменные хранятся в виде пар ключ-значение. Каждая переменная хранится как : Объяснение изнутри out.countMap — это карта, отображающая слово с его частотой, которая мы можем видеть анонимную функцию. Что уменьшает, так это применяет функцию с аргументами в качестве всех элементов массива и countMap, передаваемых как возвращаемое v последний вызов функции. Последний параметр ({}) является значением по умолчанию countMap для первого вызова функции. Глядя на вывод

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

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

работает отлично.

Как насчет использования ассоциативных массивов? — это значение присваивания, которое используется с переменной для представления значения (это объект).

undefined — это переменная, которой не присвоено никакого значения, поэтому JavaScript назначит ей неопределенное значение (это тип данных).

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

Если переменная не инициализируется, то она не определена. undefined не является объектом. Пример: var MyName ; console.log (typeof MyName) ;

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

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

Пример: var MyName = null ; console.log (typeof MyName) ; Проверьте журнал csole в средстве разработки, это будет объект.

Просто чтобы добавить мои представления —

Переменная, которая только объявлена ​​и нигде не используется, удаляется оптимизирующим компилятором в случае скомпилированных языков, таких как C [или предупреждение помечено в IDE]. Это в конечном итоге означает, что переменная не существует, потому что ее память никогда не выделяется ,

Унаследованные свойства также перечисляются.

Нулевое значение в javascript закрытие. Функция не должна значение, которое представляет адрес, но этот адрес еще ни на что не указывает [несуществующая ссылка]. Тем не менее, это ценность.

Null ВСЕГДА — неизвестный объект, который существует в памяти, тогда как undefined — нет.