JavaScript中的null和undefault有什么区别？

undefined表示变量已声明但尚未赋值：

var testVar;console.log(testVar); //shows undefinedconsole.log(typeof testVar); //shows undefined

null是赋值。它可以作为无值的表示分配给变量：

var testVar = null;console.log(testVar); //shows nullconsole.log(typeof testVar); //shows object

从前面的例子中，很明显undefined和null是两个不同的类型：undefined是一个类型本身（未定义），而null是一个对象。

证明：

console.log(null === undefined) // false (not the same type)console.log(null == undefined) // true (but the "same value")console.log(null === null) // true (both type and value are the same)

和

null = 'value' // Uncaught SyntaxError: invalid assignment left-hand sideundefined = 'value' // 'value'

我把它从这里

未定义的值是一个原始值，当变量没有#36825；个值

null值是一个原始值，表示null、空、或不存在的引用。

当你通过var声明一个变量而不给它一个值时，它将具有未定义的值。单独地，如果你尝试WScript. Echo（）或警报（）此值，你将看不到任何内容。但是，如果你向其附加一个空字符串，那么它会突然出现：

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

您可以声明一个变量，将其设置为null，并且行为是相同的，除了您会看到“null”打印出来与“未定义”。这确实是一个很小的区别。

您甚至可以将未定义的变量与null进行比较，反之亦然，条件将为true：

undefined == nullnull == undefined

然而，它们被认为是两种不同的类型。虽然未定义是一个完全属于自己的类型，但null被认为是一个特殊的对象值。您可以通过使用typeof（）来看到这一点，它返回一个表示变量一般类型的字符串：

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

运行上述脚本将产生以下输出：

undefinedobject

不管它们是不同的类型，如果您尝试访问其中任何一个的成员，它们的行为仍然相同，例如，它们将抛出异常。使用WSH，您将看到可怕的“'varname'is null or not an Object”，这是如果您幸运的话（但这是另一篇文章的主题）。

你可以明确地将变量设置为未定义，但我强烈建议不要这样做。我建议只将变量设置为null，而忘记设置的值则保持未定义。同时，我真的鼓励你始终设置每个变量。JavaScript的作用域链与C风格语言不同，即使是资深程序员也很容易混淆，将变量设置为null是防止基于它的错误的最佳方法。

另一个你会看到未定义弹出的实例是在使用删除运算符时。我们这些来自C世界的人可能会错误地将其解释为销毁对象，但事实并非如此。此操作的作用是从数组中删除下标或从对象中删除成员。对于数组，它不会影响长度，而是下标现在被认为是未定义的。

var a = [ 'a', 'b', 'c' ];delete a[1];for (var i = 0; i < a.length; i++)WScript.Echo((i+".) "+a[i]);

上述脚本的结果是：

0.) a1.) undefined2.) c

当读取从未存在的下标或成员时，您也会得到未定义的返回。

null和untex的区别是：JavaScript永远不会将任何内容设置为null，这通常是我们所做的。虽然我们可以将变量设置为untex，但我们更喜欢null，因为它不是为我们完成的。当你调试时，这意味着任何设置为null的东西都是你自己做的，而不是JavaScript。除此之外，这两个特殊值几乎是等价的。

未定义表示变量已声明但没有值：

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

Null是一个赋值：

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

null是一个特殊值，表示“没有值”。null是一个特殊对象，因为typeof null返回“对象”。

另一方面，undefined意味着变量没有被声明，或者没有被赋予值。

null：没有变量的值；未定义：没有变量本身；

…其中变量是与值关联的符号名称。

JS可以用null隐式初始化新声明的变量，但它没有。

由于typeof返回未定义，undefault是一个类型，其中null是一个初始化器，表示变量不指向任何对象（Javascript中的几乎所有内容都是对象）。

null和un憎恨都是用来表示某个值的缺失。

var a = null;

a被初始化和定义。

typeof(a)//object

null是JavaScript中的一个对象

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

b未定义且未初始化

未定义的对象属性也是未定义的。例如，“x”未在对象c上定义，如果您尝试访问c. x，它将返回未定义。

通常我们将null分配给未定义的变量。

null是一个特殊的关键字，表示没有值。

把它看作一个值，比如：

• "foo"是字符串，
• true是boolean，
• 1234是数字。
• null未定义。

未定义属性表示尚未为变量分配包括null在内的值。喜欢

var foo;

定义的空变量是数据类型undefined的null

两者都代表一个没有值的变量的值

和null不表示没有值的字符串-空字符串-

喜欢

var a = '';console.log(typeof a); // stringconsole.log(a == null); //falseconsole.log(a == undefined); // false

现在如果

var a;console.log(a == null); //trueconsole.log(a == undefined); //true

但是

var a;console.log(a === null); //falseconsole.log(a === undefined); // true

SO每个人都有自己的使用方式

未定义使用它来比较变量数据类型

null使用它来清空变量的值

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

在JavasScript中，有5种原始数据类型：String、Number、Boolean、null和untex。我将用一些简单的例子来解释。

假设我们有一个简单的函数

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

此外，上面的function if(a == null)与if(!a)相同。

现在，当我们调用这个函数而不传递参数a时

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

还

var a;alert(typeof a);

这将给出undefault；我们已经声明了一个变量，但我们没有为这个变量分配任何值；

但如果我们写

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

所以null是一个对象。在某种程度上，我们为'a'分配了一个值null

null和未定义是两种不同的对象类型，它们具有以下共同点：

• 两者都只能保存一个值，分别为null和未定义；
• 两者都没有属性或方法，并且尝试读取其中任何一个的任何属性都将导致运行时错误（对于所有其他对象，如果您尝试读取不存在的属性，则获得值未定义）；
• 值null和未定义被认为彼此相等，而不是==和!=运算符。

然而，相似之处到此结束。这一次，关键字null和未定义的实现方式存在根本差异。这并不明显，但考虑以下示例：

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

、和只是预初始化的“超全局”变量的名称——它们在运行时初始化，可以被同名的普通全局或局部变量覆盖。

现在，让我们用null尝试同样的事情：

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

null、真正和虚假是保留关键字-编译器不允许您将它们用作变量或属性名称

另一个区别是未定义是基本类型，而null是对象类型（表示对象引用的缺失）。考虑以下内容：

WScript.Echo(typeof false); // Will print: booleanWScript.Echo(typeof 0); // Will print: numberWScript.Echo(typeof ""); // Will print: stringWScript.Echo(typeof {}); // Will print: objectWScript.Echo(typeof undefined); // Will print: undefinedWScript.Echo(typeof null); // (!!!) Will print: object

此外，在数字上下文中处理null和未定义的方式存在重要差异：

var a; // declared but uninitialized variables hold the value undefinedWScript.Echo(a === undefined); // Prints: -1
var b = null; // the value null must be explicitly assignedWScript.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 (!!!)

当用于算术表达式或数字比较时，null变成了——与虚假类似，它基本上只是一种特殊的“零”。另一方面，未定义是一个真正的“无”，当你尝试在数字上下文中使用它时，它变成了NaN（“不是数字”）。

请注意，null和未定义接受==和!=运算符的特殊处理，但您可以使用表达式(a >= b && a <= b)测试一个和b的真正数字相等性。

您可能会认为untex表示系统级、意外或类似错误的值缺失，而null表示程序级、正常或预期的值缺失。

通过JavaScript：权威指南

补充一下我的观点——

如果是像C++这样的编译语言[或者在IDE中标记了警告]，则只声明并且从未在任何地方使用的变量会被优化编译器删除。这最终意味着该变量不存在，因为它的内存从未分配过。

在javascript解释器的情况下，[我猜]一个变量仅从它被赋予值的那一刻起被视为存在。在那之前，它的类型是“未定义的”，没有为它分配内存。而且，所以它的类型是未定义的。

javascript是中的null表示一个地址的值，但该地址还没有指向任何东西[不存在的引用]。尽管如此，它还是一个值。

Null始终是内存中存在的未知对象，而未定义则不是。

null-它是一个赋值值，与变量一起使用以表示没有值（它是一个对象）。

未定义-它是一个没有分配任何值的变量，因此JavaScript会为其分配一个unset（它是一种数据类型）。

未申报-如果一个变量根本没有创建，它被称为未声明。

如果一个变量没有初始化，那么它是未定义的。未定义不是对象。示例：var MyName；console.log（typeof MyName）；

检查控制台日志开发工具，它将被打印为未定义。

null是一个对象。如果你想让某个变量为null，那么null是used.null变量存在但值未知。它应该按照语法分配给一个变量。null不会自动初始化。

示例：var MyName=null；console.log（typeof MyName）在开发工具中检查csole日志，它将是一个对象。

undefined和null之间的差异很小，但有一个区别。值为undefined的变量从未被初始化。值为null的变量被显式地赋予了null的值，这意味着该变量被显式地设置为没有值。如果使用null==undefined表达式比较undefined和null，它们将相等。

根据Ryan Morr关于这个主题的详尽文章…

“一般来说，如果你需要将非值赋值给变量或属性，将其传递给函数，或者从函数返回，null几乎总是最好的选择。简单地说，JavaScript使用未定义，程序员应该使用null。”

见探索空与未定义的永恒深渊

对于undefined类型，只有一个值：undefined。

对于null类型，只有一个值：null。

对于他们俩来说，标签既是它的类型，也是它的值。

它们之间的区别。例如：

• null是一个空值
• undefined是一个缺失值

或：

• undefined还没有值
• null有一个值，现在没有了

实际上，null是特殊关键字，而不是标识符，因此您不能将其视为要分配的变量。

然而，undefined是一个标识符。然而，在non-strict模式和strict模式下，您可以创建一个名称未定义的局部变量。但这是一个可怕的想法！

function foo() {undefined = 2; // bad idea!}
foo();
function foo() {"use strict";undefined = 2; // TypeError!}
foo();

我将解释undefined、null和Uncaught ReferenceError：

1-Uncaught ReferenceError：脚本中的变量尚未宣布，没有引用此变量
2-undefined：变量声明但未初始化
3-null：变量声明为空值

请仔细阅读以下内容。它应该消除您对JavaScript中null和undefined之间差异的所有疑问。此外，您可以使用本答案末尾的实用函数来获取更具体类型的变量。

在JavaScript中，我们可以有以下类型的变量：

1. 未声明的变量
2. 声明但未赋值的变量
3. 使用文字undefined分配的变量
4. 使用文字null分配的变量
5. 变量赋值为undefined或null以外的任何值

以下将逐一解释这些案例：

1. 未声明的变量

   • 只能使用返回字符串“不确定”的typeof运算符进行检查
   • 不能用松散的等号操作符（== undefined）检查，更不用说严格的等号操作符（=== undefined）了，
     以及if语句和三元运算符（? :）-这些抛出引用错误

2. 声明但未赋值的变量

   • typeof返回字符串“不确定”
   • ==检查null返回true
   • ==检查undefined返回true
   • ===检查null返回false
   • ===检查undefined返回true
   • 是Falsy到if语句和三元运算符（? :）

3. 使用文字#0分配的变量
   这些变量的处理方式与声明但未赋值的变量完全相同。

4. 使用文字#0分配的变量

   • typeof返回字符串对象
   • ==检查null返回true
   • ==检查undefined返回true
   • ===检查null返回true
   • ===检查undefined返回false
   • 是Falsy到if语句和三元运算符（? :）

5. 变量赋值为#0或#1以外的任何值

   • typeof返回以下字符串之一：“大”、布尔型、函数、数字、对象、字符串、符号

以下提供了正确检查变量类型的算法：

1. 获取我们的变量typeof，如果不是对象则返回它
2. 检查null，因为typeof null也返回对象
3. 使用Switch语句评估Object.prototype.toString.call（o）以返回更精确的值。Object的toString方法返回的字符串看起来像本机/主机对象的'[对象构造器名称]'。对于所有其他对象（用户定义的对象），它总是返回'[对象对象]'
4. 如果最后一部分是这种情况（变量的字符串化版本是'[对象对象]'）并且参数返回构造函数Boolean是true，它将尝试通过toString读取它并从那里提取名称来获取构造函数的名称。如果无法到达构造函数，则像往常一样返回对象。如果字符串不包含其名称，则返回匿名

（支持ECMAScript 2020之前的所有类型）

function TypeOf(o, returnConstructorBoolean) {const type = typeof o
if (type !== 'object') return typeif (o === null)        return 'null'
const toString = Object.prototype.toString.call(o)
switch (toString) {// Value types: 6case '[object BigInt]':            return 'bigint'case '[object Boolean]':           return 'boolean'case '[object Date]':              return 'date'case '[object Number]':            return 'number'case '[object String]':            return 'string'case '[object Symbol]':            return 'symbol'
// Error types: 7case '[object Error]':             return 'error'case '[object EvalError]':         return 'evalerror'case '[object RangeError]':        return 'rangeerror'case '[object ReferenceError]':    return 'referenceerror'case '[object SyntaxError]':       return 'syntaxerror'case '[object TypeError]':         return 'typeerror'case '[object URIError]':          return 'urierror'
// Indexed Collection and Helper types: 13case '[object Array]':             return 'array'case '[object Int8Array]':         return 'int8array'case '[object Uint8Array]':        return 'uint8array'case '[object Uint8ClampedArray]': return 'uint8clampedarray'case '[object Int16Array]':        return 'int16array'case '[object Uint16Array]':       return 'uint16array'case '[object Int32Array]':        return 'int32array'case '[object Uint32Array]':       return 'uint32array'case '[object Float32Array]':      return 'float32array'case '[object Float64Array]':      return 'float64array'case '[object ArrayBuffer]':       return 'arraybuffer'case '[object SharedArrayBuffer]': return 'sharedarraybuffer'case '[object DataView]':          return 'dataview'
// Keyed Collection types: 2case '[object Map]':               return 'map'case '[object WeakMap]':           return 'weakmap'
// Set types: 2case '[object Set]':               return 'set'case '[object WeakSet]':           return 'weakset'
// Operation types: 3case '[object RegExp]':            return 'regexp'case '[object Proxy]':             return 'proxy'case '[object Promise]':           return 'promise'
// Plain objectscase '[object Object]':if (!returnConstructorBoolean)return type
const _prototype = Object.getPrototypeOf(o)if (!_prototype)return type
const _constructor = _prototype.constructorif (!_constructor)return type
const matches = Function.prototype.toString.call(_constructor).match(/^function\s*([^\s(]+)/)return matches ? matches[1] : 'anonymous'
default: return toString.split(' ')[1].slice(0, -1)}}

基本上，未定义是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;