在JavaScript中的null和undefined有什么区别？
我想知道在JavaScript中的null和undefined之间有什么区别。
在JavaScript中， undefined表示一个variables已经被声明，但还没有被分配一个值，比如：
var TestVar; alert(TestVar); //shows undefined alert(typeof TestVar); //shows undefined
null是一个赋值。 它可以分配给一个variables作为没有值的表示：
var TestVar = null; alert(TestVar); //shows null alert(typeof TestVar); //shows object
从前面的例子中可以明显看出， undefined和null是两个不同的types： undefined是一个types本身（undefined），而null是一个对象。
null === undefined // false null == undefined // true null === null // true
和
null = 'value' // ReferenceError undefined = 'value' // 'value'
我从这里选了这个
未定义的值是一个variables未被赋值的原始值。
空值是表示空，空或不存在的引用的原始值。
当你通过var声明一个variables而不给它一个值时，它的值将是undefined。 本身，如果你尝试WScript.Echo（）或alert（）这个值，你什么也看不到。 但是，如果你添加一个空白string然后突然出现：
var s; WScript.Echo(s); WScript.Echo("" + s);
您可以声明一个variables，将其设置为null，除非您将“null”打印出来而不是“undefined”，否则行为是相同的。 这确实是一个小小的差异。
你甚至可以比较一个未定义的variables为null，反之亦然，条件成立：
undefined == null null == undefined
然而，它们被认为是两种不同的types。 虽然undefined是一个types本身，空值被认为是一个特殊的对象值。 你可以通过使用typeof（）来看到这个，它返回一个表示variables的一般types的string：
var a; WScript.Echo(typeof(a)); var b = null; WScript.Echo(typeof(b));
运行上面的脚本将导致以下输出：
undefined object
不pipe他们是不同的types，如果你尝试访问任何一个成员，他们仍然会采取相同的行动，例如他们会抛出exception。 使用WSH，你会看到可怕的“'varname'为空或不是对象”，这就是如果你幸运（但这是另一篇文章的主题）。
你可以明确地设置一个variables是不确定的，但我强烈build议反对它。 我build议只设置variables为空，并为您忘记设置的值留下未定义的值。 同时，我真的鼓励你总是设定每一个variables。 JavaScript的作用域链与C风格的语言链有所不同，即使是老手程序员也容易混淆，而将variables设置为null是防止基于它的错误的最好方法。
另一个你会看到未定义的实例是使用delete操作符。 我们这些来自C世界的人可能会错误地将其解释为摧毁一个客体，但事实并非如此。 这个操作的作用是从一个数组或者一个对象的成员中删除一个下标。 对于数组，它不影响长度，而是下标现在被认为是未定义的。
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
阅读未读的下标或成员时，您也将返回undefined。
null和undefined之间的区别是：JavaScript永远不会将任何东西设置为null，这通常是我们所做的。 虽然我们可以将variables设置为undefined，但我们更喜欢null，因为这不是我们所做的事情。 当你debugging这意味着任何设置为null是你自己做，而不是JavaScript。 除此之外，这两个特殊的价值几乎是相等的。
null是指示缺less值的特殊关键字。
把它看作一个价值，就像：
- “foo”是string，
- true是布尔值，
- 1234是号码，
- null是未定义的。
未定义的属性表明一个variables还没有被赋予一个包含null的值。 喜欢
var foo;
定义的空variables是undefined的数据types的undefined
它们都代表一个没有值的variables的值
AND 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用它来比较variables的数据types
null用它来清空一个variables的值
var a = 'javascript'; a = null ; // will change the type of variable "a" from string to object
null ：variables缺less值; 未定义 ：缺lessvariables本身;
..wherevariables是一个与值相关联的符号名称。
JS可能足够隐含地初始化新声明的variables为null ，但它不会。
未定义意味着一个variables已被声明，但没有值：
var var1; alert(var1); //undefined alert(typeof var1); //undefined
空是一项任务：
var var2= null; alert(var2); //null alert(typeof var2); //object
您可能会考虑未定义来表示系统级别的，意外的或错误的值缺失，null表示程序级别，正常或预期的缺失值。
通过JavaScript：权威指南
我将解释undefined ， null和Uncaught ReferenceError ：
1 – Uncaught ReferenceError ：variables没有在脚本中声明 ，没有引用这个variables
2 – undefined ：已声明variables但未初始化
3 – null ：声明的variables，是一个空值
null和undefined是两个不同的对象types，它们具有以下共同之处：
- 两者都只能保持一个值，分别为null和undefined ;
- 两者都没有属性或方法，试图读取任何一个属性将导致运行时错误（对于所有其他对象，如果您尝试读取不存在的属性，您将获得未定义的值）;
- 值null和undefined被认为是相等的，没有别的
==和!=运算符。
相似之处在此结束。 有一次，关键字null和undefined的实现方式有一个根本的区别。 这并不明显，但请考虑以下示例：
var undefined = "foo"; WScript.Echo(undefined); // This will print: foo
未定义 ， NaN和Infinity只是预初始化的“超全局”variables的名称 – 它们在运行时被初始化，并且可以被具有相同名称的普通全局或局部variables覆盖。
现在，让我们用null来尝试相同的事情：
var null = "foo"; // This will cause a compile-time error WScript.Echo(null);
哎呀！ null ， true和false是保留关键字 – 编译器不会让你用它们作为variables或属性名称
另一个区别是undefined是一个基本types，而null是一个对象types（表示对象引用的缺失 ）。 考虑以下几点：
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 (!!!)
当在算术expression式或数字比较中使用时， null变成0 ，类似于false ，它基本上只是一种特殊的“零”。 未定义 ，另一方面，是一个真正的“没有”，并成为NaN （“不是一个数字”），当你尝试在数字上下文中使用它。
请注意， null和undefined从==和!=运算符接受特殊处理，但可以使用expression式(a >= b && a <= b)testinga和b的真正数值相等。
null是一个特殊的值，意思是“没有价值”。 null是一个特殊的对象，因为typeof null返回“object”。
另一方面， undefined表示该variables没有被声明，或没有被赋予一个值。
来源 。
请仔细阅读以下内容。 它将消除所有关于JavaScript中的null和undefined之间的区别的怀疑。 您也可以使用下面给出的效用函数来精确确定types。
在JavaScript中，我们可以有以下types的variables。
- 未声明的variables
- 声明但未分配的variables
- 赋值为文字的variables未定义
- variables赋值为null
- variables分配了除undefined或null之外的任何内容
下面逐一解释这些情况
-
未声明variables ：以下情况适用于未申报variables
- 只能通过typeof（）来检查，返回string'undefined'
- 不能用==或===或if或条件运算符检查吗？ （引发参考错误）
-
声明但未分配的variables
- typeof返回string'undefined'
- ==用null检查返回true
- ==用undefined检查返回true
- ===检查null返回false
- ===检查与undefined返回true
- 如果还是有条件的话？ 返回false
-
variables赋值为 undefined ：这些variables的处理方式与声明但未赋值的variables类似。
-
variables赋值为 null
- typeof返回string'object'
- ==用null检查返回true
- ==用undefined检查返回true
- ===检查null返回true
- ===检查undefined返回false
- 如果还是有条件的话？ 返回false
-
variables分配了除 undefined或null 以外的任何内容
- typeof返回下列string之一： 'string' ， 'number' ， 'boolean' ， 'function' ， 'object' ， 'symbol'
以下提供了对variables进行正确types检查的algorithm：
- 检查未申报 / 未分配 /使用typeof 分配 未定义 。 返回string'undefined'返回。
- 使用===检查null 。 如果返回“null”，则返回true 。
- 使用typeof检查实际types。 返回types如果不等于'object'
- 调用Object.prototype.toString.call（o）来确定实际的对象types。 它将为所有内置的Javascript或DOM定义的对象返回一个types为“[object ObjectType]”的string。 对于用户定义的对象，它返回“[object Object]”
您还可以使用以下实用程序function来确定types。 目前它支持所有ECMA 262 2017types。
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 }
在JavasSript中有5个原始数据types：String，Number，Boolean，null和undefined。 我会试着用一个简单的例子来解释
可以说我们有一个简单的function
function test(a) { if(a == null){ alert("a is null"); } else { alert("The value of a is " + a); } }
如果（a == null）与if（！a）相同，
现在当我们调用这个函数而不传递参数a时
test(); it will alert "a is null"; test(4); it will alert "The value of a is " + 4;
也
var a; alert(typeof a);
这将给未定义的; 我们已经声明了一个variables，但是我们还没有赋予这个variables任何值。 但如果我们写
var a = null; alert(typeof a); will give alert as object
所以null是一个对象。 在某种程度上，我们已经赋值为'a'
TL;博士
使用null来设置一个variables，你知道它是一个对象。
使用undefined来设置一个混合types的variables。
这是我对5个基本types和对象types的使用，解释了undefined或null “用例”之间的区别。
串
如果你知道一个variables只是一个string，而所有的生命周期，按照惯例，你可以将它初始化为"" ：
("") ? true : false; // false typeof ""; // "string"; ("Hello World") ? true : false; // true typeof "Hello World"; // "string"
数
如果你知道一个variables只是一个数字，而所有的生命周期，按照惯例，你可以初始化为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"
布尔
如果你知道一个variables只是一个布尔值，而所有的生命周期，按照惯例，你可以初始化它为false ：
(false) ? true : false; // false typeof false; // "boolean"; (true) ? true : false; // true typeof true; // "boolean"
目的
如果你知道一个variables只是一个对象，而所有的生命周期，按照惯例，你可以初始化它为null ：
(null) ? true : false; // false typeof null; // "object"; ({}) ? true : false; // true typeof {}; // "object"
注意：closuresnull的智能用法是成为对象的虚假版本，因为Object始终为true ，并且因为typeof null返回object 。 这意味着typeof myVarObject为Object和nulltypes返回一致的值。
所有
如果你知道一个variables有一个混合types（任何types，而所有的生命周期），按照惯例，你可以初始化它，以undefined 。
null是一个语言关键字，它的计算结果是一个通常用于表示缺less值的特殊值。 在null上使用typeof运算符返回string“object”，指示null可以被认为是指示“无对象”的特殊对象值。 然而在实践中，null通常被认为是它自己types的唯一成员，它可以用来表示数字和string以及对象的“无价值”。 大多数编程语言与JavaScript的null值相当：您可能熟悉它为null或nil。
JavaScript也有第二个值，表示没有价值。 未定义的值代表更深层次的缺席。 这是尚未初始化的variables的值，以及在查询不存在的对象属性或数组元素的值时获得的值。 未定义的值也是由没有返回值的函数和没有参数提供的函数参数的值返回的。 undefined是一个预定义的全局variables（不是像null这样的语言关键字），被初始化为未定义的值。 在ECMAScript 3中，undefined是一个读/写variables，可以设置为任何值。 该错误在ECMAScript 5中得到了纠正，并且在该版本的语言中，undefined是只读的。 如果将typeof运算符应用于未定义的值，则返回“undefined”，表示此值是特殊types的唯一成员。
尽pipe存在这些差异，null和undefined都表示没有价值，并且通常可以互换使用。 等号运算符==认为它们是平等的。 （使用严格的相等运算符===来区分它们。）两者都是虚假值 – 当需要布尔值时，它们的行为类似于假。 null或undefined都没有任何属性或方法。 其实使用。 或[]访问这些值的属性或方法会导致TypeError。
您可能会考虑未定义来表示系统级别的，意外的或错误的值缺失，null表示程序级别，正常或预期的缺失值。 如果您需要将这些值中的一个赋值给variables或属性，或者将这些值中的一个赋值给函数，那么null几乎总是正确的select。
JavaScript中的Null和undefined都表示没有价值。
var a = null; //variable assigned null value var b; // undefined尽pipe两者都存在缺less价值，但是：未定义实际上意味着该variables未被初始化。 没有返回任何值和函数参数的函数，返回未定义的值。 使用严格的相等运算符===区分null和undefined。
参考： http ： //www.thesstech.com/javascript/null-and-undefined
好的，当我们听到null和undefined时候，我们可能会感到困惑，但是让我们从简单的开始，它们在很多方面都是谬误和相似的，但是JavaScript的怪异部分，使它们有一些显着的差异，例如typeof null是'object'而typeof undefined是'undefined' 。
typeof null; //"object" typeof undefined; //"undefined";
但是如果你用==来检查它们，你会发现它们都是虚假的：
null==undefined; //true
您也可以将null指定给对象属性或原语，而undefined可以简单地通过不分配给任何东西来实现。
我创build了一个快速的图像来一目了然地显示你的差异。
由于typeof返回undefined，undefined是一个types，其中null是一个初始值设定项，表示variables指向没有对象（事实上Javascript中的所有东西都是一个对象）。
null和undefined都被用来表示没有某个值。
var a = null;
a被初始化和定义。
typeof(a) //object
null是JavaScript中的一个对象
Object.prototype.toString.call(a) // [object Object] var b;
b是未定义的和未初始化的
未定义的对象属性也是未定义的。 例如，“x”没有在对象c上定义，如果你尝试访问cx，它将返回undefined。
一般来说，我们将null赋值给未定义的variables。
对于undefinedtypes，只有一个值： undefined 。
对于nulltypes，只有一个值： null 。
所以对他们来说， 这个标签既是它的types，也是它的价值。
他们之间的差异。 例如：
-
null是一个空值 -
undefined是缺less的值
要么：
- 尚未
undefined尚未有价值 -
null有一个值，现在不在了
实际上， null是一个特殊的关键字 ，而不是一个标识符，因此你不能把它当作一个variables来分配给它。
但是， undefined是一个标识符 。 然而，在non-strict模式和strict模式下，都可以创build未定义名称的局部variables。 但这是一个可怕的想法！
function foo() { undefined = 2; // bad idea! } foo(); function foo() { "use strict"; undefined = 2; // TypeError! } foo();
null – 这是一个赋值。 哪个用于variables来表示没有值。 （它的一个对象）
undefined – 这是一个没有赋值的variables。 所以JavaScript会分配一个未定义的。 （其数据types）
未声明 – 如果variables没有被创build，则被称为未声明。
undefined和null之间的区别是最小的，但是有区别。 其值undefinedvariables从未被初始化。 值为null的variables被显式赋值为null ，这意味着该variables被显式设置为没有值。 如果使用null==undefinedexpression式比较undefined和null ，则它们将相等。
Per Ryan Morr关于这个主题的彻底的文章…
“一般来说，如果你需要给一个variables或属性赋一个非值，把它传递给一个函数，或者从一个函数中返回，那么null几乎总是最好的select。简单地说，JavaScript使用了未定义，程序员应该使用null“。
参见探索空的和未定义的永恒深渊
对于JavaScript，null表示对象，undefined表示variables，属性和方法。
为空，必须定义一个对象，否则将是未定义的。
如果你想testing一个对象是否存在，如果这个对象是未定义的，这将会抛出一个错误：
不正确：
if (myObj !== null && typeof myObj !== "undefined")
因此，您必须首先testingtypeof（）：
正确：
if (typeof myObj !== "undefined" && myObj !== null)
当一个值为null时，它就是一无所有，并且不包含任何内容。 空值或variables仍然满; 它充满了空虚。 空虚不同于空，这是没有什么。 例如，定义一个variables并将其值设置为空string如下所示：
var myVariable = '';
variablesmyVariable是空的，但它不是null。
Undefined是一个状态，有时用值来表示一个尚未包含值的variables。 如var abcd ; 。 这个状态与null不同，尽pipenull和undefined都可以用相同的方式进行计算。
- 未定义表示一个variables已被声明，但还没有被赋值。
- null是一个赋值。 它可以被分配给一个variables作为没有值的表示。
- undefined和null是两种截然不同的types：
undefined是一个types本身（未定义），而null是一个对象。
- 未赋值的variables由JavaScript初始化，缺省值为undefined。
- JavaScript永远不会将值设置为null。 这必须以编程方式完成。
基本上， Undefined是javascript在运行时创build的全局variables，null表示没有赋值给variables（实际上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作为输出。 这是Undefined和null之间的主要区别
在JavaScript中，所有variables都存储为键值对。 每个variables存储为variable_name：variable_value / reference 。
未定义意味着一个variables在内存中被赋予了空间，但是没有赋值。 作为最佳实践，您不应该将此types用作任务。
在这种情况下，如何表示何时在代码的后面某个variables没有值？ 你可以使用nulltypes，它也是一个用于定义相同的东西的types，不存在值，但它与undefined不同，因为在这种情况下，你实际上在内存中有值。 该值为空
两者都是相似的，但用法和含义是不同的。
当你在javascript中声明一个variables时，它被赋值为undefined 。 这意味着该variables是未触及的，将来可以赋予任何值。 这也意味着你不知道这个variables在宣布的时候将会持有的价值。
现在你可以明确地分配一个variablesnull 。 这意味着该variables没有任何价值。 例如 – 有些人没有中间名。 所以在这种情况下，最好把null值赋给一个person对象的middlenamevariables。
现在假设有人正在访问你的person对象的middlenamevariables，它的值是undefined 。 他不知道开发者忘记初始化这个variables还是没有任何价值。 如果它的值为null ，则用户可以容易地推断中间名不具有任何值，并且它不是未触摸的variables。
如果一个variables没有被初始化，那么它是未定义的。 未定义不是一个对象。 例如：var MyName; console.log（typeof MyName）;
检查控制台login开发工具，它将被打印为未定义。
null是一个对象。如果你想要一些variables为null，则使用null。variables存在，但值不知道。它应该在语法上被分配给一个variables。 null不会自动初始化。
示例：var MyName = null; console.log（typeof MyName）; 检查开发工具中的csole日志，这将是一个对象。
只是添加我的意见 –
只有在C ++这样的编译语言的情况下（或者在IDE中标记了一个警告），才会被一个优化的编译器删除一个只能被声明并且从不在任何地方使用的variables。 它最终意味着variables不存在，因为它的内存永远不会被分配。
在JavaScript解释器的情况下，[我猜]一个variables被视为只存在的地方给它的价值。 在此之前，它的types是“未定义”，并没有分配内存。 而且，它的types是不确定的。
javascript 中的null 是一个表示地址的值，但该地址指向任何东西[不存在的引用]。 尽pipe如此，它是一个价值。
Null is ALWAYS an unknown object that exists in memory, whereas undefined is not.
