03.2.1.1 类型、值与类型转换
所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.2 JavaScript / 03.2.1 语言核心与对象模型
03.2.1.1-001 JavaScript 有哪些原始类型和对象类型?
一句话结论
原始类型共七种:undefined、null、boolean、number、string、symbol、bigint;其余值都是对象类型(普通对象、数组、函数、日期、正则、Map/Set 等)。
概念解释
- 原始值按值存储,不可变更自身内容。
- 对象是引用类型,属性可动态增删。
- 函数在语言中属于可调用对象。
原理流程
- 字面量或构造产生值。
- 按类型归入原始或对象。
- 赋值、传参时原始值拷贝,对象传引用。
代码 / 示例
typeof undefined // "undefined"
typeof null // "object"(历史遗留)
typeof true // "boolean"
typeof 42 // "number"
typeof "text" // "string"
typeof Symbol() // "symbol"
typeof 1n // "bigint"
typeof {} // "object"
常见误区
- 误区:
null是对象类型;正解:它是原始类型,typeof 返回 object 是历史遗留 bug。 - 误区:数组是独立原始类型;正解:数组属于对象类型。
追问
- Q:原始值为什么能调用属性(如
"abc".length)? A:临时创建包装对象访问属性,用完即丢弃,见 03.2.1.1-003。 - Q:
undefined与null语义区别? A:undefined 表示未定义/未赋值,null 表示有意置空的空值。
03.2.1.1-002 typeof 的返回结果有哪些坑?
一句话结论
typeof null 返回 "object"(历史遗留);typeof 数组/日期/正则/普通对象 都返回 "object";typeof 函数 返回 "function";未声明变量返回 "undefined" 不报错。
概念解释
- typeof 按类型标签返回字符串。
- 无法区分对象子类型。
- 对未声明标识符使用 typeof 不抛 ReferenceError。
原理流程
- 读取值的类型标签。
- 映射为 typeof 字符串。
- 对象类值统一返回 object,函数例外。
代码 / 示例
typeof null // "object"
typeof [] // "object"
typeof new Date() // "object"
typeof /regex/ // "object"
typeof (() => {}) // "function"
typeof notDefined // "undefined",不报错
常见误区
- 误区:用 typeof 判断数组;正解:用
Array.isArray(arr)。 - 误区:typeof null 说明 null 是对象;正解:这是已知历史行为,不代表类型归属。
追问
- Q:如何区分普通对象与内置对象? A:
Object.prototype.toString.call(v),见 03.2.1.1-005。 - Q:typeof 对 bigint 与 symbol 返回什么? A:分别为
"bigint"、"symbol"。
03.2.1.1-003 原始值的包装对象是什么机制?
一句话结论
访问原始值的属性或方法时,引擎临时创建对应包装对象(String/Number/Boolean 实例),在其上取成员,使用后立即丢弃;原始值本身不持久挂载属性。
概念解释
- 包装类型:
String、Number、Boolean。 - 临时对象只存在于本次属性访问。
- 给原始值赋值属性会被静默忽略(非严格模式)。
原理流程
- 对原始值取属性。
- 引擎构造临时包装实例。
- 读取成员后销毁临时对象。
代码 / 示例
"abc".length; // 3,临时 String 对象
(5).toString(); // "5"
const s = "x";
s.foo = 1; // 静默失败,原始值不挂属性
console.log(s.foo); // undefined
常见误区
- 误区:原始值上可以保存自定义属性;正解:临时包装对象用完即弃,赋值不保留。
- 误区:
new String("a")与"a"等价;正解:前者是对象,typeof为 object,相等比较需注意。
追问
- Q:为什么推荐用字面量而不是 new 包装? A:避免对象类型导致比较、typeof 与隐式转换行为意外。
- Q:包装对象转布尔值是 true 吗? A:对象包装实例恒为真值,即使
new Boolean(false)也是 true。
03.2.1.1-004 instanceof 如何判断类型?有什么局限?
一句话结论
instanceof 检查构造函数的 prototype 是否出现在对象的原型链上;它只判断对象与构造函数的关系,无法判断原始类型,且跨 iframe/ realms 时原型链不同会误判。
概念解释
- 右侧必须是构造函数/类。
- 原始值(除装箱场景)返回 false。
- 不同全局环境的构造函数原型不是同一引用。
原理流程
- 取左侧对象的原型链。
- 沿链查找右侧
prototype。 - 找到返回 true,链到 null 返回 false。
代码 / 示例
[] instanceof Array // true
new Date() instanceof Date // true
"abc" instanceof String // false(原始值)
常见误区
- 误区:instanceof 能判断字符串类型;正解:原始值不走原型链,返回 false。
- 误区:同一对象在任何窗口都 instanceof 同一构造函数;正解:跨 realm 时构造函数不同,需用 toString 或 Symbol.toStringTag 判断。
追问
- Q:如何实现 instanceof 逻辑? A:沿
__proto__链遍历,与右侧 prototype 比较,见 03.2.1.2。 - Q:instanceof 能判断自定义类继承吗? A:能,沿原型链向上匹配父类 prototype。
03.2.1.1-005 如何准确判断内置对象类型?
一句话结论
Object.prototype.toString.call(value) 返回 "[object Type]",可区分 Array、Date、RegExp、Map、Set、Null、Undefined 等;比 typeof 与 instanceof 更稳定。
概念解释
- 调用未改动过 toString 的原生方法。
- 内置类型带
Symbol.toStringTag时按标签输出。 - 自定义对象可覆盖标签。
原理流程
- 借用 Object.prototype.toString。
- call 传入目标值。
- 解析返回字符串中的类型名。
代码 / 示例
const type = (v) => Object.prototype.toString.call(v).slice(8, -1);
type([]) // "Array"
type(new Date())// "Date"
type(/x/) // "RegExp"
type(null) // "Null"
type(undefined) // "Undefined"
type(new Map()) // "Map"
常见误区
- 误区:直接
arr.toString()判断;正解:数组重写了 toString,返回逗号拼接字符串。 - 误区:toString 结果不可被自定义影响;正解:对象设置
Symbol.toStringTag会改变输出标签。
追问
- Q:Array.isArray 与 toString 哪个判断数组? A:Array.isArray 更直接可靠;toString 用于更细的类型区分。
- Q:函数返回什么? A:
[object Function]。
03.2.1.1-006 == 与 === 有什么区别?
一句话结论
=== 严格相等:类型与值都相同才为 true,不做隐式转换;== 宽松相等:类型不同时先按抽象规则转换再比较,容易产生意外结果,工程上优先用 ===。
概念解释
- 严格相等:NaN 不等于任何值,+0 与 -0 相等。
- 宽松相等:有完整的抽象相等比较规则(见 03.2.1.1-008)。
- 例外:
null == undefined为 true,二者与其他值都不宽松相等。
原理流程
- ===:先比类型,类型不同直接 false,再比值。
- ==:类型相同走 ===;不同则按规则转换后比较。
- 比较结果返回布尔值。
代码 / 示例
1 == "1" // true
1 === "1" // false
null == undefined // true
null === undefined// false
NaN === NaN // false
常见误区
- 误区:== 只是“忽略类型比较值”;正解:转换规则复杂,布尔、对象、字符串、数字之间有固定步骤。
- 误区:=== 会把 NaN 判等;正解:NaN 是唯一不等于自身的值,判断用
Number.isNaN。
追问
- Q:判断 NaN 用什么? A:
Number.isNaN(x),全局isNaN会先把非数字转数字,范围更宽。 - Q:+0 与 -0 严格相等吗? A:相等,区分零号用
Object.is(0, -0)为 false。
03.2.1.1-007 ToPrimitive 抽象转换如何执行?
一句话结论
对象转原始值时,先按 hint(number/string/default)调用 [Symbol.toPrimitive],否则依次尝试 valueOf()、toString(),返回原始值为止;步骤与顺序由 hint 决定。
概念解释
- hint number:先 valueOf 后 toString。
- hint string:先 toString 后 valueOf。
- default:多数场景按 number 处理(Date 按 string)。
- 转换结果不是原始值会抛 TypeError。
原理流程
- 操作需要原始值(加法、比较、隐式转换)。
- 查找 Symbol.toPrimitive 钩子。
- 按 hint 调用 valueOf/toString,取得原始值。
代码 / 示例
const obj = {
valueOf() { return 1; },
toString() { return "two"; }
};
Number(obj); // 1,hint number 先 valueOf
String(obj); // "two",hint string 先 toString
obj + 0; // 1,default hint
常见误区
- 误区:对象转字符串总是先 toString;正解:hint 为 number/default 时先 valueOf。
- 误区:valueOf 返回对象也能继续转换;正解:必须返回原始值,否则抛错。
追问
- Q:Date 对象默认 hint 是什么? A:Date 的 default hint 按 string 处理,所以日期拼接字符串得到日期文本。
- Q:如何自定义转换行为? A:实现
[Symbol.toPrimitive](hint)方法,优先级最高。
03.2.1.1-008 抽象相等比较有哪些典型规则?
一句话结论
null 与 undefined 互等且不与其他值相等;字符串/数字/布尔比较时先转数字;对象与原始值比较时对象先 ToPrimitive;其余按类型转换后再比。
概念解释
- 布尔与其他值比:布尔先转数字。
- 对象与字符串/数字比:对象先转原始值。
- 规则步骤固定,可逐步推演结果。
原理流程
- 类型相同 → 严格比较。
- null/undefined 特例处理。
- 按对侧类型转换(布尔→数字,对象→原始)。
- 转换后同类型再比较。
代码 / 示例
0 == false // true:false → 0
"" == 0 // true:"" → 0
"1" == true // true:true → 1,"1" → 1
[] == false // true:[] → "" → 0,false → 0
常见误区
- 误区:== 的结果凭直觉猜;正解:按规则逐步转换,典型值可推演。
- 误区:对象 == 数字时数字转对象;正解:方向是对象转原始值。
追问
- Q:
[] == ![]结果是什么? A:true。![]先得 false,再按[] == false:[] 转 "" 转 0,false 转 0,相等。 - Q:为什么工程上避免 ==? A:规则细节多、可读性差,严格相等能消除一整类隐患。
03.2.1.1-009 哪些值是假值(falsy)?
一句话结论
JavaScript 假值共七个:false、0、-0、0n、""、null、undefined、NaN;其余值(含空对象、空数组、空函数字符串)都为真值。
概念解释
- 布尔转换:
Boolean(v)或!!v。 - 包装对象恒为真值。
- 条件判断、
||/&&短路按真假值取值。
原理流程
- 调用 ToBoolean 规则。
- 命中假值列表返回 false。
- 其他返回 true。
代码 / 示例
Boolean(false) // false
Boolean(0) // false
Boolean("") // false
Boolean(null) // false
Boolean(undefined)// false
Boolean(NaN) // false
Boolean([]) // true
Boolean({}) // true
Boolean("0") // true(非空字符串)
常见误区
- 误区:空数组/空对象是假值;正解:它们是对象,恒为真值。
- 误区:字符串 "false" 是假值;正解:非空字符串都是真值。
追问
- Q:
||返回的是真假值还是原值? A:返回第一个真值或最后一个原值,不是布尔值。 - Q:
??与||区别? A:??只在 null/undefined 时取右值,0 与空字符串不会被误判。
03.2.1.1-010 NaN 与 Infinity 如何判断和产生?
一句话结论
NaN 表示非法数值结果,不等于自身,用 Number.isNaN 判断;Infinity 表示超出数值范围的无穷大,除以零得到 Infinity,负无穷为 -Infinity。
概念解释
- 非法数学运算:
0/0、NaN - 1、非数字转数字失败。 - 数值上限:超过
Number.MAX_VALUE溢出为 Infinity。 - NaN 是 number 类型。
原理流程
- 数值运算无法得到有效数字。
- 产生 NaN;溢出产生 Infinity。
- 判断时避免用
x === NaN。
代码 / 示例
0 / 0 // NaN
"abc" - 1 // NaN
Number.isNaN(NaN) // true
1 / 0 // Infinity
-1 / 0 // -Infinity
Number.isFinite(Infinity) // false
常见误区
- 误区:
isNaN(x)只判断 NaN;正解:它先把 x 转数字,非数字字符串也会被判 true,Number.isNaN更严格。 - 误区:NaN 是字符串类型;正解:typeof NaN 是 number。
追问
- Q:如何判断一个值是有效数字? A:
typeof x === 'number' && !Number.isNaN(x) && Number.isFinite(x)按场景组合。 - Q:Number.MAX_VALUE 与 MAX_SAFE_INTEGER 区别? A:前者是最大浮点数,后者是可精确表示的最大整数(2^53 - 1)。
03.2.1.1-011 字符串转数字有哪些方式,parseInt 的 radix 注意什么?
一句话结论
Number(v)、+v 整体转换,失败得 NaN;parseInt 解析前缀整数并按 radix 进制转换,遇非数字停止;parseFloat 解析浮点数。
概念解释
- Number:空字符串转 0,非数字转 NaN。
- parseInt:忽略前导空白,解析到非法字符为止。
- radix 省略时按字符串前缀推断(0x 十六进制),建议始终显式传 10。
原理流程
- 选择转换函数。
- 逐字符解析合法部分。
- 返回数字或 NaN。
代码 / 示例
Number("123") // 123
Number("") // 0
Number("12a") // NaN
parseInt("12px", 10) // 12
parseInt("0xa") // 10(前缀推断十六进制)
parseFloat("3.14x")// 3.14
常见误区
- 误区:parseInt("08") 一定按八进制;正解:现代环境无前缀按十进制,显式 radix 10 最稳妥。
- 误区:Number(" ") 与 parseInt(" ") 结果相同;正解:Number 空白串转 0,parseInt 空白后无数字转 NaN。
追问
- Q:BigInt 字面量后缀是什么? A:
123n,不能与 Number 直接混合运算,需转换。 - Q:数字千分位字符串怎么转? A:先去除逗号等分隔符再 Number,避免 NaN。
03.2.1.1-012 BigInt 解决什么问题?
一句话结论
BigInt 表示任意精度整数,解决 Number 超过 2^53 - 1 后丢失精度的问题;字面量加 n 后缀,不能与 Number 直接算术运算。
概念解释
- typeof BigInt 为
"bigint"。 - 可与 Number 比较大小,但运算需同类型。
- 不支持
>>>无符号右移等部分位运算。
原理流程
- 大整数写为
123n或BigInt(123)。 - 按 BigInt 精度运算。
- 需要与 Number 混合时先显式转换。
代码 / 示例
const huge = 9007199254740993n;
typeof huge; // "bigint"
huge + 1n; // 9007199254740994n
Number(huge) === 9007199254740993; // false,已丢精度
常见误区
- 误区:BigInt 可以直接
+ 1;正解:类型不同抛 TypeError,需1n。 - 误区:BigInt 支持小数;正解:它是整数类型,小数截断或抛错。
追问
- Q:JSON 序列化 BigInt 报错吗? A:
JSON.stringify不支持 BigInt,需转字符串或自定义 replacer。 - Q:浏览器/Node 支持版本? A:现代环境支持,旧版本需按目标版本核实(待确认)。
03.2.1.1-013 Symbol 是什么?有什么用途?
一句话结论
Symbol 是唯一且不可变的原始值,每个 Symbol() 调用生成唯一标识;用作对象键避免命名冲突,也用于实现语言内部钩子(如 Symbol.toPrimitive、Symbol.iterator)。
概念解释
- 相同描述符不相等:
Symbol("a") !== Symbol("a")。 - 共享 Symbol 注册表:
Symbol.for/Symbol.keyFor。 - Symbol 键不参与
Object.keys/for...in枚举。
原理流程
- 调用 Symbol 生成唯一值。
- 作为对象属性键或内部协议标识。
- 遍历与序列化时按规则排除。
代码 / 示例
const key = Symbol("id");
const obj = { [key]: 1 };
obj[key]; // 1
Object.keys(obj); // []
Symbol.for("x") === Symbol.for("x"); // true
常见误区
- 误区:
Symbol("a")两次相等;正解:每次调用都是新唯一值。 - 误区:Symbol 键会被 JSON 序列化;正解:JSON 忽略 Symbol 键与 Symbol 值。
追问
- Q:Symbol 与私有字段区别? A:Symbol 键仍可通过
Object.getOwnPropertySymbols访问;#private是类内私有,外部不可见。 - Q:常见内置 Symbol 有哪些? A:iterator、toPrimitive、toStringTag、hasInstance、species 等。
03.2.1.1-014 原始值不可变是什么含义?
一句话结论
原始值的内容无法被修改,所有“修改”操作都产生新值;变量重新绑定只是指向新原始值,旧值保持不变。
概念解释
- 字符串操作返回新字符串。
- 数字、布尔、Symbol、BigInt 同理。
- 对象属性可修改,不属于不可变。
原理流程
- 对原始值执行操作。
- 引擎生成新原始值。
- 变量绑定到新值,旧值不被改动。
代码 / 示例
let s = "abc";
s.toUpperCase(); // "ABC" 新字符串
s; // "abc" 原字符串未变
s = s + "d"; // 重新绑定到新值 "abcd"
常见误区
- 误区:字符串方法会原地修改;正解:所有字符串方法返回新字符串。
- 误区:原始值在栈上所以能改;正解:存储位置与不可变性是类型语义,不可变指内容不可变。
追问
- Q:数组是可变还是不可变? A:对象引用,元素可增删改。
- Q:冻结对象与原始不可变有何不同? A:
Object.freeze冻结对象属性,属于人为限制;原始不可变是语言类型语义。
03.2.1.1-015 引用类型赋值与共享有什么表现?
一句话结论
对象赋值、传参复制的是引用,多个变量指向同一对象;通过任一引用修改属性,其他引用可见;原始值赋值则是值拷贝,互不影响。
概念解释
- 引用共享:修改属性作用于同一底层对象。
- 重新赋值变量只改变绑定,不影响原对象。
- 浅拷贝只复制一层引用。
原理流程
- 变量保存对象引用。
- 赋值/传参复制引用。
- 属性修改经引用作用于共享对象。
代码 / 示例
const a = { n: 1 };
const b = a;
b.n = 2;
a.n; // 2,共享对象
let x = 1;
let y = x;
y = 9;
x; // 1,原始值拷贝
常见误区
- 误区:
b = a复制了对象;正解:复制的是引用,对象只有一份。 - 误区:修改 b 后 a 也重新赋值;正解:属性共享修改,
b = {}只改变 b 的绑定。
追问
- Q:函数参数修改对象属性会影响外部吗? A:会,传引用共享;重新赋值参数变量不影响外部绑定。
- Q:如何切断共享? A:深拷贝生成独立对象,见 03.2.1.5。
03.2.1.1-016 如何写一个稳健的类型检查工具函数?
一句话结论
原始类型用 typeof 细分,null 单独判断,对象类型用 Object.prototype.toString 解析标签,数组用 Array.isArray;按返回值类型名组织工具函数。
概念解释
- 先排除 null/undefined。
- 原始类型 typeof 可识别。
- 对象类统一走 toString 标签。
原理流程
- 处理 null/undefined 特例。
- typeof 识别原始类型。
- 对象值借用 toString 返回类型名。
代码 / 示例
function getType(v) {
if (v === null) return "null";
if (v === undefined) return "undefined";
const t = typeof v;
if (t !== "object") return t;
return Object.prototype.toString.call(v).slice(8, -1).toLowerCase();
}
getType([]); // "array"
getType(1n); // "bigint"
getType(null); // "null"
常见误区
- 误区:工具函数只靠 typeof;正解:对象子类型必须 toString 或专用 API。
- 误区:返回中文类型名更友好;正解:工程上建议返回稳定英文标签,展示层再翻译。
追问
- Q:如何判断函数? A:
typeof v === 'function',类也属于函数类型。 - Q:自定义类如何标注类型名? A:设置
Symbol.toStringTag或在工具函数中按构造函数判断。
03.2.1.1-017 有哪些经典的转换陷阱题?
一句话结论
典型陷阱:[] == ![] 为 true、[] == [] 为 false、{} + [] 在语句开头被解析为代码块导致结果异常;推演必须按运算符优先级与 ToPrimitive 规则逐步进行。
概念解释
[] == ![]:先![]得 false,对象与布尔比较双方转数字后相等。[] == []:两个不同对象引用,严格比较 false。{} + []:行首{}被当代码块,+[]结果为 "0";括号包裹才按对象加法解析。
原理流程
- 识别运算符与解析上下文。
- 先处理
!、括号等优先级。 - 按抽象相等/加法规则逐步转换。
代码 / 示例
[] == ![] // true
[] == [] // false
({} + []); // "[object Object]",括号强制表达式
[] + {}; // "[object Object]"
0 + []; // "0",[] → ""
常见误区
- 误区:陷阱题结果靠死记;正解:掌握转换规则可逐题推演,记忆只用于典型对照。
- 误区:
{}在任何上下文都是对象;正解:行首语句位置会被解析为代码块。
追问
- Q:
null == 0为什么 false? A:null 只与 undefined 宽松相等,不转数字比较。 - Q:为什么不建议面试中纠结这类题? A:工程价值低,实际代码应写严格相等与显式转换。
03.2.1.1-018 严格模式在类型与赋值上有哪些差异?
一句话结论
严格模式下未声明变量赋值抛 ReferenceError,删除不可配置属性/变量抛错,函数参数名重复报错,this 为 undefined 而非全局对象;静默失败被显式错误取代。
概念解释
- 启用:
"use strict"或模块/类默认严格模式。 - 变量、参数、对象行为更严格。
- 避免意外污染全局。
原理流程
- 脚本/函数声明严格模式。
- 引擎按严格规则检查赋值与参数。
- 违规直接抛错而非静默忽略。
代码 / 示例
"use strict";
// undeclaredVar = 1; // ReferenceError
function f(a, a) {} // SyntaxError:参数重复
常见误区
- 误区:严格模式改变类型转换规则;正解:转换规则不变,改变的是赋值、参数与 this 等容错行为。
- 误区:模块代码需要手写 use strict;正解:ESM、类、类字段默认处于严格模式。
追问
- Q:严格模式下普通函数 this 是什么? A:undefined,非严格模式为全局对象,见 03.2.1.4。
- Q:严格模式能否撤销? A:一旦进入严格模式不能退回非严格,作用域边界内持续生效。