促销活动上线第二天,客服收到三张截图:购物车页面显示 268 元,点进结算页变成 298 元,提交订单后订单详情又回到 268 元,但实际扣款是 298。用户蒙了,开发也蒙了。查了一下午,发现这三个地方各自算了一遍价格:购物车用一份老代码,结算页复制了一份改过的新代码,订单接口又是另一份。

这类问题很少是「算法写错」,而是「同一套规则写在三个地方」。规则本身只有三条:满 200 减 30、会员再打 9 折、满 99 免运费。可一旦复制成三份,任何一次改动都会漏掉一处。要把它收拢,靠的是两样东西:清楚的条件分支,和一个能被多处调用的函数。

这篇讲 if 与提前返回、switch 和 PHP 8 的 match 有什么本质区别、循环里最容易踩的引用坑、函数参数与作用域的几条规则,最后用一个订单价格计算把整套流程走一遍。

条件分支:先处理异常,再处理正常

if / elseif / else 是最基本的写法,真正的难点不是语法,而是嵌套层数。一段代码如果缩进到第四层,读的人要在脑子里同时记住四个条件,才敢判断某一行会不会执行。常见的改法是提前返回:把不合法、不满足的情况先挡掉,主流程留在最外层。

<?php
declare(strict_types=1);

function shippingFee(int $goodsCents, bool $hasFreeCoupon): int
{
    if ($hasFreeCoupon) {
        return 0;
    }
    if ($goodsCents <= 0) {
        return 0;
    }
    if ($goodsCents >= 9900) {
        return 0;
    }
    return 1000;
}

echo shippingFee(5000, false); // 1000
echo shippingFee(12000, false); // 0
echo shippingFee(5000, true);   // 0

这段代码和一层层 else 嵌套的结果一样,但每一行都能单独读。函数只有一个出口在最后,异常分支各自返回,不用在脑子里叠条件。

在模板里写条件时,用替代语法 if (...): ... endif;,和 HTML 混排更清楚。但要注意:模板里只做「显示或不显示」的判断,别在模板里算钱、查库。计算放函数里,模板只负责输出结果。

switch 与 match:一个语句,一个表达式

老代码里常见 switch,新代码更推荐 match。它们最大的差别不在语法糖,而在两件事:比较方式和返回值。

switch

语句,不产生值,要靠给变量赋值。用松散比较(==),容易命中意外分支;每个 case 都要记得写 break,漏掉就会继续往下执行。

match(PHP 8.0+)

表达式,直接返回一个值。用严格比较(===),不会因为类型转换命中别的分支;没有 fallthrough;没匹配到且没有 default 时抛 UnhandledMatchError。

<?php
declare(strict_types=1);

function orderStatusText(string $status): string
{
    return match ($status) {
        'pending'   => '待付款',
        'paid'      => '待发货',
        'shipped'   => '已发货',
        'completed' => '已完成',
        'cancelled' => '已取消',
        default     => '未知状态',
    };
}

echo orderStatusText('paid'); // 待发货

match 不需要 break,天生就是「命中一个就结束」。多个条件可以合并写:'paid', 'shipped' => ...。它还能用 match (true) 做范围判断:

<?php
$rate = match (true) {
    $isMember && $orderCents >= 30000 => 85,
    $isMember => 90,
    default => 100,
};

这段的意思是「会员且订单满 300 元打 85 折,会员打 9 折,其他原价」。写成 if / elseif 当然也行,但 match 强制你把每个分支写成一个值,读起来更像一张规则表。

switch 的比较是松散的。当条件是字符串或数字混合来源时,'0'、0、false 之间可能串到错误的分支。新代码一律用 match;维护老代码时,如果看到 switch,先确认传给它的变量类型是否稳定。

switch 的坑不止「忘了 break」一个,但忘了 break 的现场最典型。运费规则写成这样:

$fee = 0;
switch ($status) {
    case 'pending':
        $fee = 0;
    case 'paid':
        $fee = 1000;
        break;
    default:
        $fee = 0;
}

待付款那个分支漏了 break,于是它会一路滑进「已付款」,运费变成 10 元。这类 bug 不报错、不写日志,只会让某一类订单长期多收一笔,等到对账才发现。查法很土:在分支开头各加一行 error_log('branch: paid'),跑一单待付款,日志里出现两行,就说明穿透了。

更隐蔽的是比较规则。switch 用松散比较,switch ("0") 配 case false: 会命中,因为 "0" == false 为真;switch (0) 配 case "abc": 在 PHP 8 里则不会命中。同一段 switch 在 7 和 8 上可能走不同分支,这种代码升级时最危险,因为编译能过、测试也未必覆盖。

还有一个 switch 独有的怪动作:在 switch 里写 continue,它等价于 break,只跳出 switch,不会进入下一次循环。PHP 7.3 起会提示 Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"?,但警告常被压掉。真要跳过本轮循环就写 continue 2,或者干脆把这个 switch 换成 match 加一句 if。

还有一个容易忽略的边界:match 只有 default 能兜底,没写 default 又传进来一个没覆盖的值,程序直接抛异常。这既是保护,也是风险——从数据库或接口来的状态值,永远假设它可能多出一个你没见过的。要么显式写 default,要么在外面捕获异常并记录原始值。

报错长这样,先在命令行复现,省得去翻日志:

php -r 'echo match ("1") { 1 => "int" };'
PHP Fatal error:  Uncaught UnhandledMatchError: Unhandled match case '1' in Command line code:1
Stack trace:
#0 {main}
  thrown in Command line code on line 1

Web 请求里看不到这么完整的信息。默认 display_errors=Off,用户只有 500 和一张白屏,完整栈写进错误日志:

[06-Nov-2026 10:20:41 UTC] PHP Fatal error:  Uncaught UnhandledMatchError: Unhandled match case 'refunded' in /var/www/html/src/OrderStatus.php:37
Stack trace:
#0 /var/www/html/public/order.php(14): statusText('refunded')
#1 {main}
  thrown in /var/www/html/src/OrderStatus.php on line 37

注意 Unhandled match case 'refunded' 已经把没接住的值原样打了出来,这是 match 比 switch 强的地方。修的时候别只补一个 'refunded' => '已退款',要追问「这个值是谁写进数据库的」:状态机里根本没有退款,说明问题在上游,补分支只是把脏数据藏起来。稳妥做法是加 default,在里面记一条带原始值的日志,再返回明确的兜底文案。

循环:foreach 用得最多,坑也最多

PHP 里遍历数组几乎都用 foreach。它默认遍历的是数组的副本(写时复制),所以循环里改元素不会影响原数组,除非你写引用。引用遍历是 PHP 最经典的事故来源之一:

<?php
$prices = [100, 200, 300];

foreach ($prices as &$price) {
    $price = $price * 0.9;
}
unset($price); // 这一句别省

foreach ($prices as $price) {
    echo $price . "\n";
}
// 实测输出 90 180 270

如果删掉 unset($price),第二个循环会复用同一个引用。循环结束前,$price 仍然指向第三个元素,第二次循环每遍历到一个值,都会把它写到第三个元素上,结果是第三个元素被反复覆盖,前两个值看起来正常,第三个变成最后一个遍历到的值。本机 PHP 8.3.36 实测:保留 unset() 输出 90、180、270,删掉后输出 90、180、180。表现是「数组最后一个元素莫名其妙变了」。

规则很简单:用引用遍历之后立刻 unset();更好的做法是根本不用引用,改用下标赋值,或者用 array_map() 生成新数组。

<?php
$prices = array_map(fn (int $p): int => (int) round($p * 0.9), $prices);

其他循环:for 适合明确的次数;while 适合「条件满足就一直做」;do...while 至少执行一次。break 和 continue 可以带层数,break 2 跳出两层循环,但这种写法可读性差,能拆成函数就拆成函数。

循环里最忌讳的是查数据库或调接口。一次循环查一次库,一百条数据就是一百次往返,这就是 N+1 查询,第 7 篇会专门讲怎么一次性取回来。

函数:把规则收在一个地方

函数的参数可以有默认值、类型声明和返回类型。从 PHP 8 起还可以用命名参数,调用时直接写参数名,顺序无关:

<?php
function sendNotice(string $to, string $subject, string $body, bool $async = true): bool
{
    // 示例,真实实现看具体邮件库
    return true;
}

sendNotice(
    to: 'ops@example.com',
    subject: '库存告警',
    body: 'SKU-1024 剩余 3 件',
    async: false,
);

命名参数读起来清楚,但有一个代价:参数名变成了对外约定的一部分。把 $to 改名成 $recipient,所有用命名参数调用的地方全部报错。团队里用它要约定好,要么整体用,要么整体不用。

可变参数用 ...$args 收集,调用时也可以展开数组。引用参数写成 &$value,能直接修改调用方的变量,但非常容易让调用者误判——看调用处完全不知道变量被改了。除了少数必须修改的场景(比如 preg_match 的匹配结果),尽量用返回值。

作用域要再强调一次:函数内看不到外部变量。闭包要用 use 显式捕获;箭头函数(fn)会自动捕获外层用到的变量,但只能写一个表达式。

<?php
$rate = 0.9;

$applyRate = fn (int $cents): int => (int) round($cents * $rate);
echo $applyRate(1000); // 900

$threshold = 20000;
$isBigOrder = function (int $cents) use ($threshold): bool {
    return $cents >= $threshold;
};
var_dump($isBigOrder(25000)); // bool(true)

PHP 8.1 起还有「第一类可调用语法」:strlen(...) 直接得到一个闭包,可以当参数传。它比字符串函数名更安全,静态分析工具能检查,重构时改名也不会漏。

还有一个细节:参数的默认值只能是常量表达式。function f(int $n = 1 + 2) 可以,function f(int $n = time()) 不行,会直接语法错误。PHP 8.1 起允许在默认值里写 new,比如 function nowAt(?DateTime $at = new DateTime()),但它没法表达「随时间变化的默认值」。需要依赖运行时状态的默认值,正确写法是把参数设成 null,在函数体里 $at ??= new DateTime(),这样调用方传不传、什么时候调用都清楚。

这句话不是理论,写错连 php -l 都过不去。把运行时才有的东西塞进默认值:

function createOrder(int $userId, string $no = 'ORD' . date('YmdHis')) { /* ... */ }
php -l order.php
PHP Fatal error:  Constant expression contains invalid operations in order.php on line 3

函数调用、time()、date() 都不能出现在参数默认值里。想要「不传就按当前时间生成」,就把参数设成 null,进函数体再补 if ($no === null) { $no = 'ORD' . date('YmdHis'); }。这样调用方传 null、传空串、不传,行为都由你定,不随版本变。

闭包的错误更安静。下面这段本意是捕获 20000 这个门槛:

$threshold = 20000;
$isBigOrder = function (int $cents) use ($limit): bool {
    return $cents >= $limit;
};

名字写错了,use ($limit) 里的变量在外层根本不存在。PHP 8 会在定义闭包那一行给 Warning: Undefined variable $limit,然后把 null 捕获进去;接着 $cents >= null 对任何正数都成立,所有订单都被判成大额。这条警告要是被别的日志淹了,你只会看到「满减发得特别多」,查一周也查不到这里。

就算名字写对,use 默认也是按值捕获,抓到的是闭包定义那一刻的快照。先建闭包、后改 $threshold,闭包里永远是旧值;写 use (&$threshold) 能跟着变,但等于留了一个随时被外部改掉的隐式依赖。更稳的做法是把门槛当参数传进来,调用处一眼能看见用的是哪个值。

场景走查:一套折扣规则从三份到一份

回到开头。需求方给的规则是:商品小计满 200 元减 30 元;会员在减完之后再打 9 折;运费满 99 元免,否则 10 元。第一版代码分别在购物车控制器、结算页模板和订单接口里各写了一遍,而且三份的减价顺序不一样。

第一版的问题很快暴露:运营把满减门槛从 200 改成 188,只改了结算页那份。购物车还按 200 算,于是同一个购物车,两个页面差 30 元。第二版的做法是把计算抽成一个纯函数,输入商品明细和会员标记,输出一份带明细的结果。

<?php
declare(strict_types=1);

/**
 * @param array{name: string, priceCents: int, qty: int}[] $items
 * @return array{subtotal: int, discount: int, shipping: int, total: int}
 */
function calculateOrder(array $items, bool $isMember, bool $hasFreeShipping): array
{
    $subtotal = 0;
    foreach ($items as $item) {
        $subtotal += $item['priceCents'] * $item['qty'];
    }

    // 满 200 减 30,门槛与金额集中在这里改
    $discount = $subtotal >= 20000 ? 3000 : 0;

    $afterDiscount = $subtotal - $discount;

    $rate = match (true) {
        $isMember && $afterDiscount >= 30000 => 85,
        $isMember => 90,
        default => 100,
    };
    $afterDiscount = intdiv($afterDiscount * $rate, 100);

    $shipping = match (true) {
        $hasFreeShipping => 0,
        $subtotal >= 9900 => 0,
        default => 1000,
    };

    return [
        'subtotal' => $subtotal,
        'discount' => $discount,
        'shipping' => $shipping,
        'total' => $afterDiscount + $shipping,
    ];
}

$result = calculateOrder(
    [['name' => '键盘', 'priceCents' => 19900, 'qty' => 1]],
    isMember: true,
    hasFreeShipping: false,
);

var_dump($result);

注意几个刻意的选择。金额全部用整数分,避免浮点误差;减价和打折的顺序写死在函数里,因为顺序会直接改变结果,这个顺序也写进了需求文档;运费和折扣分别算,最后统一返回明细,页面只负责展示,不再各自算一遍。

这个函数还有一个隐性好处:可以单独测试。给几个输入,断言输出,不用起页面、不用连数据库。第三版上线时,运营改门槛只需要改函数里的一个数字,三处调用同时生效。上线后又在函数里加了一行日志,记录入参和结果,对账时能直接查到某笔订单是怎么算出来的。

纯函数(同样输入永远得到同样输出,不读写外部状态)是最好测的。把计算和查库分开:函数只算,数据在外面取好传进来。第 5 篇讲面向对象、第 7 篇讲数据库时,这个分工还会出现。

引用遍历的账,最后是在线上还的。批量调价脚本一次处理 300 个 SKU,日志显示 300 条全部成功,第二天客服收到一条投诉:某个 SKU 的会员价高得离谱,正好等于这批数据里最后一个 SKU 的原价。

foreach ($skus as &$sku) {
    $sku['member_price'] = (int) round($sku['price'] * 90 / 100);
}
$sku = $defaultRow; // 循环之后还在用同名变量

循环结束后 $sku 仍然指向数组最后一个元素。后面只要出现一次 $sku = ...,不管是构造默认行、接一段查询结果,还是又写了个 foreach ($skus as $sku),值都会落到最后一个元素上。所以脏数据永远出现在那批数据的最后一条,值等于最后一次赋给 $sku 的东西。三条数据本地测不出来,三百条上线才露头。

一行命令就能看见差别:

php -r '$a = [1, 2, 3]; foreach ($a as &$v) { $v *= 2; } unset($v); var_dump($a);'  # 2 4 6
php -r '$a = [1, 2, 3]; foreach ($a as &$v) { $v *= 2; } $v = 99; var_dump($a);'     # 2 4 99

规则只有一句:引用遍历完立刻 unset();或者干脆别用引用,按下标写 $skus[$i]['member_price'] = ...,或者用 array_map() 生成新数组。批量任务里第二点更重要,它顺带避免了「改了一半失败」的中间状态。

现象、原因与第一步

现象真实原因第一步查什么
三个页面价格不一致同一套规则被复制成了多份,改动漏掉其中一处全局搜索规则常量或门槛数字,确认有几处实现
某类订单折扣没生效switch 漏写 break,或 match 没覆盖该值把输入值打印出来,逐个分支核对;给 match 加 default
数组最后一个元素被莫名改掉foreach 用了引用,结束后没 unset搜 as &$,检查后面有没有 unset()
调用函数后原变量没变参数按值传递,函数内改的是副本看函数签名有没有 &,或者改成用返回值
改名后调用处集体报错用了命名参数,参数名成了约定搜索 参数名: 形式的调用,统一替换
请求超时或 CPU 打满循环条件没有推进,或递归没有终止条件在循环里加计数器和上限日志,确认每轮状态在变化
页面加载几十秒循环里逐条查库,N+1 查询打开数据库慢查询日志,数一数一个请求发了几条 SQL
UnhandledMatchError输入值没有对应的 match 分支看异常里的值,补分支或加 default 并记录日志

边界与代价

把函数拆小不是越细越好。一个函数三行、调用要跳五个文件,读起来同样痛苦。经验值是:一个函数只做一件事,长度控制在能在一屏里看完;超过二十行就想想能不能拆,但不要为了拆而拆。

match 的限制在于每个分支只能是一个表达式。分支里要做多步处理,就得抽成函数再调用,或者退回 if。别为了用新语法硬塞,把逻辑写到看不懂。

命名参数让调用更清楚,也让重命名变成破坏性改动。参数名在公开库、团队内部接口里都算 API,改之前先搜调用点。这个代价在 PHP 8 之前不存在,用的时候要有意识。

循环里做重活无论怎么优化都危险:一次请求的时间有限,循环里发网络请求、读大文件、生成图片,很容易把 FPM 进程占死,表现为整站变慢甚至 502。这类批量任务应该拆成命令行脚本分批跑,而不是放在用户请求里。

当天能自己验证的练习

本篇的坑都能在本机复现,看到对应输出才算真的理解:

php -r '$a = [1, 2, 3]; foreach ($a as &$v) { $v *= 2; } unset($v); var_dump($a);'  # 2 4 6
php -r 'echo match (1) { "1" => "string", default => "other" };'                     # other
php -l order.php                                                                      # No syntax errors detected in order.php

第一条去掉 unset($v)、结尾补一句 $v = 99;,输出会变成 2 4 99;第二条删掉 default,就会拿到 UnhandledMatchError;第三条如果报 Constant expression... 之类的 Fatal error,说明默认值里写了函数调用。

  1. 把 shippingFee() 改写成嵌套 else 版本,再改回提前返回,体会两种写法的阅读难度。
  2. 写一个 switch 处理订单状态,故意漏一个 break,观察两个分支连续执行;再用 match 重写,确认不写 break 也不会串。
  3. 运行文章里的引用遍历例子,先保留 unset(),再删掉,对比两次输出,确认最后一个元素的变化。
  4. 把 calculateOrder() 用三组输入跑一遍:非会员 199 元、会员 199 元、会员 350 元,手算核对四个字段。
  5. 给 calculateOrder() 传入一个不存在的会员等级,观察你写的 match 是否兜住;如果没兜住,看看异常信息里有什么。

小结

三句话:条件分支先挡异常再走主流程,别把逻辑压进四层嵌套;能用 match 就不用 switch,它严格比较、有返回值、不会 fallthrough;函数的作用是把同一套规则收在一个地方,顺带让它可测试。

下一篇讲数组。今天算价格用的 $items 就是一个数组,真实项目里它还经常带着嵌套、键名、空值。下一篇会讲清 PHP 数组的「有序哈希表」本质,以及 array_filter 之后 json_encode 为什么把列表变成了对象——这个坑几乎每个写接口的人都踩过。