前几年做一个活动页,后端给的库存字段是 "12",字符串。前端同学想「还剩 12 件,加上刚选的 1 件就是 13」,写了 stock + 1。结果页面上显示还剩 121 件,运营在群里问是不是库存补错了。接口没问题,代码也没报错,问题在于写的人默认「数字就是数字」,而 JavaScript 的 + 见到字符串就改成拼接。
还有一类更隐蔽的:一个模块里拿到 user 对象,顺手改了 user.name,另一个页面的头部也跟着变了。很多人第一反应是「我明明用 const 声明的,怎么还能被改」。这两个现象背后是同一组基础知识:值有哪些类型、变量里存的是什么、什么时候会发生类型转换。
这篇讲什么:把类型、变量声明、类型转换这三件事按真实会出事的角度讲一遍。读完你能做到:看到 "1" + 1 知道结果是什么;知道 const 拦得住什么、拦不住什么;在代码评审时认出那些靠隐式转换「碰巧能跑」的写法。
类型只分两大类,但边角料不少
JavaScript 的值分成两类:原始类型(primitive)和对象。原始类型一共七种,它们的特点是不可再拆分、按值传递:
| 类型 | 例子 | 实际项目中常见的来源 |
|---|---|---|
| string 字符串 | "张三" | 表单输入、URL 参数、接口里的文本字段 |
| number 数字 | 42、3.14 | 计数、金额、时间戳 |
| boolean 布尔 | true / false | 开关、勾选状态、接口标志位 |
| undefined | undefined | 声明了没赋值、对象上没有的属性 |
| null | null | 接口显式返回「没有」 |
| symbol | Symbol("id") | 框架内部用来做唯一标记,业务代码很少直接写 |
| bigint | 10n | 超大整数,比如某些 ID,业务里也不多 |
除了这七种,剩下全是对象:数组、函数、日期、正则、Map、Set,以及你自己写的 {}。对象的特点是「引用」——变量里存的其实是一个地址,指向内存里那份数据。这一点后面单独讲。
typeof 是最常用的判断类型的手段,但它有几个历史遗留的怪结果,不知道就会写出错误的判断:
typeof "abc" // "string"
typeof 42 // "number"
typeof true // "boolean"
typeof undefined // "undefined"
typeof null // "object",语言早期的 bug,一直没改
typeof [] // "object",数组也是对象
typeof function(){} // "function",函数被特殊对待
typeof Symbol() // "symbol"
所以判断数组别用 typeof,用 Array.isArray(value);判断 null 直接写 value === null。这两个写法看着朴素,但比任何花哨的判断都可靠。
typeof NaN 是 "number",typeof 10n 是 "bigint":前者说明「类型是数字」不等于「值能用于计算」,后者说明 bigint 是单独一类,不能和 number 混算。
更常踩的是 typeof value === "object":接口返回 null 时也成立,接着写 value.id 就报 Cannot read properties of null。判断「普通对象」至少排除 null 和数组:
function isPlainObject(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
isPlainObject({}); // true
isPlainObject(null); // false
isPlainObject([]); // false
Symbol 和 bigint 出现得少:Object.keys() 和 JSON.stringify() 都不带 Symbol 键;JSON.stringify({ id: 10n }) 抛 TypeError。bigint 出接口前要转字符串。
number 只有一种,坑几乎都在小数上
JavaScript 不区分整数和小数,所有数字都是双精度浮点数。好处是写起来省事,坏处是有些十进制小数没法精确表示,算出来会带一串尾巴:
0.1 + 0.2 // 0.30000000000000004
0.1 + 0.2 === 0.3 // false
1 / 3 // 0.3333333333333333
这不是 JavaScript 独有的问题,二进制浮点都这样。业务里真正会出事的场景是金额:19.9 加几次就可能出现分位误差,最后对账差一分钱。稳妥的做法是金额统一用「分」这个整数单位来算,展示时再除以 100;或者一开始就用专门处理小数的库。别用 === 直接比较两个算出来的小数。
还有两个值要认识:NaN(Not a Number,表示「算不出一个合法数字」,比如 "abc" * 2),以及 Infinity。判断 NaN 不能用 ===,因为它和谁都不相等,包括它自己:
NaN === NaN // false
isNaN("abc") // true,会先做类型转换,容易误判
Number.isNaN(NaN) // true,只对真正的 NaN 为真
Number.isNaN("abc") // false
另外记住 Number.MAX_SAFE_INTEGER(9007199254740991)。超过这个范围的整数运算可能丢精度。遇到过有人拿它存雪花算法生成的长 ID,后半段被悄悄改掉,排查了一下午。ID 这种「看着像数字但只用来标识」的值,传的时候当字符串,最省事。
换算成业务语言:安全整数约 9007 万亿,金额用「分」存约 90 万亿元,电商够用。但订单号、雪花 ID、物流单号常是 19 位,前端随手 Number() 就会改掉末几位。判断标准:不参与加减乘除就当字符串,别为「看起来是数字」转来转去。
金额这块还有个 toFixed 的细节。它返回字符串,四舍五入也不一定符合十进制直觉:
(1.005).toFixed(2) // "1.00"
(1.005).toFixed(2) === "1.01" // false
因为 1.005 在二进制里存成了略小于它的数。所以金额最稳的链路是接口直接给整数「分」,前端只做整数运算,展示时再除以 100,别在前端做「元转分再四舍五入」的二次加工。
变量里存的到底是什么
原始类型的变量,变量里就是那个值本身。赋值就是复制一份,改新的不影响旧的:
let a = 1;
let b = a;
b = 2;
console.log(a); // 1,没被影响
对象不一样。变量里存的是「指向对象的一份引用」,你可以理解成存了张门牌号。赋值复制的是门牌号,不是房子:
const user = { name: "张三" };
const sameUser = user; // 复制的是引用
sameUser.name = "李四";
console.log(user.name); // "李四",原对象也变了
const other = { name: "张三" }; // 新写一个字面量才是新对象
other.name = "王五";
console.log(user.name); // "李四",不受影响
由此带出两个常见误解:
误解一:const 表示「不能改」
const 锁的是「这个变量名不能再指向别的值」,不是值本身。所以 const list = [] 之后 list.push(1) 完全合法,const user = {} 之后改 user.name 也合法。真想冻结对象,得用 Object.freeze(user),而且它只冻结第一层。
误解二:函数传参是「传值」或「传引用」
准确说法是「按值传递,只不过传的值是引用」。函数内部拿到的是门牌号的副本,能改房子里的东西,但不能让外面的变量指向另一栋房子。所以别指望在函数里 obj = {} 能影响调用方。
判断两个对象是否「相等」也要留心。用 === 比的是门牌号,两个内容一模一样的对象也不相等:
const a = { id: 1 };
const b = { id: 1 };
console.log(a === b); // false,两个不同的对象
console.log(JSON.stringify(a) === JSON.stringify(b)); // true,但不推荐当通用比较
「复制一个对象」这句话在实际项目里经常被理解成浅拷贝就够了。拿一个带嵌套的配置来看:
const baseConfig = { theme: "light", layout: { columns: 2 } };
const copy = { ...baseConfig };
copy.layout.columns = 3;
console.log(baseConfig.layout.columns); // 3,原对象也变了
展开运算符只复制第一层,layout 这个属性里存的还是同一个门牌号。要断开嵌套引用,可以用 structuredClone(baseConfig),现代浏览器和 Node 17 以后都有;结构简单时手写一层层复制更可控。别把 JSON.parse(JSON.stringify(obj)) 当万能深拷贝:Date 会变成字符串,undefined 和函数会直接消失,RegExp 变成空对象,有循环引用还会抛错。这些差异在订单快照、日志上报里都会变成事故。
let、const、var:默认用哪个
现在写业务代码,结论很明确:默认 const,需要重新赋值才用 let,var 除了维护老代码基本不用碰。原因不在于新旧,而在于作用域和提升的差别。
| 对比项 | var | let / const |
|---|---|---|
| 作用域 | 函数级,if 块里声明的外面也能用 | 块级,出了 {} 就失效 |
| 提升 | 声明整体提升,赋值前是 undefined | 只提升声明,赋值前访问会报错 |
| 重复声明 | 允许,后一个覆盖前一个 | 同一作用域内报错 |
| 挂到全局对象上 | 会(浏览器里变成 window 的属性) | 不会 |
「提升」这个词第一次见容易懵,说人话就是:JS 执行代码前会先扫一遍声明,把变量名登记好。用 var 时登记完顺手给了个 undefined,所以你在声明之前访问不报错,只是拿到 undefined;用 let 和 const 只登记名字,声明那行执行之前这块区域是「未初始化」的,访问直接报 ReferenceError。这个区间叫暂时性死区(TDZ)。
把这段落到具体报错上,以后看到能立刻定位:
console.log(typeof total); // ReferenceError: Cannot access 'total' before initialization
let total = 0;
console.log(typeof missing); // "undefined",没声明过的变量 typeof 不报错
const fixed; // SyntaxError: Missing initializer in const declaration
let a = 1;
let a = 2; // SyntaxError: Identifier 'a' has already been declared
注意第二行和第四行的区别:typeof 对没声明过的变量返回 "undefined",对 TDZ 里的变量照样抛错。别用 typeof 去试探还没初始化的 let。const 必须在声明时赋值;同一作用域重复声明 let 会直接语法报错,比 var 静默覆盖安全。
var 最经典的坑,几乎每个前端都被问过:
for (var i = 1; i <= 3; i++) {
setTimeout(() => console.log(i), i * 1000);
}
// 实际输出:3 3 3
// 期望输出:1 2 3
原因和「提升」有关:var 的 i 只有一个,属于函数作用域,三个回调闭包共用它;循环一秒内早就跑完了,等回调执行时 i 已经是 3。把 var 换成 let,每次循环都会创建一个新的 i,结果就是 1、2、3。这个例子会在闭包那篇再拆一次。
顺带提一个团队习惯:声明位置尽量靠近使用位置,别学老代码把所有变量堆在函数开头。读代码的人不用来回翻,也就少了一半的「这个变量到底哪来的」。
类型转换:大部分 bug 的源头
JavaScript 是弱类型语言,运算时发现类型不对,会自己转。转得对的时候你觉得方便,转得不对的时候它也不报错,只是给你一个奇怪的结果。
先看几个跑出来是什么。下面这些结果建议自己动手敲一遍,比背结论有用:
| 表达式 | 结果 | 为什么 |
|---|---|---|
"1" + 1 | "11" | + 只要一边是字符串就走拼接 |
"3" - 1 | 2 | - 只做数学运算,先把字符串转成数字 |
"3" * "2" | 6 | 同上 |
[] + [] | "" | 数组先转成空字符串 |
[] + {} | "[object Object]" | 对象转成字符串 |
null + 1 | 1 | null 转数字是 0 |
undefined + 1 | NaN | undefined 转数字是 NaN |
"0" === false | false | 严格相等不做类型转换,字符串和布尔就是不等 |
"0" == false | true | 宽松相等两边都转成数字 0 |
+ 的规则一句话能说完:只要有一个操作数是字符串,就做字符串拼接;否则做加法。对象参与运算时会先尝试变成原始值(字符串或数字),这个过程由对象自己的转换方法决定,普通对象变成 "[object Object]",数组变成逗号连接的字符串。所以 [1, 2] + "" 得到 "1,2",偶尔有人拿它做小抄,但不建议写在正式代码里。
实际开发里,我建议少依赖隐式转换,多用显式的三种写法:
// 字符串转数字
Number("12") // 12
Number("") // 0,空字符串会变 0,表单里要特别注意
Number("12px") // NaN,整串必须是合法数字
parseInt("12px", 10) // 12,只读前面的整数部分,宽容但容易误用
parseFloat("3.14元") // 3.14
// 转字符串
String(42) // "42"
(42).toString() // "42"
// 转布尔:除了下面这几种,其他都是 true
Boolean(0) // false
Boolean("") // false
Boolean(null) // false
Boolean(undefined) // false
Boolean(NaN) // false
Boolean("0") // true,注意,"0" 是非空字符串
Boolean([]) // true,空数组也是真值
Boolean({}) // true
显式转换也不是按直觉走,几个结果建议记在便签上:
Number(null) // 0
Number(undefined) // NaN
Number(" ") // 0,全是空白也算空串
Number([]) // 0
Number([1]) // 1
Number([1, 2]) // NaN
Number("0x10") // 16,带前缀的字符串会被识别
parseInt("1e3", 10) // 1,parseInt 只读到 1 就停了
parseInt("0x10", 10) // 0,radix 是 10 时不认 0x
最危险的是第一行。Number(null) 不报错,给你 0。接口价格返回 null(没定价或商品已下架)时,页面显示 ¥0.00,用户以为免费。所以转换前先判空。另外 parseInt 很宽容:"12px" 能拿到 12,"1e3" 只能拿到 1,写金额和数量时不如 Number 严格。
表单这块有个高频事故:输入框的值永远是字符串。用户没填是 "",填 0 是 "0",你写 Number(input.value) 之后两个都变成 0,就分不清「没填」和「填了 0」。所以先判空再转换,或者干脆保留字符串、到用的时候再转。
price 是 19.9 还是 "19.9"、id 是不是超过安全整数。这种一眼确认,比线上出事后复盘便宜得多。完整场景走查:活动页从能跑到敢上线
需求不复杂:双十一活动页展示 36 个 SKU,用户加购、看到合计、提交订单后端只收商品和数量。接口大概是这样:
GET /api/activity/products?activityId=A2026
{
"items": [
{
"skuId": "9007199254740993",
"title": "保温杯 500ml",
"price": "19.90",
"stock": "12",
"limit": 2
}
],
"total": 36
}
字段类型值得先盯一眼:skuId 是 16 位数字的字符串,price 和 stock 也是字符串,limit 是数字。不是文档写错,是后端从商品库、库存服务、活动配置三个地方拼出来的,类型没统一。
第一版半天写完,本地能跑:
const cart = [];
function addToCart(item) {
const line = cart.find(x => x.skuId === item.skuId);
if (line) {
line.count += 1;
} else {
item.skuId = Number(item.skuId); // 拼详情链接时转成了数字
cart.push(item); // 直接把列表项放进购物车
item.count = 1;
}
render();
}
function render() {
const total = cart.reduce((sum, line) => sum + line.price * line.count, 0);
document.querySelector("#total").textContent = "合计 ¥" + total;
}
本地拿 19.9 元买 1 件测,页面显示「合计 ¥19.9」,没问题。上线当天来了三个现象:买 3 件保温杯,合计显示 ¥59.699999999999996;加购后返回列表,卡片上多出一行「已选 1 件」,同一件商品出现在「猜你喜欢」里也带着这个数字;下单接口收到的 skuId 末位是 2 而不是 3,客服按 ID 查不到订单。
三个现象对应三个基础问题:金额用浮点数按「元」累加;购物车直接复用了列表对象的引用;拼详情链接时又把 item.skuId 转成了数字,16 位数字超过安全整数,末位被改掉,刷新列表后还会认不出已在购物车里的商品。第一版还埋着两个没当场暴露的问题:根本没校验库存,随手补一句 next > item.stock 也不能全信——"12" 会转成 12,但后端某天返回 "12件" 时转成 NaN,比较结果是 false,直接超卖;提交时把 price 一起发给后端,等于让客户端决定成交价。
改法是在数据进前端时做一次归一化,之后的代码只信任归一化后的结构:
function normalize(raw) {
const priceCents = Math.round(Number(raw.price) * 100);
const stock = Number(raw.stock);
if (raw.price == null || raw.price === "" || !Number.isFinite(priceCents) || !Number.isInteger(stock)) {
throw new Error("商品数据异常:" + raw.skuId);
}
return {
skuId: String(raw.skuId),
title: raw.title,
priceCents,
stock,
limit: Number(raw.limit ?? 0)
};
}
const cart = [];
function addToCart(item) {
const line = cart.find(x => x.skuId === item.skuId);
const next = line ? line.count + 1 : 1;
if (next > item.stock) return "库存不足";
if (item.limit > 0 && next > item.limit) return "超过限购";
if (line) line.count = next;
else cart.push({ skuId: item.skuId, title: item.title, priceCents: item.priceCents, count: 1 });
return null;
}
function totalCents() {
return cart.reduce((sum, line) => sum + line.priceCents * line.count, 0);
}
展示时再除 100:(totalCents() / 100).toFixed(2)。三件 19.90 元得到 5970 分,页面显示 ¥59.70,和收银台算的一致。提交只带 skuId 和 count,价格由后端按当前价重算,前端展示价只用于展示:
await fetch("/api/order", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
items: cart.map(({ skuId, count }) => ({ skuId, count }))
})
});
验收看三个点:36 个 SKU 全量加购,合计和手工算的分一致;改数量后,列表卡片上的「已选」从购物车重新算,商品对象本身没有 count 字段;抓包看下单请求,skuId 保持原字符串,末位不再变化。36 条数据一次返回约 18KB,归一化多花不到 1 毫秒,换来的是一眼能看懂的数据边界。
错误现象对照
下面这些现象在这类页面里反复出现,排查时先按第三列看一眼,通常比读一遍代码快:
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
合计显示 ¥59.699999999999996 | 金额用浮点数按「元」累加,二进制表示有误差 | 看合计代码是不是 price * count 直接相加,改成整数「分」 |
商品卡片莫名多出 count: 1,推荐位也显示已选 | 购物车 push(item) 存的是列表对象的同一个引用 | 搜 cart.push,确认 push 的是新建对象还是原对象 |
TypeError: item.price.toFixed is not a function | 接口 price 是字符串,字符串没有 toFixed | Network 面板看响应体里字段带不带引号 |
订单里 skuId 末位变了,按 ID 查不到商品 | 16 位以上的数字被 Number() 转成 number,超过安全整数 | 全局搜 Number(.*id 或 parseInt(.*id,对比接口原始文本 |
未定价商品显示 ¥0.00,用户以为免费 | Number(null) 得到 0,判空被跳过 | 在转换前打印原值,确认是 null、"" 还是真的 0 |
const 声明的配置对象还是被改了 | const 只锁引用,别处持有同一个对象 | 搜这个对象被传给了谁、有没有被 push 进数组 |
边界与代价
这套做法不是所有页面都值得上。内部工具、字段稳定、没有金额和长 ID,加一层归一化只会让改字段时多改一处。判断标准:出现金额、库存、长 ID、用户输入任意一类,就在入口归一化;纯展示列表直接透传。
金额用「分」也有上限:Number.MAX_SAFE_INTEGER 分约 90 万亿元,电商够用;但金融级记账、或大额数字相乘会溢出,该换字符串计算或大数库。两位小数、千万级总额以内,用分最简单,不必引入库。
深拷贝成本按数据量算:几百条、20 个字段的列表,structuredClone 通常几毫秒;5MB 以上的 JSON 别在主线程同步克隆,会明显卡,先测。更稳的是只复制要改的那一层。
还有三个边界值:
Object.freeze只冻一层,深层要递归冻结;递归冻结大对象是 O(n),适合冻配置常量,不适合冻列表数据。- bigint 不能和 number 混算,
10n + 1直接抛TypeError;也不能直接JSON.stringify,跨接口一律转字符串。 null和undefined最好约定语义:接口显式「没有」用null,字段缺失是undefined;判空写value == null一次覆盖两个。
小结
这篇真正需要带走的是三句话:
const 只锁变量指向,不锁内容;想彻底保护对象得冻结,而且冻结只管一层。+ 遇字符串就拼接,所以接口字段的类型要先确认再用。当天可以自己验证的几件事,做完比读三遍有用:
- 在控制台依次执行
typeof null、typeof []、Array.isArray([]),把结果和文中的表对一遍,确认你不会再用typeof判数组。 - 写
const price = "19.90"; const count = 3;,分别用「元」直接相乘和「分」整数相乘,看两个结果差在哪。 - 构造
const base = { layout: { columns: 2 } }; const copy = { ...base };,改copy.layout.columns,确认base也变;再用structuredClone重做一次。 - 依次打印
Number(null)、Number("")、Number(undefined),想一下你项目里价格字段为 null 时页面会显示什么。 - 随便找一个你项目里
const声明的对象,搜它有没有被 push 进数组或作为参数传出去后被改,这就是「const 拦不住」的真实例子。
这些内容不难,但它们是后面所有文章的地基。下一篇讲运算符与比较,接着拆 + 和隐式转换:为什么 0 || 99 会吞掉合法的 0、== 什么场景还能用、?. 和 ?? 解决了什么。你写下的每个默认值和判空,都建立在「值是真还是假」这个判断上。