接一个用户创建接口时,我写了个工具函数:

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);

测试环境里点几下是对的。它的问题不在语法,全在边界上:

  1. size 绑的是「每页条数」下拉,里面有个「全部」选项,值是 5000。后端上限 100,这个分支直接 30 秒超时,页面一直转圈。测试时没人选过它。
  2. filter.status 初始值是 null。模板字符串把 null 拼成了字面量 "null",后端不认,返回 0 条。用户看到「暂无数据」,第一反应是今天没订单。
  3. 关键词没编码。搜「A&B」时 & 把参数截断,后端实际收到 keyword=A,结果莫名其妙。
  4. start 和 end 在两个调用点各传一遍,其中一处写反了。区间倒置,接口正常返回 0 条,没有任何报错。
  5. 函数没有 return,另一个页面写 const rows = await fetchOrders(...),再用 rows.length,报 Cannot read properties of undefined (reading 'length')。
  6. 「加载更多」靠模块顶层的 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 定义再调用,报错比静默出错好。

下面几条今天就能在控制台里验证,不用搭环境:

  1. 先写 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。
  2. 写 function createUser(name, role) { return { name, role: role ?? "user" }; },分别传 undefined、null、"":前两个得到 "user",空字符串保留。再换成默认参数写法,对比 null 的结果。
  3. 找一处四个以上位置参数的调用改成对象参数,让同事不查文档说出每个实参的含义。

下一篇讲闭包,建议顺着这篇最后一节读下去。这篇里那个 counter() 每次调用都从 0 开始的例子,只要把 count 挪到外层函数,再返回一个读它的内层函数,值就能跨调用留下来。那条线走下去就是闭包,也是防抖、私有状态、一次性缓存的共同底座。读之前可以先自己写一遍计数器,确认两次 counter() 拿到的是两个独立的数,再看下一篇为什么说「函数记得自己从哪来」。