Skip to content

4. 应用练习 – 第 1 版和第 2 版

4.1. 问题

Image

上面的表格(来自 lefigaro.fr 的一个法语页面)用于在纳税人只有工资需要申报的简化情形下计算税额。正如注释 (1) 所指出的,以这种方式计算出的税额是三项调整之前的税额:

  • 家庭系数上限,适用于高收入者;
  • 适用于低收入者的税额抵免和税额减免。

因此,税额计算包括以下步骤 [http://impotsurlerevenu.org/comprendre-le-calcul-de-l-impot/1217-calcul-de-l-impot-2019.php]:

Image

我们打算编写一个程序,在纳税人只有单一工资需要申报的简化情形下计算纳税人的税额。所使用的规则是针对 2018 年收入的 2019 年税款的规则。它们将作为贯穿本文档的指导原则:算法在应用程序的各个版本中保持不变;变化的只有其架构。

4.1.1. 应纳税额(毛税额)的计算

毛税额可以按如下方式计算。

首先,计算纳税人的份数:

  • 每位家长计 1 份;
  • 前两个孩子每人计 1/2 份;
  • 之后的每个孩子各计 1 份。

因此份数为:

  • nbShares = 1 + nbChildren * 0.5 + (nbChildren - 2) * 0.5(如果雇员未婚);
  • nbShares = 2 + nbChildren * 0.5 + (nbChildren - 2) * 0.5(如果已婚);

其中 nbChildren 是子女数,项 (子女数 - 2) * 0.5 只在有三个或更多子女时适用。接下来:

  • 应税收入 R 的计算公式为 R = 0.9 * S,其中 S 是年薪;
  • 计算家庭系数 QF = R / nbShares:
  • 根据以下数据(2019 年)计算毛税额 I:
field1(QF 的阈值)
field2(coeffR)
field3(coeffN)
9964
0
0
27,519
0.14
1,394.96
73,779
0.3
5,798
156,244
0.41
13,913.69
0
0.45
20,163.45

每一行有 3 个字段:field1、field2、field3。要计算税额 I,先找到第一个满足 QF <= field1 的行,并使用该行的值。例如,对于一位已婚、有两个子女、年薪 S 为 50,000 欧元的雇员:

  • 应税收入:R = 0.9 * S = 45,000;
  • 份数:nbShares = 2 + 2 * 0.5 = 3;
  • 家庭系数:QF = 45,000 / 3 = 15,000。

第一个满足 QF <= field1 的行如下:

27519    0.14    1394.96

于是税额 I 等于 0.14*R – 1,394.96*nbShares=[0.14*45000-1394.96*3]=2,115。税额向下取整到欧元。

如果从第一行起就满足条件 QF <= field1,则税额为零。

如果 QF 使得条件 QF <= field1 始终不满足,则使用最后一行的系数。在这种情况下:

0    0.45    20163.45

由此得到毛税额 I = 0.45*R – 20,163.45*nbShares。

4.1.2. 家庭系数上限

Image

为了确定家庭系数 QF 的上限是否适用,我们重新计算不计入子女的毛税额。仍以那位已婚、有两个子女、年薪 S 为 50,000 欧元的雇员为例:

  • 应税收入:R = 0.9 * S = 45,000;
  • 份数:nbShares = 2(不再计入子女);
  • 家庭系数:QF = 45,000 / 2 = 22,500。

第一个满足 QF <= field1 的行如下:

27519    0.14    1394.96

于是税额 I 等于 0.14*R – 1,394.96*nbShares=[0.14*45000-1394.96*2]=3,510。

  • 与子女相关的收入上限:1,551 * 2 = 3,102 欧元;
  • 最低税额:3,510 – 3,102 = 408 欧元。

3 份时的毛税额,即前面已算出的 2,115 欧元,高于最低税额 408 欧元,因此这里不适用家庭系数上限。

一般来说,毛税额为 max(tax1, tax2),其中:

  • [tax1]:是计入子女计算的毛税额;
  • [tax2]:是不计入子女计算、并扣除与子女相关的最高减额(这里是每半份 1,551 欧元)后的毛税额。

4.1.3. 税额抵免的计算

Image

仍以那位已婚、有两个子女、年薪 S 为 50,000 欧元的雇员为例:

上一步得到的毛税额(2,115)低于夫妇适用的 2,627 欧元(单身者为 1,595 欧元):因此适用税额抵免。其计算如下:

  • 抵免额 = 阈值(夫妇=1,970 / 单身=1,196)- 0.75 * 毛税额;
  • 抵免额 = 1,970 – 0.75 × 2,115 = 383.75,向上取整为 384 欧元;
  • 新的毛税额 = 2,115 – 384 = 1,731 欧元。

4.1.4. 税额减免的计算

Image

低于某一阈值时,对前面各步计算得到的毛税额适用 20% 的减免。2019 年的阈值如下:

  • 单身:21,037 欧元;
  • 夫妇:42,074 欧元(上面示例中使用的数字 37,968 似乎有误)。

这个阈值要加上如下数值:3,797 * (由子女贡献的半份数)。

仍以那位已婚、有两个子女、年薪 S 为 50,000 欧元的雇员为例:

  • 他的应税收入(45,000 欧元)低于阈值(42,074 + 2 × 3,797)= 49,668 欧元;
  • 因此他有权享受 20% 的税额减免:1,731 * 0.2 = 346.2 欧元,向上取整为 347 欧元;
  • 纳税人的毛税额变为:1,731 – 347 = 1,384 欧元。

4.1.5. 净税额的计算

我们的计算到此结束:应缴净税额将是 1,384 欧元。实际上,纳税人还可能有资格享受其他扣除,特别是向公益或公共利益组织捐赠的扣除。

4.1.6. 高收入者

我们前面的示例适用于大多数雇员。但是,高收入者的税额计算有所不同。

4.1.6.1. 年收入 10% 扣除额的上限

在大多数情况下,应税收入用公式 R = 0.9 × S 计算,其中 S 是年薪。这称为 10% 扣除。这项扣除是有上限的。2019 年:

  • 不得超过 12,502 欧元;
  • 不得低于 437 欧元。

考虑一位未婚、没有子女、年薪为 200,000 欧元的雇员:

  • 10% 的扣除额为 200,000 欧元 > 12,502 欧元。因此它被限制在 12,502 欧元。

4.1.6.2. 家庭系数上限

我们来看一个适用上面“家庭系数上限”一节所述上限的例子:一对夫妇,有三个子女,年收入为 100,000 欧元。让我们再次走一遍计算步骤:

  • 10% 的扣除额为 10,000 欧元 < 12,502 欧元。因此应税收入 R 为 100,000 – 10,000 = 90,000 欧元;
  • 这对夫妇的份数为 nbShares = 2 + 0.5 × 2 + 1 = 4 份;
  • 因此他们的家庭系数为 QF = R / nbShares = 90,000 / 4 = 22,500 欧元;
  • 他们计入子女的毛税额 I1 为 I1 = 0.14 × 90,000 − 1,394.96 × 4 = 7,020 欧元;
  • 他们不计入子女的毛税额 I2:
    • QF = 90,000 / 2 = 45,000 欧元;
    • I2 = 0.3 × 90,000 − 5,798 × 2 = 15,404 欧元;
    • 家庭系数上限规则规定,子女带来的好处不能超过(1,551 × 4 个半份)= 6,204 欧元。然而,在这个例子中,I2-I1 = 15,404 – 7,020 = 8,384 欧元,大于 6,204 欧元;
    • 因此毛税额被重新计算为 I3 = I2-6204 = 15,404 - 6,204 = 9,200 欧元。

这对夫妇既不享受抵免也不享受减免,他们的最终税额将是 9,200 欧元。

4.1.7. 官方数据

税额计算很复杂。在本文档中,将通过示例来说明这一过程。官方结果来自税务机关 2019 年的模拟器 [https://www3.impots.gouv.fr/simulateur/calcul_impot/2019/simplifie/index.htm]:

纳税人
官方结果
本文档算法的结果
有 2 个子女、年收入 55,555 欧元的夫妇
税额 = 2,815 欧元
税率 = 14%
税额 = 2,814 欧元
税率 = 14%
有 2 个子女、年收入 50,000 欧元的夫妇
税额 = 1,385 欧元
抵免 = 384 欧元
减免 = 346 欧元
税率 = 14%
税额 = 1,384 欧元
抵免 = 384 欧元
减免 = 347 欧元
税率 = 14%
有 3 个子女、年收入 50,000 欧元的夫妇
税额 = 0 欧元
抵免 = 720 欧元
减免 = 0 欧元
税率 = 14%
税额 = 0 欧元
抵免 = 720 欧元
减免 = 0 欧元
税率 = 14%
有 2 个子女、年收入 100,000 欧元的单身者
税额 = 19,884 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 41%
税额 = 19,884 欧元
附加税额 = 4,480 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 41%
有 3 个子女、年收入 100,000 欧元的单身者
税额 = 16,782 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 41%
税额 = 16,782 欧元
附加税额 = 7,176 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 41%
有 3 个子女、年收入 100,000 欧元的夫妇
税额 = 9,200 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 30%
税额 = 9,200 欧元
附加税额 = 2,180 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 30%
有 5 个子女、年收入 100,000 欧元的夫妇
税额 = 4,230 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 14%
税额 = 4,230 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 14%
无子女、年收入 100,000 欧元的单身者
税额 = 22,986 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 41%
税额 = 22,986 欧元
附加税额 = 0 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 41%
有 2 个子女、年收入 30,000 欧元的夫妇
税额 = 0 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 0%
税额 = 0 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 0%
无子女、年收入 200,000 欧元的单身者
税额 = 64,211 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 45%
税额 = 64,210 欧元
附加税额 = 7,498 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 45%
有 3 个子女、年收入 200,000 欧元的夫妇
税额 = 42,843 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 41%
税额 = 42,842 欧元
附加税额 = 17,283 欧元
抵免 = 0 欧元
减免 = 0 欧元
税率 = 41%

在上面的示例中,“附加税额”指高收入者由于两个因素而多缴的金额:

  • 年收入 10% 扣除额的上限;
  • 家庭系数的上限。

这个指标无法核实,因为税务机关的模拟器没有提供它。

我们可以看到,本文档的算法每次都能算出正确的税额,只是有 1 欧元的误差。这一误差源于舍入。所有的金额都经过了舍入:有时向上取整到下一个欧元,有时向下取整到欧元。由于作者不了解官方的舍入规则,本文档算法中的金额是这样舍入的:

  • 抵免和减免向上取整到下一个欧元;
  • 附加税额和最终税额向下取整到欧元。

在下一节中,将进行测试以验证结果的有效性。这些测试将使用上表中的示例进行,可接受的误差为 1 欧元。

4.2. 脚本的目录结构

应用程序的前两个版本位于 [scripts-console/tax] 文件夹中:

tax
├── version-01
│   ├── main.php
│   ├── results.txt
│   ├── taxpayersdata.txt
│   └── verified-results.txt
└── version-02
    ├── main.php
    ├── results.txt
    ├── taxadmindata.json
    └── taxpayersdata.txt

作为参考,文件 [verified-results.txt] 包含使用官方模拟器对文件 [taxpayersdata.txt] 中的纳税人所得到的结果。

4.3. 第 1 版

4.3.1. 算法

我们给出第一个程序,其中:

  • 计算税额所需的数据以数组和常量的形式硬编码在程序中;
  • 纳税人数据(婚姻状况、子女数、工资)存放在第一个文本文件 [taxpayersdata.txt] 中;
  • 税额计算的结果(婚姻状况、子女数、工资、税额等)存放在第二个文本文件 [results.txt] 中。

数据文件 [taxpayersdata.txt] (是否已婚、子女数、工资)如下:

yes,2,55555
yes,2,50000
yes,3,50000
no,2,100000
no,3,100000
yes,3,100000
yes,5,100000
no,0,100000
yes,2,30000
no,0,200000
yes,3,200000

脚本 [version-01/main.php] 的主程序如下:

<?php

// 函数参数和结果的严格类型
declare(strict_types=1);

// 全局常量
const HALF_SHARE_QF_CEILING = 1551;
const SINGLE_INCOME_CEILING_FOR_REDUCTION = 21037;
const COUPLE_INCOME_CEILING_FOR_REDUCTION = 42074;
const HALF_SHARE_REDUCTION_VALUE = 3797;
const SINGLE_DISCOUNT_CEILING = 1196;
const COUPLE_DISCOUNT_CEILING = 1970;
const COUPLE_TAX_CEILING_FOR_DISCOUNT = 2627;
const SINGLE_TAX_CEILING_FOR_DISCOUNT = 1595;
const TEN_PERCENT_ALLOWANCE_MAX = 12502;
const TEN_PERCENT_ALLOWANCE_MIN = 437;

// 局部常量的定义
$DATA = "taxpayersdata.txt";
$RESULTS = "results.txt";
$limits = [9964, 27519, 73779, 156244, 0];
$coeffR = [0, 0.14, 0.3, 0.41, 0.45];
$coeffN = [0, 1394.96, 5798, 13913.69, 20163.45];

// 打开数据文件
$data = is_readable($DATA) ? fopen($DATA, "r") : false;
if ($data === false) {
    print "Unable to open the data file [$DATA] for reading\n";
    exit;
}

// 打开结果文件
$results = fopen($RESULTS, "w");
if ($results === false) {
    print "Unable to create the results file [$RESULTS]\n";
    exit;
}

// 我们处理数据文件的当前行
while (($line = fgets($data, 100)) !== false) {
    // 我们删除可能存在的行尾标记
    $line = cutNewLineChar($line);
    // 我们获取组成 $line 的 3 个字段 married,children,salary
    [$married, $children, $salary] = explode(",", $line);
    $married = strtolower($married);
    $children = (int) $children;
    $salary = (int) $salary;
    // 我们计算税款
    $result = calculateTax($married, $children, $salary, $limits, $coeffR, $coeffN);
    // 我们把结果写入结果文件
    $result = ["married" => $married, "children" => $children, "salary" => $salary] + $result;
    fputs($results, json_encode($result, JSON_UNESCAPED_UNICODE) . "\n");
    // 下一条数据
}
// 我们关闭文件
fclose($data);
fclose($results);
print "The results have been saved in the file [$RESULTS]\n";

// 结束
exit;

// --------------------------------------------------------------------------
function cutNewLineChar(string $line): string
{
    // 如果 $line 存在行尾标记,则将其删除
    // (Windows 上是 \r\n,Unix 上是 \n)
    return rtrim($line, "\r\n");
}

说明:

  • 第 4 行:我们强制严格遵守参数类型和函数返回值类型;
  • 第 7–16 行:定义计算税额所需的所有常量。关键字 [const] 定义一个全局常量,在整个脚本中都可以访问,包括在函数内部。PHP 7 课程使用的是函数 [define("HALF_SHARE_QF_CEILING", 1551)],它做同样的事,现在仍然存在。[const] 可读性更好,并且允许编辑器检查常量的名称。按惯例,常量名使用大写字母;
  • 第 19 行:包含纳税人数据(是否已婚、子女数、工资)的文本文件的名称;
  • 第 20 行:包含税额计算结果的文本文件的名称;
  • 第 21–23 行:三个数据表,定义了税额计算中所用的各个税档。它们就是“毛税额的计算”一节中表格的三列;
  • 第 26–30 行:使用 [r] 以读模式打开纳税人数据文件。函数 [is_readable] 首先检查文件是否存在并且可读:如果不是,则把 [$data] 设为 [false]。这样可以避免文件缺失时 [fopen] 发出的警告。如果文件无法打开,函数 [fopen] 同样返回值 [false] ;
  • 第 33–37 行:使用 [w] 以写模式打开结果文件;
  • 第 40–54 行:循环读取纳税人数据文件中的各行(是否已婚、子女数、工资);
  • 第 40 行:函数 [fgets] 最多读取 100 个字符,并在遇到第一个行尾标记时停止。这里所有行都不到 100 个字符。如果遇到行尾字符,它会包含在返回的字符串中。到达文件末尾时,函数 [fgets] 返回值 [false];
  • 第 42 行:去掉行尾字符。文件 [taxpayersdata.txt] 是在 Windows 中创建的:其各行以两个字符 \r\n 结尾;
  • 第 44 行:取出这一行的各个组成部分(是否已婚、子女数、工资)。它们是三个字符串;
  • 第 45–47 行:婚姻状况被转换为小写,子女数和工资被转换为整数。这些显式转换是必要的:在严格模式下,函数 [calculateTax] 不会接受字符串 "2" 作为其参数 [int $children];
  • 第 49 行:计算税额。结果以关联数组的形式返回。请注意,工资是一个 [int],它被传给 [float $salary] 参数(属于 [calculateTax] 函数):这是严格模式下唯一允许的转换;
  • 第 51 行:键 [married, children, salary] 被添加到之前取得的数组的开头。应用于两个关联数组的 + 运算符返回一个包含这两个数组元素的数组;
  • 第 52 行:结果以 JSON 字符串的形式存入结果文件,每个纳税人占一行;
  • 第 56–57 行:纳税人数据文件处理完毕后,关闭这些文件;
  • 第 64 行:这个函数用于去掉 [$line] 字符串中一行的行尾字符。行尾字符在 Windows 系统上是字符串 "\r\n",在 Unix 系统上是 "\n"。结果是去掉了行尾字符的输入字符串。

函数 [calculateTax] 如下:

// 税款计算
// --------------------------------------------------------------------------
function calculateTax(string $married, int $children, float $salary, array $limits, array $coeffR, array $coeffN): array
{
    // $married:是、否
    // $children:子女数
    // $salary:年薪
    // $limits、$coeffR、$coeffN:用于计算税款的数据数组
    //
    // 计算有子女时的税款
    $result1 = calculateTax2($married, $children, $salary, $limits, $coeffR, $coeffN);
    $tax1 = $result1["tax"];
    // 计算没有子女时的税款
    if ($children !== 0) {
        $result2 = calculateTax2($married, 0, $salary, $limits, $coeffR, $coeffN);
        $tax2 = $result2["tax"];
        // 应用家庭系数上限
        if ($children < 3) {
            // 前 2 个子女适用 HALF_SHARE_QF_CEILING 欧元
            $tax2 = $tax2 - $children * HALF_SHARE_QF_CEILING;
        } else {
            // 前 2 个子女适用 HALF_SHARE_QF_CEILING 欧元,之后的子女加倍
            $tax2 = $tax2 - 2 * HALF_SHARE_QF_CEILING - ($children - 2) * 2 * HALF_SHARE_QF_CEILING;
        }
    } else {
        $tax2 = $tax1;
        $result2 = $result1;
    }
    // 我们取较高的税款及其对应的税率和速算扣除数
    if ($tax1 > $tax2) {
        $tax = $tax1;
        $rate = $result1["rate"];
        $surcharge = $result1["surcharge"];
    } else {
        $surcharge = $tax2 - $tax1 + $result2["surcharge"];
        $tax = $tax2;
        $rate = $result2["rate"];
    }
    // 计算可能的减免
    $discount = getDiscount($married, $salary, $tax);
    $tax -= $discount;
    // 计算可能的税额减免
    $reduction = getReduction($married, $salary, $children, $tax);
    $tax -= $reduction;
    // 结果
    return [
        "tax" => (int) floor($tax),
        "surcharge" => (int) $surcharge,
        "discount" => (int) $discount,
        "reduction" => (int) $reduction,
        "rate" => $rate,
    ];
}

说明:

  • 第 81 行:计算包含被抚养人在内的毛税额。结果的形式为 [["tax" => $tax, "surcharge" => $surcharge, "rate" => $coeffR[$i]]],其中:
    • [tax]:毛税额;
    • [surcharge]:附加税额(如果有)。当 10% 的扣除额超过 12,502 欧元的上限时适用;
    • [rate]:纳税人的税率;
  • 第 82 行:应缴的毛税额 [$tax1] ;
  • 第 84–85 行:如果纳税人至少有一个子女,则使用相同的数据但假设有 0 个子女重新计算税额。这第二次计算是必要的,用于确定因有子女而减少的税额是否超过某个上限;
  • 第 86 行:应缴的毛税额 [$tax2] ;
  • 第 88–94 行:对于毛税额 [$tax2],现在要考虑子女:子女贡献的每个半份会使税额减少 [HALF_SHARE_QF_CEILING] 欧元。前两个子女每人贡献一个半份;其后的子女每人贡献一整份,即总共两个半份;
  • 第 96–97 行:纳税人没有子女的情形。这时无需计算 [$tax2] ,它等于 [$tax1];
  • 第 100–108 行:已经算出了两个毛税额:[tax1, tax2]。税务机关取其中较高的一个。由此得到的毛税额为 [$tax];
  • 第 110–111 行:毛税额 [$tax] 可能适用抵免;
  • 第 113–114 行:毛税额 [$tax] 可能适用减免;
  • 第 116–122 行:[$tax] 现在是应缴的净税额。返回结果。计算使用的是实数([float]):函数 [floor] (向下取整到整数)和 [ceil] (向上取整到整数)返回的也是实数。我们使用 [(int)] 把金额转换为整数,使其显示时不带小数部分。税率仍然是实数。

函数 [calculateTax2] 如下:

// --------------------------------------------------------------------------
function calculateTax2(string $married, int $children, float $salary, array $limits, array $coeffR, array $coeffN): array
{
    // $married:是、否
    // $children:子女数
    // $salary:年薪
    // $limits、$coeffR、$coeffN:用于计算税款的数据数组
    //
    // 份数
    if ($married === "yes") {
        $nbShares = $children / 2 + 2;
    } else {
        $nbShares = $children / 2 + 1;
    }
    // 从第 3 个子女起每个子女 1 份
    if ($children >= 3) {
        // 从第 3 个子女起每个子女再加半份
        $nbShares += 0.5 * ($children - 2);
    }
    // 应纳税所得额
    $taxableIncome = getTaxableIncome($salary);
    // 附加额
    $surcharge = floor($taxableIncome - 0.9 * $salary);
    // 为了处理舍入问题
    if ($surcharge < 0) {
        $surcharge = 0;
    }
    // 家庭系数
    $quotient = $taxableIncome / $nbShares;
    // 放在 limits 数组末尾,以终止后面的循环
    $limits[count($limits) - 1] = $quotient;
    // 计算税款
    $i = 0;
    while ($quotient > $limits[$i]) {
        $i++;
    }
    // 由于我们把 $quotient 放在了 $limits 数组的末尾,前面的循环
    // 不会越过 $limits 数组
    // 现在可以计算税款了
    $tax = floor($taxableIncome * $coeffR[$i] - $nbShares * $coeffN[$i]);
    // 结果
    return ["tax" => $tax, "surcharge" => $surcharge, "rate" => $coeffR[$i]];
}

说明:

  • 这里,税额是使用所谓的累进税率表计算的;
  • 第 134–142 行:计算纳税人的份数;
  • 第 145 行:应税收入通过一个函数计算。正如我们所见,它并不总是 0.9*annualSalary。事实上,10% 的扣除额有 12,502 欧元的上限;
  • 第 147 行:如果应税收入超过 0.9*annualSalary,则计算可能的附加税额;
  • 第 149–151 行:修正由于舍入误差,结果有时为 [$surcharge=-1] 的情况;
  • 第 153 行:家庭系数;
  • 第 155–160 行:这个系数用于确定纳税人所属的税档。我们在 [$limits] 中查找第一个 大于或等于该系数的元素。该系数被存放在 [$limits] 的最后一个元素中(该元素原为 0):因此 [while] 循环最迟会在这最后一个元素处停止。由于数组 [$limits] 是按值传递的,这个修改只影响函数的局部副本;
  • 第 164 行:确定了纳税人所属的税档之后,就可以计算其毛税额。函数 [floor($x)] 返回不大于 [$x] 的最大整数;
  • 第 166 行:返回计算得到的信息。

函数 [getTaxableIncome] 如下:

// taxableIncome=annualSalary-allowance
// 扣除额有下限和上限
function getTaxableIncome(float $salary): float
{
    // 按工资的 10% 扣除
    $allowance = 0.1 * $salary;
    // 此扣除额不能超过 TEN_PERCENT_ALLOWANCE_MAX
    if ($allowance > TEN_PERCENT_ALLOWANCE_MAX) {
        $allowance = TEN_PERCENT_ALLOWANCE_MAX;
    }
    // 扣除额不能低于 TEN_PERCENT_ALLOWANCE_MIN
    if ($allowance < TEN_PERCENT_ALLOWANCE_MIN) {
        $allowance = TEN_PERCENT_ALLOWANCE_MIN;
    }
    // 应纳税所得额
    $taxableIncome = $salary - $allowance;
    // 结果
    return floor($taxableIncome);
}

说明:

  • 第 174 行:标准扣除额为年薪的 10%;
  • 第 176–178 行:扣除额不能超过最高扣除额 [TEN_PERCENT_ALLOWANCE_MAX];
  • 第 180–182 行:扣除额不能低于最低扣除额 [TEN_PERCENT_ALLOWANCE_MIN];
  • 第 184–186 行:计算应税收入,使用函数 [floor] 向下取整到欧元。

函数 [getDiscount] 如下:

// 计算可能的减免
function getDiscount(string $married, float $salary, float $taxes): float
{
    // 开始时,减免为零
    $discount = 0;
    // 可获得减免的税款最高金额
    $taxCeilingForDiscount = $married === "yes" ? COUPLE_TAX_CEILING_FOR_DISCOUNT : SINGLE_TAX_CEILING_FOR_DISCOUNT;
    if ($taxes < $taxCeilingForDiscount) {
        // 减免的最高金额
        $discountCeiling = $married === "yes" ? COUPLE_DISCOUNT_CEILING : SINGLE_DISCOUNT_CEILING;
        // 理论减免额
        $discount = $discountCeiling - 0.75 * $taxes;
        // 减免额不能超过税款金额
        if ($discount > $taxes) {
            $discount = $taxes;
        }
        // 减免额不得小于 0
        if ($discount < 0) {
            $discount = 0;
        }
    }
    // 结果
    return ceil($discount);
}

说明:

  • 第 195 行:有资格享受抵免的毛税额上限。这个金额对单身纳税人和夫妇不同;
  • 第 196 行:纳税人是否有资格享受抵免;
  • 第 200 行:抵免公式。[$discountCeiling] 是抵免额的上限。这个上限在第 198 行计算。同样,它取决于纳税人的状态——已婚还是单身;
  • 第 202–204 行:抵免额不能超过应缴的毛税额。例如,当 [$taxes] 等于 0 时就是这种情况;
  • 第 206–208 行:避免出现负的抵免额;
  • 第 211 行:抵免额向上取整到下一个欧元。

函数 [getReduction] 如下:

// 计算可能的减税
function getReduction(string $married, float $salary, int $children, float $taxes): float
{
    // 有资格享受 20% 减税的收入上限
    $incomeCeilingForReduction = $married === "yes" ? COUPLE_INCOME_CEILING_FOR_REDUCTION : SINGLE_INCOME_CEILING_FOR_REDUCTION;
    $incomeCeilingForReduction += $children * HALF_SHARE_REDUCTION_VALUE;
    if ($children > 2) {
        $incomeCeilingForReduction += ($children - 2) * HALF_SHARE_REDUCTION_VALUE;
    }
    // 应纳税所得额
    $taxableIncome = getTaxableIncome($salary);
    // 减税
    $reduction = 0;
    if ($taxableIncome < $incomeCeilingForReduction) {
        // 20% 减税
        $reduction = 0.2 * $taxes;
    }
    // 结果
    return ceil($reduction);
}

说明:

  • 第 218–222 行:要有资格享受税额减免,应税收入(第 224 行)必须低于这里计算出的阈值。子女每贡献一个半份,这个阈值就增加 [HALF_SHARE_REDUCTION_VALUE] ;
  • 第 227–230 行:如果纳税人满足条件,就有权享受 20% 的税额减免(第 229 行);
  • 第 232 行:减免额向上取整到下一个欧元。

4.3.2. 结果

在 [version-01] 文件夹中打开的终端里运行该脚本:

> php main.php
The results have been saved in the file [results.txt]

包含结果的 [results.txt] 文件(是否已婚、子女数、工资、税额、附加税额、抵免、减免、税率)如下:

{"married":"yes","children":2,"salary":55555,"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"yes","children":2,"salary":50000,"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}
{"married":"yes","children":3,"salary":50000,"tax":0,"surcharge":0,"discount":720,"reduction":0,"rate":0.14}
{"married":"no","children":2,"salary":100000,"tax":19884,"surcharge":4480,"discount":0,"reduction":0,"rate":0.41}
{"married":"no","children":3,"salary":100000,"tax":16782,"surcharge":7176,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":3,"salary":100000,"tax":9200,"surcharge":2180,"discount":0,"reduction":0,"rate":0.3}
{"married":"yes","children":5,"salary":100000,"tax":4230,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"no","children":0,"salary":100000,"tax":22986,"surcharge":0,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":2,"salary":30000,"tax":0,"surcharge":0,"discount":0,"reduction":0,"rate":0}
{"married":"no","children":0,"salary":200000,"tax":64210,"surcharge":7498,"discount":0,"reduction":0,"rate":0.45}
{"married":"yes","children":3,"salary":200000,"tax":42842,"surcharge":17283,"discount":0,"reduction":0,"rate":0.41}

计算出的税额(2814、1384、0、19884、16782、9200、4230、22,986、0、64,210、42,842)就是官方数据表中“本文档算法的结果”一列中的数字:它们与使用税务机关模拟器得到的结果相符,误差在 1 欧元以内。请注意,在 PHP 7 的运行结果中,[children] 和 [salary] 的值是字符串(“2”、“55555”):PHP 8 版本在计算之前把它们转换成了整数,而 JSON 文件把它们保存为数字。

4.3.3. 结论

即使在被认为简单的情形下,税额的计算算法也是复杂的。我们不会在这里再回头讨论它。在不同的版本中,尽管呈现上有一些变化,它的核心将保持不变。因此我们只对这些变化加以说明。

4.4. 第 2 版

4.4.1. 变化

在上一版中,计算税额所需的数据以常量和数组的形式硬编码。应避免这种做法。在新版本中,这些数据被外部化到位于脚本旁边的 JSON 文件 [taxadmindata.json] 中:

1
2
3
4
5
version-02
├── main.php
├── results.txt
├── taxadmindata.json
└── taxpayersdata.txt

文件 [taxadmindata.json] 的内容如下:

{
    "limits": [9964, 27519, 73779, 156244, 0],
    "coeffR": [0, 0.14, 0.3, 0.41, 0.45],
    "coeffN": [0, 1394.96, 5798, 13913.69, 20163.45],
    "HALF_SHARE_QF_CEILING": 1551,
    "SINGLE_INCOME_CEILING_FOR_REDUCTION": 21037,
    "COUPLE_INCOME_CEILING_FOR_REDUCTION": 42074,
    "HALF_SHARE_REDUCTION_VALUE": 3797,
    "SINGLE_DISCOUNT_CEILING": 1196,
    "COUPLE_DISCOUNT_CEILING": 1970,
    "COUPLE_TAX_CEILING_FOR_DISCOUNT": 2627,
    "SINGLE_TAX_CEILING_FOR_DISCOUNT": 1595,
    "TEN_PERCENT_ALLOWANCE_MAX": 12502,
    "TEN_PERCENT_ALLOWANCE_MIN": 437
}

它包含三个表 [limits, coeffR, coeffN] 以及第 1 版中的常量,名称相同。

新版本 [version-02/main.php], 如下(未显示的函数与第 1 版代码相同,只是多了参数 [$taxAdminData]):

<?php

// 严格遵守所声明的函数参数和结果的类型
declare(strict_types=1);

// 常量的定义
$TAXPAYERSDATA = "taxpayersdata.txt";
$RESULTS = "results.txt";
$TAXADMINDATA = "taxadmindata.json";

// 我们获取税务数据文件的内容
$fileContents = is_readable($TAXADMINDATA) ? file_get_contents($TAXADMINDATA) : false;
$error = false;
$message = "";
// 出错?
if ($fileContents === false) {
    // 我们记录错误
    $error = true;
    $message = "The data file [$TAXADMINDATA] does not exist";
}

if (!$error) {
    // 文件内容是有效的 JSON 吗?
    if (json_validate($fileContents)) {
        // 我们把税务数据文件的 JSON 代码取回到一个关联数组中
        $taxAdminData = json_decode($fileContents, true);
    } else {
        // 我们记录错误
        $error = true;
        $message = "The JSON data file [$TAXADMINDATA] could not be processed correctly";
    }
}

// 出错?
if ($error) {
    // 显示错误消息然后停止
    print "$message\n";
    exit;
}

// 打开结果文件
$results = fopen($RESULTS, "w");
if ($results === false) {
    print "Unable to create the results file [$RESULTS]\n";
    // 退出
    exit;
}

// 打开纳税人数据文件
$taxpayersdata = is_readable($TAXPAYERSDATA) ? fopen($TAXPAYERSDATA, "r") : false;
if ($taxpayersdata === false) {
    print "Unable to open the taxpayers file [$TAXPAYERSDATA]\n";
    // 退出
    exit;
}

// 我们处理数据文件的当前行
while (($line = fgets($taxpayersdata, 100)) !== false) {
    // 我们删除可能存在的行尾标记
    $line = cutNewLineChar($line);
    // 我们获取组成 $line 的 3 个字段 married,children,salary
    [$married, $children, $salary] = explode(",", $line);
    $married = strtolower($married);
    $children = (int) $children;
    $salary = (int) $salary;
    // 我们计算税款
    $result = calculateTax($taxAdminData, $married, $children, $salary);
    // 我们把结果写入结果文件
    $result = ["married" => $married, "children" => $children, "salary" => $salary] + $result;
    fputs($results, json_encode($result, JSON_UNESCAPED_UNICODE) . "\n");
    // 下一条数据
}
// 我们关闭文件
fclose($taxpayersdata);
fclose($results);
print "The results have been saved in the file [$RESULTS]\n";

// 结束
exit;

// --------------------------------------------------------------------------
function cutNewLineChar(string $line): string
{
    // 如果 $line 存在行尾标记,则将其删除
    // (Windows 上是 \r\n,Unix 上是 \n)
    return rtrim($line, "\r\n");
}

// 税款计算
// --------------------------------------------------------------------------
function calculateTax(array $taxAdminData, string $married, int $children, float $salary): array
{
    // $married:是、否
    // $children:子女数
    // $salary:年薪
    // $taxAdminData:税务管理部门的数据
    //
    // 计算有子女时的税款
    $result1 = calculateTax2($taxAdminData, $married, $children, $salary);
    $tax1 = $result1["tax"];
    // 计算没有子女时的税款
    if ($children !== 0) {
        $result2 = calculateTax2($taxAdminData, $married, 0, $salary);
        $tax2 = $result2["tax"];
        // 应用家庭系数上限
        if ($children < 3) {
            // 前 2 个子女适用 HALF_SHARE_QF_CEILING 欧元
            $tax2 = $tax2 - $children * $taxAdminData["HALF_SHARE_QF_CEILING"];
        } else {
            // 前 2 个子女适用 HALF_SHARE_QF_CEILING 欧元,之后的子女加倍
            $tax2 = $tax2 - 2 * $taxAdminData["HALF_SHARE_QF_CEILING"] - ($children - 2) * 2 * $taxAdminData["HALF_SHARE_QF_CEILING"];
        }
    } else {
        $tax2 = $tax1;
        $result2 = $result1;
    }
    // 我们取较高的税款及其对应的税率和速算扣除数
    if ($tax1 > $tax2) {
        $tax = $tax1;
        $rate = $result1["rate"];
        $surcharge = $result1["surcharge"];
    } else {
        $surcharge = $tax2 - $tax1 + $result2["surcharge"];
        $tax = $tax2;
        $rate = $result2["rate"];
    }
    // 计算可能的减免
    $discount = getDiscount($taxAdminData, $married, $salary, $tax);
    $tax -= $discount;
    // 计算可能的税额减免
    $reduction = getReduction($taxAdminData, $married, $salary, $children, $tax);
    $tax -= $reduction;
    // 结果
    return [
        "tax" => (int) floor($tax),
        "surcharge" => (int) $surcharge,
        "discount" => (int) $discount,
        "reduction" => (int) $reduction,
        "rate" => $rate,
    ];
}

说明:

  • 第 9 行:包含税务机关数据的 JSON 文件的名称;
  • 第 12–20 行:尝试读取名为 [$TAXADMINDATA] 的 JSON 文件的内容。函数 [file_get_contents] 以字符串形式返回文件的全部内容,如果操作失败则返回 [false] ;
  • 第 22–32 行:如果文件读取成功,就使用函数 [json_validate](PHP 8.3)验证它包含有效的 JSON 数据,然后把其内容解码到关联数组 [$taxAdminData] 中;
  • 第 35–39 行:如果前两个操作中的任何一个出现错误,就向控制台写入一条错误消息,程序终止;
  • 第 67 行:与第 1 版的区别在于,这里来自税务机关的数据(数组和常量)存放在关联数组 [$taxAdminData] 中,而在第 1 版中,它们存放在全局数组和常量中。区分这两个版本的正是这些常量的全局性:
    • 在第 1 版中,常量在 [main.php] 的所有函数中都可以访问;
    • 要在第 2 版中达到同样的效果,必须把关联数组 [$taxAdminData] 作为参数传给所有需要它的函数:[calculateTax], [calculateTax2], [getTaxableIncome], [getDiscount] 和 [getReduction];
  • 第 91 行:函数 [calculateTax] 接收数组 [$taxAdminData] 作为其第一个参数。数组 [limits, coeffR, coeffN] 不再是参数;它们包含在 [$taxAdminData] 中;
  • 第 108–111 行:原来使用全局常量的地方,现在改用作为参数接收的数组 [$taxAdminData] 的内容。

函数 [calculateTax2] 以同样的方式从数组 [$taxAdminData] 中取得税档:

// --------------------------------------------------------------------------
function calculateTax2(array $taxAdminData, string $married, int $children, float $salary): array
{
    // $married:是、否
    // $children:子女数
    // $salary:年薪
    // $taxAdminData:税务管理部门的数据
    //
    // 份数
    if ($married === "yes") {
        $nbShares = $children / 2 + 2;
    } else {
        $nbShares = $children / 2 + 1;
    }
    // 从第 3 个子女起每个子女 1 份
    if ($children >= 3) {
        // 从第 3 个子女起每个子女再加半份
        $nbShares += 0.5 * ($children - 2);
    }
    // 应纳税所得额
    $taxableIncome = getTaxableIncome($taxAdminData, $salary);
    // 附加额
    $surcharge = floor($taxableIncome - 0.9 * $salary);
    // 为了处理舍入问题
    if ($surcharge < 0) {
        $surcharge = 0;
    }
    // 家庭系数
    $quotient = $taxableIncome / $nbShares;
    // 税率档
    $limits = $taxAdminData["limits"];
    $coeffR = $taxAdminData["coeffR"];
    $coeffN = $taxAdminData["coeffN"];
    // 放在 limits 数组末尾,以终止后面的循环
    $limits[count($limits) - 1] = $quotient;
    // 计算税款
    $i = 0;
    while ($quotient > $limits[$i]) {
        $i++;
    }
    // 由于我们把 $quotient 放在了 $limits 数组的末尾,前面的循环
    // 不会越过 $limits 数组
    // 现在可以计算税款了
    $tax = floor($taxableIncome * $coeffR[$i] - $nbShares * $coeffN[$i]);
    // 结果
    return ["tax" => $tax, "surcharge" => $surcharge, "rate" => $coeffR[$i]];
}
  • 第 173–175 行:从字典 [$taxAdminData] 中取出三个税档表。其余代码保持不变。

其他函数也以同样的方式改写。例如函数 [getDiscount]:

// 计算可能的减免
function getDiscount(array $taxAdminData, string $married, float $salary, float $taxes): float
{
    // 开始时,减免为零
    $discount = 0;
    // 可获得减免的税款最高金额
    $taxCeilingForDiscount = $married === "yes" ? $taxAdminData["COUPLE_TAX_CEILING_FOR_DISCOUNT"] : $taxAdminData["SINGLE_TAX_CEILING_FOR_DISCOUNT"];
    if ($taxes < $taxCeilingForDiscount) {
        // 减免的最高金额
        $discountCeiling = $married === "yes" ? $taxAdminData["COUPLE_DISCOUNT_CEILING"] : $taxAdminData["SINGLE_DISCOUNT_CEILING"];
        // 理论减免额
        $discount = $discountCeiling - 0.75 * $taxes;
        // 减免额不能超过税款金额
        if ($discount > $taxes) {
            $discount = $taxes;
        }
        // 减免额不得小于 0
        if ($discount < 0) {
            $discount = 0;
        }
    }
    // 结果
    return ceil($discount);
}

执行会产生如下输出:

> php main.php
The results have been saved in the file [results.txt]

以及如下的 [results.txt] 文件:

{"married":"yes","children":2,"salary":55555,"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"yes","children":2,"salary":50000,"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}
{"married":"yes","children":3,"salary":50000,"tax":0,"surcharge":0,"discount":720,"reduction":0,"rate":0.14}
{"married":"no","children":2,"salary":100000,"tax":19884,"surcharge":4480,"discount":0,"reduction":0,"rate":0.41}
{"married":"no","children":3,"salary":100000,"tax":16782,"surcharge":7176,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":3,"salary":100000,"tax":9200,"surcharge":2180,"discount":0,"reduction":0,"rate":0.3}
{"married":"yes","children":5,"salary":100000,"tax":4230,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"no","children":0,"salary":100000,"tax":22986,"surcharge":0,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":2,"salary":30000,"tax":0,"surcharge":0,"discount":0,"reduction":0,"rate":0}
{"married":"no","children":0,"salary":200000,"tax":64210,"surcharge":7498,"discount":0,"reduction":0,"rate":0.45}
{"married":"yes","children":3,"salary":200000,"tax":42842,"surcharge":17283,"discount":0,"reduction":0,"rate":0.41}

得到的结果与上一版得到的结果相同。

4.4.2. 结论

第 2 版比第 1 版灵活得多。如果在另一年,税额计算算法保持不变,那么只有税档和计算常量会改变。只需更新文件 [taxadmindata.json] 即可。而使用第 1 版时,你必须进入代码去修改税档和计算常量。然而,需要修改税档和计算常量值的人很可能无权访问算法的代码。

不过,第 2 版有一个缺陷:数组 [$taxAdminData] 必须传给所有函数,而且无法保证它确实包含所有期望的键。JSON 文件中某个键的拼写错误,要到执行计算时才会被发现。第 3 版将把这些数据存放在类 [TaxAdminData] 的对象中,该类的属性是经过声明并带有类型的。