接一个用户创建接口时,我写了个工具函数:
function createUser(name, role = "user") {
return { name, role };
}
调用方从表单里取角色,没选的时候传的是 null(后端约定,空值就是 null):
createUser("张三", null); // { name: "张三", role: null }
默认值没起作用,数据库里出现了一批 role 为 null 的用户,权限判断全走异常分支。原因很直接:参数默认值只在传入 undefined 时才生效,null 是「明确给了一个空值」,不算没传。
这篇讲什么:函数的几种写法有什么实质差别、参数和返回值里容易踩的点、作用域链是怎么工作的、以及「提升」这个听起来抽象的词到底在影响什么。读完你能做到:写工具函数时默认值和空值处理不出错;能解释为什么有时候函数定义写在调用后面也能跑、有时候就报 not a function;看懂内层函数为什么能访问外层变量。
三种写法,差别不在长短
最常见的两种是函数声明和函数表达式,还有一种是箭头函数(this 的差别放在this 与 class那篇讲)。
// 函数声明
function sum(a, b) {
return a + b;
}
// 函数表达式:赋值给变量
const sum2 = function (a, b) {
return a + b;
};
// 箭头函数
const sum3 = (a, b) => a + b;
功能上它们都能算加法,真正的区别有两处:一是提升行为,二是 this。先说不那么玄的:函数声明会整体提升,函数表达式不会。
console.log(sum(1, 2)); // 3,声明在后面也能用
console.log(sum2(1, 2)); // 报错:Cannot access 'sum2' before initialization
function sum(a, b) { return a + b; }
const sum2 = function (a, b) { return a + b; };
原因在下一篇会展开:声明在代码执行前就被登记好了,表达式本质是「把一个函数值赋给变量」,变量登记了但还没赋值,所以调用时报错。这个差别在真实项目里出现过很多次:工具函数写在文件末尾,某个更早执行的初始化逻辑调用了它,模块化之后加载顺序一变就炸。
我的习惯是:顶层工具函数用函数声明,写在文件靠前的工具区;需要按条件创建、或者作为回调传出去的,用表达式或箭头函数。团队统一比个人偏好更重要,混着写最容易出问题。
还有两个细节值得知道。函数表达式可以给自己起名字,这个名字只在函数内部可见:
const fetchOrders = function fetchOrdersInner() {
// 报错堆栈里显示 fetchOrdersInner,而不是 anonymous
};
全用匿名箭头函数时,线上日志里一整片 (anonymous),很难判断是哪一层调用的。关键函数给个名字,排查时省很多事。
另一个是:别在 if 或 try 块里写函数声明。严格模式下它是块级作用域,出块就没了;非严格模式各引擎历史上处理不一致,打包合并后更难说清。要按条件选实现,用变量:
const handler = isProd ? handleProd : handleMock;
参数:默认值、剩余参数和 arguments
默认值的规则前面已经踩过一次,这里集中说清楚:
function greet(name = "访客") {
return "你好," + name;
}
greet(); // "你好,访客"
greet(undefined); // "你好,访客"
greet(null); // "你好,null",null 不触发默认值
greet(""); // "你好,",空字符串也不触发
所以接口字段转成函数参数时,判断要写完整。要么在调用前把 null 归一成 undefined,要么在函数体内用 ?? 兜底:
function createUser(name, role) {
return { name, role: role ?? "user" };
}
createUser("张三", null); // { name: "张三", role: "user" }
参数多了以后,别用一长串位置参数。调用方很容易把顺序搞反,而且看调用处根本不知道每个值是什么意思:
// 难读:true 是什么?第三个参数又是啥?
sendRequest(url, true, 3000);
// 改成对象参数,调用处自带说明
sendRequest({ url, retry: true, timeout: 3000 });
剩余参数(rest)用来收集不定数量的参数,它是真数组,能用 map、reduce:
function sum(...nums) {
return nums.reduce((total, n) => total + n, 0);
}
sum(1, 2, 3); // 6
function log(level, ...messages) {
console.log("[" + level + "]", ...messages);
}
log("warn", "库存不足", "商品 ID: 1001");
// [warn] 库存不足 商品 ID: 1001
老代码里还会见到 arguments,它是函数内建的类数组对象,能用下标和 length,但没有数组方法,而且在箭头函数里不存在。新代码用剩余参数就行。
再补两条写公共函数时会碰到的规则。默认值表达式每次调用都重新求值,而且按从左到右的顺序算,所以后面的默认值可以用前面的参数:
function pageSize(total, size = Math.min(total, 100)) {
return size;
}
pageSize(30); // 30
pageSize(500); // 100
反过来不行。function f(a = b, b = 1) 在算 a 的默认值时 b 还没初始化,直接抛 ReferenceError。默认值里也别放重活:写成 function f(cfg = loadConfig()),调用一千次就真读一千次配置。
options.timeout,调用方的对象也会变。如果函数不该改动入参,进去先解构一份新的,别直接改。返回值:不写 return 就是 undefined
这个规则简单,但组合起来会出问题。最常见的两种:
// 忘了返回值,调用方拿到 undefined
function save(data) {
api.post("/save", data); // 少了 return
}
const result = await save(payload);
if (result.ok) { ... } // 报错:Cannot read properties of undefined
// 用了箭头函数的简写,但返回的是对象
const makeUser = (name) => { name: name };
console.log(makeUser("张三")); // undefined
// 花括号被当成函数体了,要包一层括号
const makeUser2 = (name) => ({ name });
还有一个更隐蔽的:return 后面换行。JavaScript 有「自动分号插入」机制,遇到换行可能自己补分号,导致你返回的东西被截断:
function getConfig() {
return
{ retry: 3 };
}
console.log(getConfig()); // undefined
// 正确写法:左花括号跟 return 在同一行
function getConfig2() {
return { retry: 3 };
}
这个坑不常见,但排查起来很费时间,因为代码「看起来」完全正常。养成习惯:return 后面要么直接结束,要么同一行开始写返回值。
函数到底该不该有返回值,我一般按这个标准判断:这个函数是「做事」还是「算东西」。做事(发请求、写缓存、操作 DOM)可以没有返回值,但要么明确返回结果对象,要么调用方别去接;算东西必须返回,并且只做计算、不产生副作用,这种函数最好测。
异步函数还有个容易忽略的点:只要写了 async,返回值一定被包成 Promise。哪怕写 return 42,调用方拿到的也是 Promise<42>,忘了 await 就去取 .ok,拿到的是 undefined,然后报一个和真正原因完全无关的错。
构造函数是唯一例外:用 new 调用时,如果函数里返回了一个对象,这个对象会替换掉新建的实例;返回原始值则被忽略。这条规则知道就行,别在业务代码里依赖它,构造函数老老实实往 this 上挂字段。
作用域:函数能看见什么
作用域说人话就是「一个变量在哪些地方能被访问到」。JavaScript 用的是词法作用域:函数能访问哪些外部变量,在它被写出来的那一刻就定了,跟它在哪被调用没关系。
const appName = "订单系统";
function showName() {
console.log(appName); // 能读到外层的 appName
}
function outer() {
const inner = "内部变量";
function readInner() {
console.log(inner); // 能读到 outer 里的 inner
}
}
console.log(inner); // 报错:inner is not defined
查找变量的过程是从内往外一层层找,找到就用,找不到继续往外,直到全局;全局也没有就报 ReferenceError。这条从内到外的路径就是作用域链。
window 上的东西,最后才找到这里所以「函数在哪定义」很重要。同一个函数,写在文件顶层和在某个函数内部,能看到的东西完全不同。这也是为什么把工具函数随手塞进某个函数里,之后在别处用不了——它被关在那个作用域里了。
另一个常见误解是「函数内部的变量外面看不到」。这是对的,但不能反过来理解成「外面能随便改里面的东西」。函数每次调用都会创建一套新的局部变量,互不干扰:
function counter() {
let count = 0;
count++;
return count;
}
counter(); // 1
counter(); // 1,每次都是新的 count
块级作用域是另一层。let 和 const 在花括号里声明,出了块就访问不到。要注意 switch 的各个 case 共享同一个块,不包花括号就声明同名变量会报重复声明:
switch (order.status) {
case "paid": {
const label = "已支付";
console.log(label);
break;
}
case "refunded": {
const label = "已退款";
console.log(label);
break;
}
}
还有一种更隐蔽的:变量遮蔽。外层有个 id,函数参数也叫 id,函数里改的是参数,外层纹丝不动。读代码时觉得「明明赋值了」,其实赋给了另一个变量。像 id、data、index 这种名字,尤其别在内外层重复。
如果你想让这个值在多次调用之间保留,就得把变量放到函数外面,或者用闭包——下一篇就是讲这个。
提升:为什么有时能提前用,有时不能
「提升」(hoisting)指的是:代码正式执行前,引擎会先扫一遍当前作用域,把变量和函数的声明登记好。注意登记的是「名字」,不是「赋值」。
函数的处理比较简单:函数声明会被完整提升,所以在同一个作用域里,写在后面的函数可以在前面调用。变量分两种:
| 写法 | 执行到声明前访问 | 说明 |
|---|---|---|
var x = 1 | 得到 undefined | 名字登记了,赋值没执行 |
let x = 1 | 报 ReferenceError | 处在暂时性死区,还没初始化 |
const x = 1 | 报 ReferenceError | 同上,而且之后也不能重新赋值 |
function f() {} | 可以直接调用 | 函数声明整体提升 |
const f = function () {} | 报 ReferenceError | 本质是变量,只是值恰好是函数 |
还有一类提升是函数内部的:var 声明的变量会被提到函数顶部,但值不会。所以会出现「在声明之前访问得到 undefined」这种现象。这也是为什么现在都推荐 let 和 const:与其让错误静默发生,不如让它直接报出来。
补充两点。一是 class 声明:名字会被登记,但和 let 一样处在暂时性死区,在声明位置之前 new 会抛 ReferenceError,这跟函数声明完全不同,别以为「类也是函数所以能提前用」。
二是模块循环引用。A 模块顶层调用 B 的函数,B 又引用 A 的变量,执行顺序一变拿到的就是 undefined,报错只说「xxx is not a function」,很难联想到加载顺序。碰到这种先看两个模块的 import 关系,再查模块顶层有没有副作用初始化。
函数是值,所以能传来传去
在 JavaScript 里,函数和数字、字符串一样是值,可以赋给变量、放进数组、当参数传、当返回值返回。这不是语法糖,是后面所有异步、事件、数组方法的根基:
const handlers = {
save: () => console.log("保存"),
cancel: () => console.log("取消")
};
handlers.save(); // 保存
function withLog(fn) {
return function (...args) {
console.log("调用参数", args);
return fn(...args);
};
}
const loggedSum = withLog((a, b) => a + b);
loggedSum(1, 2);
// 调用参数 [1, 2]
// 返回 3
「接收函数或返回函数」的函数,通常叫高阶函数。日常用的 map、filter、setTimeout、事件监听都是这个模式。理解这一层,看很多库的 API 就不费劲了。
函数是值,比较的就是引用。两段长得一样的函数并不相等:
const a = () => 1;
const b = () => 1;
console.log(a === b); // false
所以 removeEventListener 必须传注册时那一个函数,现场再写一个匿名函数是解绑不掉的。很多「监听器越绑越多」的问题,源头就在这里。要能解绑,就把处理函数存成变量或类的字段。
完整场景走查:订单查询工具函数
前面都是零散的规则,这一节按一个真实需求从头走一遍。后台订单页要做查询工具,六个条件:页码 page、每页条数 size、状态 status、关键词 keyword、开始时间 start、结束时间 end。接口 GET /api/orders 返回 { list, total, page }。后端约定:page 从 1 开始;size 上限 100;status 不传就是全部,传了必须是 pending、paid、refunded 之一;时间用带时区的 ISO 字符串。
第一版长这样,当天就能跑通:
async function fetchOrders(page, size, status, keyword, start, end) {
const url = "/api/orders?page=" + page + "&size=" + size +
"&status=" + status + "&keyword=" + keyword +
"&start=" + start + "&end=" + end;
const res = await fetch(url);
const data = await res.json();
renderTable(data.list);
}
fetchOrders(1, 20, filter.status, filter.keyword, filter.start, filter.end);
测试环境里点几下是对的。它的问题不在语法,全在边界上:
- size 绑的是「每页条数」下拉,里面有个「全部」选项,值是 5000。后端上限 100,这个分支直接 30 秒超时,页面一直转圈。测试时没人选过它。
- filter.status 初始值是 null。模板字符串把 null 拼成了字面量 "null",后端不认,返回 0 条。用户看到「暂无数据」,第一反应是今天没订单。
- 关键词没编码。搜「A&B」时 & 把参数截断,后端实际收到 keyword=A,结果莫名其妙。
- start 和 end 在两个调用点各传一遍,其中一处写反了。区间倒置,接口正常返回 0 条,没有任何报错。
- 函数没有 return,另一个页面写
const rows = await fetchOrders(...),再用rows.length,报Cannot read properties of undefined (reading 'length')。 - 「加载更多」靠模块顶层的
let lastPage记页码。订单页和退款单页共用这个模块,两个页面来回切,页码互相覆盖。
前四条的共同点:错误都被「合法的空结果」盖住了。接口 200,页面能渲染,只是数据不对。这类问题最难查,因为根本没有报错,只能靠人发现「这不对劲」。
改法是把参数收口到一个归一化函数里,再让主函数只负责拼请求和返回结构:
function normalizeQuery(input = {}) {
const page = Math.max(1, Math.trunc(Number(input.page)) || 1);
const size = Math.min(100, Math.max(1, Math.trunc(Number(input.size)) || 20));
const status = ["pending", "paid", "refunded"].includes(input.status)
? input.status
: null;
const keyword = String(input.keyword ?? "").trim();
const start = input.start ?? null;
const end = input.end ?? null;
if (start && end && new Date(start) >= new Date(end)) {
throw new Error("开始时间必须早于结束时间");
}
return { page, size, status, keyword, start, end };
}
async function fetchOrders(input) {
const q = normalizeQuery(input);
const params = new URLSearchParams({ page: q.page, size: q.size });
if (q.status) params.set("status", q.status);
if (q.keyword) params.set("keyword", q.keyword);
if (q.start) params.set("start", q.start);
if (q.end) params.set("end", q.end);
const res = await fetch("/api/orders?" + params.toString());
if (!res.ok) throw new Error("查询订单失败:" + res.status);
const data = await res.json();
return { list: data.list, total: data.total, page: q.page };
}
调用处也跟着变了,每个值是什么意思,写在调用现场:
const result = await fetchOrders({
page: 1,
size: 20,
status: filter.status,
keyword: filter.keyword,
start: filter.start,
end: filter.end
});
对应地看:size 被夹到 100;null 走 ?? 再被 URLSearchParams 编码,不会出现字面量 "null";A&B 编码成 A%26B;start 和 end 有了名字,传反概率大幅下降;函数统一返回对象,调用方不用再判 undefined;分页状态交回调用方,模块里不留可变变量。
页码那块别放模块顶层。让调用方自己持有,或者用工厂函数返回一个带状态的查询器:下一页怎么算、关键词改了要不要重置页码,本来就属于调用方。
上线后接口 400 从每天几十条降到 0。「全部」选项改成两档:100 条,和 2000 条(前端循环拉 20 页,每页 100),再大的量走后端异步导出。这个取舍得提前跟产品说清楚。
错误现象对照
下面这张表是几个项目里真实见过的现象。排查时按「第一步查什么」走,别一上来就读源码。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
控制台报 Cannot access 'fetchOrders' before initialization |
用 const 定义的函数表达式处在暂时性死区,被更早执行的初始化代码调用了 |
对比调用行和定义行的执行顺序;看定义是不是被 if 或循环包着,导致实际没执行到 |
接口 400,Network 面板里 URL 出现 status=null 或 keyword=undefined |
拼 URL 前没归一化,null 和 undefined 被模板字符串转成了字面量 | 复制完整请求 URL 看参数;再打印入参对象的真实值 |
| 页面稳定显示「暂无数据」,接口 200 且 list 里有内容 | 函数漏写 return,调用方拿到 undefined,走了兜底分支 |
在函数最后一行打断点看返回值;搜函数体里到底有没有 return |
报 TypeError: Cannot destructure property 'page' of 'null' |
对象参数传了 null,解构的默认值只在 undefined 时生效 | 看调用方数据来源,尤其是后端把空对象返回成 null 的情况 |
| 两个页面同时查询,列表里显示的是另一个页面的数据 | 模块顶层有 let 变量被多个调用方共享,后发的请求覆盖了前一个的状态 |
搜模块顶层的 let,看有几个函数在读它、几个函数在写它 |
五条里只有第一条会主动报错,剩下四条都是「有结果但结果不对」。排查顺序应该是:先参数,再返回值,最后才怀疑业务逻辑。反过来做,容易在一个不存在的「后端 bug」上耗一下午。
边界与代价
函数没有「必须这样写」的规矩,但每种写法都有明确的代价。下面几条是我拿来判断的标准。
- 位置参数超过三个,且其中两个类型相同(start 和 end、min 和 max、from 和 to),一律改成对象参数。判断标准很简单:站在调用处,一眼看不出每个实参是什么意思,就该改。
- 递归超过一万层左右会撞上
Maximum call stack size exceeded,具体阈值跟引擎和每层帧大小有关。目录树、评论楼这种深度由数据决定的,用显式栈加循环,别递归。 - 默认值里别放有副作用的调用。
function f(cfg = loadConfig())每次调用都读配置,一秒调 200 次就是 200 次 IO,大多数人以为它只算一次。 - 高阶函数每包一层就多一次调用、多一层栈帧。五千行列表每秒渲染 60 次,每行再包两层日志装饰,每秒就多出六十万次调用。热路径上别为了「通用」加包装。
- 箭头函数不能当构造函数,没有
arguments,也没有prototype。需要new、需要看参数列表的场景,别用箭头函数。 - 别在块里写函数声明,理由前面说过:作用域归属在不同环境下不一致,出了问题极难复现。
一句话的判断标准:能在调用处读懂的签名,比「什么都能收」的通用函数更值钱。工具函数是给别人用的,可读性优先于灵活。
小结
写法怎么选
顶层工具函数用声明;回调和一次性逻辑用箭头函数;需要根据条件创建函数用表达式。别在同一个项目里混用三种风格表达同一个意思。
参数怎么处理
默认值只认 undefined,null 和 "" 都不算没传。参数超过三个改用对象;不想被改的入参先复制。
作用域和提升
函数在哪定义决定它能看见谁;声明会提前登记,表达式不会。拿不准顺序就先用 const 定义再调用,报错比静默出错好。
下面几条今天就能在控制台里验证,不用搭环境:
- 先写
console.log(sum(1, 2)),再在下面补function sum(a, b) { return a + b; },能打印出 3。然后把同样内容换成const sum2 = function (a, b) { return a + b; }并把调用写在前面,这次会报Cannot access 'sum2' before initialization。 - 写
function createUser(name, role) { return { name, role: role ?? "user" }; },分别传undefined、null、"":前两个得到 "user",空字符串保留。再换成默认参数写法,对比 null 的结果。 - 找一处四个以上位置参数的调用改成对象参数,让同事不查文档说出每个实参的含义。
下一篇讲闭包,建议顺着这篇最后一节读下去。这篇里那个 counter() 每次调用都从 0 开始的例子,只要把 count 挪到外层函数,再返回一个读它的内层函数,值就能跨调用留下来。那条线走下去就是闭包,也是防抖、私有状态、一次性缓存的共同底座。读之前可以先自己写一遍计数器,确认两次 counter() 拿到的是两个独立的数,再看下一篇为什么说「函数记得自己从哪来」。