罗罗编程学习记录
本页内容 展开查看

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 等)。

概念解释

  • 原始值按值存储,不可变更自身内容。
  • 对象是引用类型,属性可动态增删。
  • 函数在语言中属于可调用对象。

原理流程

  1. 字面量或构造产生值。
  2. 按类型归入原始或对象。
  3. 赋值、传参时原始值拷贝,对象传引用。

代码 / 示例

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。

原理流程

  1. 读取值的类型标签。
  2. 映射为 typeof 字符串。
  3. 对象类值统一返回 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。
  • 临时对象只存在于本次属性访问。
  • 给原始值赋值属性会被静默忽略(非严格模式)。

原理流程

  1. 对原始值取属性。
  2. 引擎构造临时包装实例。
  3. 读取成员后销毁临时对象。

代码 / 示例

"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。
  • 不同全局环境的构造函数原型不是同一引用。

原理流程

  1. 取左侧对象的原型链。
  2. 沿链查找右侧 prototype。
  3. 找到返回 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 时按标签输出。
  • 自定义对象可覆盖标签。

原理流程

  1. 借用 Object.prototype.toString。
  2. call 传入目标值。
  3. 解析返回字符串中的类型名。

代码 / 示例

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,二者与其他值都不宽松相等。

原理流程

  1. ===:先比类型,类型不同直接 false,再比值。
  2. ==:类型相同走 ===;不同则按规则转换后比较。
  3. 比较结果返回布尔值。

代码 / 示例

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。

原理流程

  1. 操作需要原始值(加法、比较、隐式转换)。
  2. 查找 Symbol.toPrimitive 钩子。
  3. 按 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;其余按类型转换后再比。

概念解释

  • 布尔与其他值比:布尔先转数字。
  • 对象与字符串/数字比:对象先转原始值。
  • 规则步骤固定,可逐步推演结果。

原理流程

  1. 类型相同 → 严格比较。
  2. null/undefined 特例处理。
  3. 按对侧类型转换(布尔→数字,对象→原始)。
  4. 转换后同类型再比较。

代码 / 示例

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。
  • 包装对象恒为真值。
  • 条件判断、||/&& 短路按真假值取值。

原理流程

  1. 调用 ToBoolean 规则。
  2. 命中假值列表返回 false。
  3. 其他返回 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 类型。

原理流程

  1. 数值运算无法得到有效数字。
  2. 产生 NaN;溢出产生 Infinity。
  3. 判断时避免用 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。

原理流程

  1. 选择转换函数。
  2. 逐字符解析合法部分。
  3. 返回数字或 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 比较大小,但运算需同类型。
  • 不支持 >>> 无符号右移等部分位运算。

原理流程

  1. 大整数写为 123n 或 BigInt(123)。
  2. 按 BigInt 精度运算。
  3. 需要与 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 枚举。

原理流程

  1. 调用 Symbol 生成唯一值。
  2. 作为对象属性键或内部协议标识。
  3. 遍历与序列化时按规则排除。

代码 / 示例

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 同理。
  • 对象属性可修改,不属于不可变。

原理流程

  1. 对原始值执行操作。
  2. 引擎生成新原始值。
  3. 变量绑定到新值,旧值不被改动。

代码 / 示例

let s = "abc";
s.toUpperCase();   // "ABC" 新字符串
s;                 // "abc" 原字符串未变
s = s + "d";       // 重新绑定到新值 "abcd"

常见误区

  • 误区:字符串方法会原地修改;正解:所有字符串方法返回新字符串。
  • 误区:原始值在栈上所以能改;正解:存储位置与不可变性是类型语义,不可变指内容不可变。

追问

  • Q:数组是可变还是不可变? A:对象引用,元素可增删改。
  • Q:冻结对象与原始不可变有何不同? A:Object.freeze 冻结对象属性,属于人为限制;原始不可变是语言类型语义。

03.2.1.1-015 引用类型赋值与共享有什么表现?

一句话结论

对象赋值、传参复制的是引用,多个变量指向同一对象;通过任一引用修改属性,其他引用可见;原始值赋值则是值拷贝,互不影响。

概念解释

  • 引用共享:修改属性作用于同一底层对象。
  • 重新赋值变量只改变绑定,不影响原对象。
  • 浅拷贝只复制一层引用。

原理流程

  1. 变量保存对象引用。
  2. 赋值/传参复制引用。
  3. 属性修改经引用作用于共享对象。

代码 / 示例

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 标签。

原理流程

  1. 处理 null/undefined 特例。
  2. typeof 识别原始类型。
  3. 对象值借用 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";括号包裹才按对象加法解析。

原理流程

  1. 识别运算符与解析上下文。
  2. 先处理 !、括号等优先级。
  3. 按抽象相等/加法规则逐步转换。

代码 / 示例

[] == ![]          // 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" 或模块/类默认严格模式。
  • 变量、参数、对象行为更严格。
  • 避免意外污染全局。

原理流程

  1. 脚本/函数声明严格模式。
  2. 引擎按严格规则检查赋值与参数。
  3. 违规直接抛错而非静默忽略。

代码 / 示例

"use strict";
// undeclaredVar = 1; // ReferenceError
function f(a, a) {}  // SyntaxError:参数重复

常见误区

  • 误区:严格模式改变类型转换规则;正解:转换规则不变,改变的是赋值、参数与 this 等容错行为。
  • 误区:模块代码需要手写 use strict;正解:ESM、类、类字段默认处于严格模式。

追问

  • Q:严格模式下普通函数 this 是什么? A:undefined,非严格模式为全局对象,见 03.2.1.4。
  • Q:严格模式能否撤销? A:一旦进入严格模式不能退回非严格,作用域边界内持续生效。