已经给出了很多“技术性”的答案，从JS仅仅是一种编程语言的有限角度来看，所有答案都是正确的。

然而，我想补充以下想法，特别是当您将TypeScript代码作为更大项目/（企业）应用程序的一部分时：

当与某种后端交谈时，您很可能会收到JSON虽然一些后端正确地避免了在JSON中使用“null”（删除那些财产），但其他后端没有这样做现在，虽然“null”可能意味着该值是故意缺失的，但更多情况下，它并没有传达这一含义。大多数数据库使用“null”只是因为它们没有“undefined”类型。但真正的含义只是“未定义”。因此，您永远无法知道“null”值是否真的意味着故意缺席。因此，“空”并不意味着故意选择“缺失值”。一般来说，这是无法决定的。因此，在语义上，“null”和“undefined”实际上是完全相同的。

因此，为了协调一致，我坚决反对使用“null”，并希望鼓励您停止在代码中使用“null“。这比你想象的要容易得多。别误会我。我不是说不处理“null”值，只是为了避免在代码中显式使用它们。换句话说：您的代码应该仍然能够处理来自应用程序外部的意外传递的“null”值，例如通过第三方库（如Angular）或第三方后端。

以下是实现这一目标的指导原则：

避免直接的未定义类型保护（例如，如果（值==未定义）｛…｝。相反，使用间接类型保护（也称为真实性检查），例如if（value）｛…｝每当0或空字符串有意义时，请使用像Lodash的isNil这样的显式助手方法或在比较中包含有意义的值（例如，如果（！value&&value！==0）｛…｝）考虑使用不允许使用null的lint规则

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

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

未声明的变量已声明但未分配的变量未定义文字赋值的变量赋值为文本null的变量变量分配了除未定义或null以外的任何值

以下逐一解释了每种情况：

未声明的变量只能使用返回字符串“undefined”的typeof运算符进行检查不能用松散相等运算符（==undefined）检查，更不用说严格相等运算符（===undefineed），以及if语句和三元运算符（？：）-这些抛出引用错误已声明但未分配的变量typeof返回字符串“undefined”==检查null返回true==未定义的检查返回true==检查null返回false==未定义的检查返回trueif语句和三元运算符（？：）是否错误未定义文字赋值的变量这些变量与已声明但未分配的变量完全相同。赋值为文本null的变量typeof返回字符串“object”==检查null返回true==未定义的检查返回true==检查null返回true==检查未定义返回falseif语句和三元运算符（？：）是否错误变量分配了除未定义或null以外的任何值typeof返回以下字符串之一：“bigint”、“boolean”、“function”、“number”、“object”、“string”、“symbol”

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

获取变量的类型，如果它不是“object”，则返回它检查null，因为typeof null也返回“object”使用switch语句对Object.protype.toString.call（o）求值，以返回更精确的值。Object的toString方法为本机/主机对象返回类似“[Object ConstructorName]”的字符串。对于所有其他对象（用户定义的对象），它始终返回“[object object]”如果最后一部分是这种情况（变量的字符串化版本为“[objectObject]”），并且参数returnConstructorBoolean为真，则它将尝试通过对其进行字符串化并从中提取名称来获取构造函数的名称。如果无法访问构造函数，将照常返回“object”。如果字符串不包含其名称，则返回“匿名”

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

function TypeOf(o, returnConstructorBoolean) {
  const type = typeof o

  if (type !== 'object') return type
  if (o === null)        return 'null'

  const toString = Object.prototype.toString.call(o)

  switch (toString) {
    // Value types: 6
    case '[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: 7
    case '[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: 13
    case '[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: 2
    case '[object Map]':               return 'map'
    case '[object WeakMap]':           return 'weakmap'

    // Set types: 2
    case '[object Set]':               return 'set'
    case '[object WeakSet]':           return 'weakset'

    // Operation types: 3
    case '[object RegExp]':            return 'regexp'
    case '[object Proxy]':             return 'proxy'
    case '[object Promise]':           return 'promise'

    // Plain objects
    case '[object Object]':
      if (!returnConstructorBoolean)
        return type

      const _prototype = Object.getPrototypeOf(o)
      if (!_prototype)              
        return type

      const _constructor = _prototype.constructor
      if (!_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)
  }
}

除了不同的含义外，还有其他区别：

对象析构函数对这两个值的作用不同：常量｛a=“默认”｝=｛a:未定义｝；//a是“默认值”常量｛b=“默认”｝=｛b:null｝；//b为空JSON.stringify（）保持null，但省略未定义const json=json.stringify（{undefinedValue:undefined，nullValue:null}）；console.log（json）；//打印｛“nullValue”：null｝运算符类型console.log（类型未定义）；//“未定义”console.log（类型为空）；//“object”而不是“null”

看看这个。输出值一千字。

var b1=文档.getElementById（“b1”）；checkif（“1，无参数”）；checkif（“2，显式未定义”，未定义）；checkif（“3，显式空”，空）；checkif（“4，the 0”，0）；checkif（“5，空字符串”，“”）；checkif（“6，string”，“string”）；checkif（“7，number”，123456）；函数checkif（a1，a2）{print（“\ncheckif（），”+a1+“：”）；如果（a2==未定义）{打印（“==未定义：是”）；}其他{打印（“==未定义：否”）；}如果（a2==未定义）{打印（“==未定义：是”）；}其他{打印（“==未定义：否”）；}如果（a2==空）{打印（“==null:YES”）；}其他{打印（“==null:NO”）；}如果（a2==空）{打印（“==空：是”）；}其他{打印（“==null:NO”）；}如果（a2==“”）{打印（“==''：是”）；}其他{打印（“==''：否”）；}如果（a2==“”）{打印（“==''：是”）；}其他{打印（“==''：否”）；}如果（isNaN（a2））{打印（“isNaN（）：是”）；}其他{打印（“isNaN（）：否”）；}如果（a2）{打印（“如果-？：是”）；}其他{打印（“如果-？：否”）；}打印（“typeof（）：”+typeof（a2））；}函数打印（v）{b1.innerHTML+=v+“\n”；}<!DOCTYPE html><html><body><pre id=“b1”></pre></body></html>

另请参见：

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefinedhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaNhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/nullhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

干杯

null和undefined都用于表示缺少某个值。

var a = null;

a被初始化和定义。

typeof(a)
//object

null是JavaScript中的对象

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

var b;

b未定义且未初始化

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

通常，我们为未定义的变量赋值null。

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

两者都只能保存一个值，分别为null和undefined；两者都没有财产或方法，尝试读取其中一个的任何财产都会导致运行时错误（对于所有其他对象，如果尝试读取不存在的属性，则会得到未定义的值）；通过==和！=，值null和undefined被视为彼此相等，其他值都不相等操作员。

然而，相似之处到此为止。这一次，在实现关键字null和undefined的方式上有一个根本的区别。这并不明显，但请考虑以下示例：

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

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

现在，让我们对null做同样的尝试：

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 (!!!)

当在算术表达式或数字比较中使用null时，null变为0-与false类似，它基本上只是一种特殊的“零”。另一方面，undefined是一个真正的“无”，当您尝试在数字上下文中使用它时，它会变成NaN（“非数字”）。

注意，null和undefined从==和！=接收特殊处理运算符，但可以使用表达式（a>=b&&a<=b）测试a和b的真正数值相等性。