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

上面的表格(来自 lefigaro.fr 的一个法语页面)用于在纳税人只有工资需要申报的简化情形下计算税额。正如注释 (1) 所指出的,以这种方式计算出的税额是三项调整之前的税额:
- 家庭系数上限,适用于高收入者;
- 适用于低收入者的税额抵免和税额减免。
因此,税额计算包括以下步骤 [http://impotsurlerevenu.org/comprendre-le-calcul-de-l-impot/1217-calcul-de-l-impot-2019.php]:

我们打算编写一个程序,在纳税人只有单一工资需要申报的简化情形下计算纳税人的税额。所使用的规则是针对 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 的行如下:
于是税额 I 等于 0.14*R – 1,394.96*nbShares=[0.14*45000-1394.96*3]=2,115。税额向下取整到欧元。
如果从第一行起就满足条件 QF <= field1,则税额为零。
如果 QF 使得条件 QF <= field1 始终不满足,则使用最后一行的系数。在这种情况下:
由此得到毛税额 I = 0.45*R – 20,163.45*nbShares。
4.1.2. 家庭系数上限

为了确定家庭系数 QF 的上限是否适用,我们重新计算不计入子女的毛税额。仍以那位已婚、有两个子女、年薪 S 为 50,000 欧元的雇员为例:
- 应税收入:R = 0.9 * S = 45,000;
- 份数:nbShares = 2(不再计入子女);
- 家庭系数:QF = 45,000 / 2 = 22,500。
第一个满足 QF <= field1 的行如下:
于是税额 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. 税额抵免的计算

仍以那位已婚、有两个子女、年薪 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. 税额减免的计算

低于某一阈值时,对前面各步计算得到的毛税额适用 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% |
在上面的示例中,“附加税额”指高收入者由于两个因素而多缴的金额:
这个指标无法核实,因为税务机关的模拟器没有提供它。
我们可以看到,本文档的算法每次都能算出正确的税额,只是有 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] 中:
| 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] 的对象中,该类的属性是经过声明并带有类型的。