要判断变量是否未定义，最安全的方式是使用 typeof 操作符；1. 使用 typeof 变量 === 'undefined' 可安全检查未声明或未赋值的变量，不会抛出错误；2. 直接使用 变量 === undefined 在变量未声明时会抛出 referenceerror，存在风险；3. typeof 在严格模式和非严格模式下均安全，但无法跨越暂时性死区（tdz），在 let/const 声明前访问仍会报错；4. 注意 undefined 表示未赋值，null 表示有意置空，应根据语义选择判断方式；5. 最佳实践是优先用 typeof 进行防御性检查，并显式初始化变量以增强代码可读性与健壮性。
在JavaScript里，要判断一个变量是不是未定义，最直接也最推荐的方式是使用
typeof操作符，检查其结果是否严格等于字符串
'undefined'。当然，你也可以直接将变量与全局的
undefined值进行严格相等比较，但前者在某些场景下会更安全。
这事儿听起来简单，但里头门道不少。我们通常说的“未定义”，可能指两种情况：一种是变量压根就没声明过，另一种是变量声明了，但还没赋值，或者被显式赋值为
undefined。
对于未声明的变量，直接去访问它会抛出一个
ReferenceError。这时候
typeof就显得特别好用，因为它不会报错，而是直接返回
'undefined'这个字符串。比如：
// 假设 'myUndeclaredVar' 从未被声明
if (typeof myUndeclaredVar === 'undefined') {
console.log('myUndeclaredVar 确实未定义或未声明。');
} else {
console.log('myUndeclaredVar 已定义。');
}
// 尝试直接访问未声明的变量会报错
// console.log(myUndeclaredVar); // 这行会抛出 ReferenceError而对于已声明但未赋值，或者被显式赋值为 undefined
的变量，你可以用
typeof，也可以直接用
=== undefined进行比较。我个人更倾向于
typeof，因为它在处理那些连声明都没的变量时，能给我一种莫名的安全感，避免了不必要的运行时错误。
let myDeclaredVar; // 声明了，但未赋值，默认为 undefined
let anotherVar = undefined; // 显式赋值为 undefined
if (typeof myDeclaredVar === 'undefined') {
console.log('myDeclaredVar 是 undefined。');
}
if (anotherVar === undefined) {
console.log('anotherVar 也是 undefined。');
}值得一提的是，
undefined在全局作用域下是一个属性，但在旧版浏览器或非严格模式下，它可能被意外覆盖。虽然现代JavaScript环境和严格模式下这几乎不可能发生，但
typeof操作符始终是返回一个字符串，这个字符串
'undefined'是无法被修改的，所以从这个角度看，它更“铁杆”一些。
为什么直接使用 === undefined
判断可能不够安全？
这个问题其实挺有意思的，它触及到了JavaScript的一些底层机制。当你直接写
if (myVar === undefined)的时候，如果
myVar这个变量在当前作用域里压根就没被声明过，JavaScript引擎在执行到
myVar的时候，就会直接抛出一个
ReferenceError。这意味着你的程序会中断，而不是继续执行判断逻辑。
举个例子，假设你有个函数，它可能接收一个参数，也可能不接收。如果你想判断这个参数是不是传进来了：
function processData(data) {
// 如果 data 压根没传，这里不会抛 ReferenceError
if (typeof data === 'undefined') {
console.log('data 未提供，使用默认值或跳过处理。');
return;
}
// 如果 data 传了，但值为 undefined，这里也会被捕获
if (data === undefined) { // 假设 data 被明确传了 undefined
console.log('data 明确是 undefined。');
}
console.log('处理数据:', data);
}
processData(); // 调用时未提供参数，data 为 undefined
processData(undefined); // 调用时明确提供了 undefined
// processData(nonExistentVar); // 如果 nonExistentVar 未声明，这里会直接报错，函数都进不去你看，
typeof的好处在于，它对未声明的变量是“免疫”的，它不会去尝试获取变量的值，只是检查它的“类型”，所以即便变量不存在，它也能安全地返回
'undefined'。而
=== undefined则要求变量必须存在（即便它的值是
undefined），否则就会“炸”掉。所以，在你不确定变量是否已经声明过的时候，
typeof是更稳妥的选择。这其实也是一种防御性编程的体现，避免不必要的运行时错误。
在不同作用域下，typeof
和 === undefined
的行为有何不同？
其实从根本上说，
typeof和
=== undefined在行为上的差异，主要体现在它们如何处理“未声明”变量上，而这与变量所处的作用域（全局作用域、函数作用域、块级作用域）并没有本质区别。无论变量在哪儿，只要它没声明，直接访问它就会导致
ReferenceError。
不过，我们可以从另一个角度来聊聊作用域的影响。在严格模式（'use strict'）下，JavaScript对未声明变量的处理会更严格。非严格模式下，如果你给一个未声明的变量赋值，它可能会在全局作用域下被隐式创建为一个全局变量。但在严格模式下，这会直接抛出
ReferenceError。
// 非严格模式下
function oldSchool() {
undeclaredGlobal = '我被隐式创建了'; // 糟糕的实践
console.log(undeclaredGlobal);
}
// oldSchool();
// console.log(typeof undeclaredGlobal); // 'string'
// 严格模式下
function modernWay() {
'use strict';
// undeclaredStrictVar = '我会报错'; // ReferenceError
// console.log(undeclaredStrictVar);
}
// modernWay(); // 运行会报错
// 无论严格与否，typeof 始终安全
if (typeof nonExistentVarInAnyScope === 'undefined') {
console.log('这个变量在任何作用域下都未声明，typeof 依然安全。');
}所以，无论你是在函数内部、块级作用域（
let或
const定义的变量）还是全局作用域，
typeof针对未声明变量的“安全帽”特性是保持不变的。而
=== undefined的“危险性”也一样，只要变量未声明，它就可能导致错误。真正需要注意的是，
let和
const声明的变量存在“暂时性死区”（Temporal Dead Zone, TDZ），在声明前访问它们也会抛出
ReferenceError，即使它们在当前作用域内。这时候，
typeof也会和直接访问一样报错。这是
typeof唯一一个“不安全”的例外情况，但它不是因为变量未声明，而是因为你在TDZ内访问。
console.log(typeof myLetVar); // ReferenceError: Cannot access 'myLetVar' before initialization let myLetVar = 10;
这一点，我觉得很多人可能容易混淆，以为
typeof总是万能的。它确实很强大，但不是没有边界的。
处理未定义变量时，有哪些常见的陷阱和最佳实践？
处理未定义变量，与其说是技术挑战，不如说更多的是一种编程习惯和思维模式的考验。常见的陷阱嘛，我能想到的，最直接的就是前面提到的，不分青红皂白地直接访问一个可能未声明的变量，然后被
ReferenceError搞得措手不及。尤其是在处理一些动态生成代码、或者从外部配置/API获取数据，其结构不那么确定的场景下，这种错误特别容易出现。
另一个小陷阱是，混淆
undefined和
null。虽然它们都表示“空”或者“无”，但语义上是有区别的。
undefined通常意味着“未赋值”或“不存在”，而
null则是明确地表示“没有值”或者“空值”，它是一个被程序员主动赋值的意图。
let a; // a 是 undefined let b = null; // b 是 null console.log(a === undefined); // true console.log(b === null); // true console.log(a == null); // true (注意 == 会进行类型转换) console.log(b == undefined); // true (同样是 == 的结果)
所以，在判断的时候，通常会用
===来避免这种类型转换带来的模糊性。我个人习惯是，如果我想明确判断是否“未赋值”，就用
=== undefined或
typeof；如果我想判断是否“无值”（包括
null和
undefined），有时候会用
== null，但通常还是会分开判断，或者根据业务逻辑来决定。
至于最佳实践，说到底，就是防御性编程。
-
优先使用
typeof
进行存在性检查： 当你不确定一个变量是否已经被声明时，typeof
是你的首选。它能有效避免ReferenceError
。 -
明确初始化变量： 养成声明变量时就进行初始化的好习惯。如果暂时没有值，可以显式地赋值为
null
，这比让它默认为undefined
更能表达意图。let userName = null; // 明确表示 userName 暂时没有值
