Skip to content

3. PHP 基础

3.1. 脚本的目录结构

本章的脚本位于课程代码 [scripts-console] 文件夹下的两个文件夹中:

php8-oct-2026
└── scripts-console
    ├── basics
    │   ├── phpinfo.php
    │   ├── basics-01.php
    │   ├── basics-02.php
    │   ├── ...
    │   ├── basics-17.php
    │   └── info.txt
    └── json
        ├── family.json
        ├── json-01.php
        ├── json-02.php
        └── json-03.php

这些是“控制台”脚本:它们在终端中使用 [php script-name.php] 命令运行,并把结果输出到同一个终端。由 [Apache] 服务器(运行在 [Laragon] 上)执行并由浏览器显示的 Web 脚本将在后面介绍。

3.2. 配置 PHP

PHP 通过一个名为 [php.ini] 的文本文件预先配置好。所有这些设置都可以通过编程方式修改。PHP 的配置对脚本的执行有很大影响,因此理解它很重要。下面的脚本 [phpinfo.php],可以让你做到这一点:

1
2
3
4
5
6
<?php

declare(strict_types=1);

// 显示 PHP 配置
phpinfo();

说明:

  • 第 3 行:这一行将出现在本课程所有脚本的开头。我们会在类型转换一节中解释它;
  • 第 6 行:函数 [phpinfo] 显示 PHP 的配置。

我们在 [scripts-console/basics] 文件夹中打开一个终端并运行该脚本。下面是其中的一段摘录:

> php phpinfo.php
phpinfo()
PHP Version => 8.5.11
…
Server API => Command Line Interface
…
PHP API => 20250925
PHP Extension => 20250925
Zend Extension => 420250925
PHP Integer Size => 64 bits
Debug Build => no
Zend Memory Manager => enabled
IPv6 Support => enabled
…
display_errors => STDOUT => STDOUT
error_reporting => 30719 => 30719
memory_limit => 512M => 512M
max_execution_time => 0 => 0
…

[phpinfo] 函数在这里显示了近 1500 行配置。我们不会逐一说明,因为其中大多数涉及 PHP 的高级用法。下面只强调几项:

  • [PHP Version]:所使用的 PHP 版本,这里是 8.5;
  • [Server API]:PHP 的启动方式。[Command Line Interface] (CLI)表示解释器运行在终端中。当 PHP 由 [Apache] 服务器执行时,这一行会改变,配置也可能不同;
  • [display_errors] 和 [error_reporting]:PHP 显示所有错误、警告和弃用通知。值 30719 对应自 PHP 8.4 起的常量 [E_ALL] 。这是学习期间所需的配置:警告几乎总是表明存在编程错误。

完整输出中的一行重要内容是 [Loaded Configuration File] 行:它指出用于配置运行你的脚本的 PHP 的是哪个 [php.ini] 文件。在 [Laragon] 中,它是形如 [C:\laragon\bin\php\php-8.5.x-Win32-vs17-x64\php.ini] 的文件。你也可以直接使用命令 [php --ini] 获得它。如果你想修改 PHP 的运行配置,就要编辑这个文件([Laragon] 通过其菜单的 [PHP > php.ini] 项提供访问)。该文件中有大量注释,解释各项配置的用途。

3.3. 第一个示例

3.3.1. 代码

下面是程序 [basics-01.php],它演示了 PHP 的基本特性:

<?php

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

// 这是一条注释
// 使用了未声明的变量
$name = "dupont";
// 屏幕显示
print "name=$name\n";
// 包含不同类型元素的数组
$array = ["one", "two", 3, 4];
// 其元素个数
$n = count($array);
// 循环
for ($i = 0; $i < $n; $i++) {
    print "array[$i]=$array[$i]\n";
}
// 用数组的内容初始化 2 个变量
[$string1, $string2] = ["string1", "string2"];
// 连接这 2 个字符串
$string3 = $string1 . $string2;
// 显示结果
print "[$string1,$string2,$string3]\n";
// 使用函数
display($string1);
// 可以获知变量的类型
displayType("n", $n);
displayType("string1", $string1);
displayType("array", $array);
// 变量的类型在执行期间可以改变
$n = "has changed";
displayType("n", $n);
// 函数可以返回一个结果
$res1 = f1(4);
print "res1=$res1\n";
// 函数可以返回一个值数组
[$res1, $res2, $res3] = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
// 我们本可以用数组来获取这些值
$t = f2();
for ($i = 0; $i < count($t); $i++) {
    print "t[$i]=$t[$i]\n";
}
// 一些测试
for ($i = 0; $i < count($t); $i++) {
    // 只显示字符串
    if (gettype($t[$i]) === "string") {
        print "t[$i]=$t[$i]\n";
    }
}
// 比较运算符 == 和 ===
if ("2" == 2) {
    print "with the == operator, the string 2 is equal to the integer 2\n";
} else {
    print "with the == operator, the string 2 is not equal to the integer 2\n";
}
if ("2" === 2) {
    print "with the === operator, the string 2 is equal to the integer 2\n";
} else {
    print "with the === operator, the string 2 is not equal to the integer 2\n";
}
// 一个在 PHP 8 中结果发生了变化的比较
if (0 == "abc") {
    print "with the == operator, the integer 0 is equal to the string abc\n";
} else {
    print "with the == operator, the integer 0 is not equal to the string abc\n";
}
// 其他测试
for ($i = 0; $i < count($t); $i++) {
    // 只显示大于 10 的整数
    if (is_int($t[$i]) && $t[$i] > 10) {
        print "t[$i]=$t[$i]\n";
    }
}
// while 循环
$t = [8, 5, 0, -2, 3, 4];
$i = 0;
$sum = 0;
while ($i < count($t) && $t[$i] > 0) {
    print "t[$i]=$t[$i]\n";
    $sum += $t[$i];   // $sum = $sum + $t[$i]
    $i++;             // $i = $i + 1
}
print "sum=$sum\n";

// 程序结束
exit;

//----------------------------------
function display(string $string): void
{
    // 显示 $string
    print "string=$string\n";
}

//----------------------------------
function displayType(string $name, mixed $variable): void
{
    // 显示 $variable 的类型
    print "type[variable $" . $name . "]=" . gettype($variable) . "\n";
}

//----------------------------------
function f1(int $param): int
{
    // 给 $param 加 10
    return $param + 10;
}

//----------------------------------
function f2(): array
{
    // 返回 3 个值
    return ["one", 0, 100];
}

结果:

> php basics-01.php
name=dupont
array[0]=one
array[1]=two
array[2]=3
array[3]=4
[string1,string2,string1string2]
string=string1
type[variable $n]=integer
type[variable $string1]=string
type[variable $array]=array
type[variable $n]=string
res1=14
(res1,res2,res3)=[one,0,100]
t[0]=one
t[1]=0
t[2]=100
t[0]=one
with the == operator, the string 2 is equal to the integer 2
with the === operator, the string 2 is not equal to the integer 2
with the == operator, the integer 0 is not equal to the string abc
t[2]=100
t[0]=8
t[1]=5
sum=13

说明:

  • 第 4 行:指示 PHP 严格检查参数的声明类型和函数返回值的类型。我们会在类型转换一节中再回到这个问题。现在只需注意,本课程的所有脚本都以这种方式开头;
  • 第 8 行:在 PHP 中,变量无需声明。它们具有动态类型,类型可以随时间改变。[$name] 表示标识符为 [name] 的变量;
  • 第 10 行:要向屏幕输出,可以使用语句 [print] 或语句 [echo];
  • 第 12 行:记号 [[...]] 用于定义数组。记号 [$array[$i]] 表示第 [$i] 号元素,所在数组为 [$array],其中第一个元素的编号为 0。较旧的记法 [array("one", "two", 3, 4)] 仍然被接受,但我们不会使用它;
  • 第 14 行:函数 [count($array)] 返回数组 [$array] 中的元素个数;
  • 第 16–18 行:一个循环。由于这个循环只包含一条语句,花括号是可选的。在本文档的其余部分,无论语句有多少条,我们都始终使用花括号;
  • 第 17 行:字符串用双引号 " 或单引号 ' 括起来。在双引号内,变量 [$variable] 会被求值(也称为“插值”),而在单引号内则不会;
  • 第 20 行:可以在一次操作中把数组的元素赋给多个变量。这里,[$string1="string1"] 且 [$string2="string2"]。这种语法称为解构,它取代了旧版 PHP 中的 [list] 函数:[list($string1, $string2) = ...] 仍然被接受;
  • 第 22 行:运算符 .(句点)是字符串连接运算符;
  • 第 91–95 行:关键字 [function] 定义一个函数。函数可以在脚本中的任何位置定义,甚至在使用之后。这里,[string $string] 表示参数 [$string] 必须是字符串,而 [: void] 表示函数不返回结果。这些类型声明在 PHP 中是可选的,但我们会始终使用它们:它们为代码提供文档,并让 PHP(以及编辑器)能够检测错误;
  • 第 98 行:类型 [mixed] (PHP 8.0)表示“任意类型”。参数 [$variable] 可以接受整数、字符串、数组等;
  • 第 101 行:预定义函数 [gettype($variable)] 返回表示 [$variable] 类型的字符串。结果表明这个类型可以随时间改变:[$n] 先是整数,然后变成字符串;
  • 第 105 行:函数使用语句 [return] 返回结果。该结果的类型在括号之后声明:[: int]。调用代码可以忽略或获取函数的结果;
  • 第 112 行:函数可以把多个值放进一个数组中一并返回;
  • 第 53–62 行:运算符 [===] 对两个元素进行严格比较:它们必须类型相同且值相同才相等。运算符 [] 则不那么严格:两个元素即使类型不同也可能相等。在这种情况下,比较是在把两个元素转换为同一类型之后进行的。人们很容易“忽视”这些隐式转换,从而得到出乎意料的结果,例如发现一个本以为为假的条件竟然为真。为了避免这个陷阱,我们将始终使用比较运算符 [=] (及其否定形式 [!==]);
  • 第 64–68 行:这些隐式转换的一个示例。在 PHP 7 中,字符串“abc”会被转换为数字 0,表达式 [0 == "abc"] 为真!自 PHP 8.0 起,当数字与不表示数字的字符串比较时,数字会被转换为字符串,表达式为假。因此 [] 的行为在不同版本之间发生了变化:这就更有理由优先使用 [=];
  • 第 72 行:如果参数是整数,函数 [is_int] 返回 [true] 。类似地,还有 [is_string]、[is_float]、[is_bool]、[is_array]……运算符 [&&] 是逻辑与。你还可以使用逻辑运算符 [||](或)和 [!](非)。PHP 还支持关键字 [and] 和 [or],但它们相对于赋值的优先级较低,可能导致意想不到的结果:我们不会使用它们;
  • 第 80 行:一个 [while] 循环。一旦条件为假它就停止,在这里就是数组遍历完毕或遇到负数或零元素的时候;
  • 第 88 行:语句 [exit] 终止脚本的执行。其后的函数此时不会被执行,但整个脚本都能识别它们。

请注意,脚本不以 PHP 代码的结束标记 [?>] 结尾。它并非必需。此外,在 Web 环境中,如果它后面跟着空格或换行,可能会引发问题,而这些在文本编辑器中不可见,很难发现。事实上,[PSR-12] 建议规定,在只包含 PHP 的文件中应省略它。因此,在本文档的其余部分,我们将一律省略它。

注意:在本文档中,我们使用关键字 [print] 在控制台显示文本。做同样的事还有另一种方式,即使用关键字 [echo]。这两个关键字之间有一些细微的差别,但在本文档的范围内,它们没有区别。所以如果你更喜欢使用 [echo],那就请用吧。

3.3.2. 使用 VS Code

要处理课程脚本,请在 [php8-oct-2026] 文件夹中用 [VS Code] 打开它([File > Open Folder] 菜单)。文件树显示在窗口左侧的资源管理器中。要运行一个脚本:

  • 打开一个集成终端([Terminal > New Terminal] 菜单)。它会在 [php8-oct-2026] 文件夹中打开;
  • 进入脚本所在的文件夹:[cd scripts-console/basics];
  • 运行脚本:[php basics-01.php]。结果会显示在终端中。或者,在文件资源管理器中,你可以右键单击 [basics] 文件夹并选择 [Open in Integrated Terminal]。

如果命令 [php] 无法识别,说明 PHP 文件夹不在 Windows 的 PATH 目录中:当你勾选 [Laragon] 的 [Tools > Path] 菜单中的相应选项时,它会把 PHP 文件夹加到那里。命令 [php -v] 应当显示 8.5 版。

扩展 [PHP Intelephense] 在你输入时分析代码,并用波浪线标出有问题的代码。将鼠标悬停在这条线上会显示相应消息。文件中的所有问题都列在 [Problems] 面板([View > Problems] 菜单)中。下面是一些有用的警告:

  • [Undefined variable]:使用了未初始化的变量。这通常是变量名拼写错误;
  • [Undefined function]:调用了不存在的函数;这通常同样是拼写错误;
  • [Expected type 'int'. Found 'string'.]:实参的类型与函数声明的类型不符。这是类型声明的主要好处之一:错误在执行之前就被报告出来;
  • [Expected 2 arguments. Found 1.]:实参的个数与函数的定义不匹配。

将鼠标悬停在函数名称上,会显示其签名(参数、类型、返回值)及其文档,PHP 的预定义函数也不例外。为确保 [Intelephense] 了解语言的最新更新,请检查 [VS Code] 的设置([File > Preferences > Settings] 菜单,搜索“intelephense php version”),确认所指定的 PHP 版本为 8.5。在学习这门语言的过程中,建议修正所有报告的警告。这是一个很好的学习方式。

[Intelephense] 还可以按照 [Format Document](右键单击)中 [PSR-12] 的编码建议来格式化文件。PSR(PHP Standard Recommendations,PHP 标准建议)是编写标准代码的指南,有助于不同人编写的代码之间的互操作和维护。它们由 [PHP-FIG] 在 www.php-fig.org 网站上发布。[PSR-1] 和 [PSR-12] 建议确立了代码编写规则。下面是 [PSR-1] 的规则:

元素
规则
类常量
类常量必须使用大写字母书写,并以 _ 字符作为分隔符。
例如:[const VAT_RATE]
方法
方法名必须使用 camelCase 书写。
示例:[public function executeBatchTaxes()]
属性
属性名应在同一个代码库中保持一致地使用 StudlyCaps、camelCase 或 under_score 之一书写。
示例:[$AnnualSalary], [$annualSalary], [$annual_salary]
副作用
一个文件应当要么声明新的符号(类、函数、常量等)而不产生任何副作用,要么执行带有副作用的代码,但不应两者兼有。
类型
类型名(类、接口等)必须使用 StudlyCaps 书写。每个类型位于各自的文件中,并处于至少有一级的命名空间内。
示例:[class ScholarshipStudent]

副作用规则规定,一个文件必须包含:

  • 要么是类型(类、接口)、函数或常量的声明;
  • 要么是不声明新类型的可执行代码。

为简单起见,本章的示例不遵循这条规则:每个脚本都是单个文件,在其中定义函数并使用它们。对于基础示例来说,把代码拆分到多个文件中会过于繁琐。对于作为本文档主线的应用程序,一旦它改用类来编写,我们将尽可能严格地遵循这些建议。

3.4. 变量作用域

3.4.1. 示例 1

脚本 [basics-02.php] 如下:

<?php

declare(strict_types=1);

// 变量的作用域

function f1(): void
{
    // 我们使用全局变量 $i
    global $i;
    $i++;
    $j = 10;
    print "f1[i,j]=[$i,$j]\n";
}

function f2(): void
{
    // 我们使用全局变量 $i
    global $i;
    $i++;
    $j = 20;
    print "f2[i,j]=[$i,$j]\n";
}

function f3(): void
{
    // 我们使用局部变量 $i
    $i = 4;
    $j = 30;
    print "f3[i,j]=[$i,$j]\n";
}

// 测试
$i = 0;
$j = 0;  // 只有当函数 f 用 global 语句显式声明
// 想要使用这两个变量时,
// 它才能识别它们
f1();
f2();
f3();
print "test[i,j]=[$i,$j]\n";

结果:

1
2
3
4
5
> php basics-02.php
f1[i,j]=[1,10]
f2[i,j]=[2,20]
f3[i,j]=[4,30]
test[i,j]=[2,0]

说明:

  • 第 34–35 行:在主程序中定义了两个变量 [$i] 和 [$j]。这些变量在函数内部是不被识别的。因此,在第 12 行,[$j] 是函数 [f1] 的局部变量,即函数 [f1] 中的变量,与主程序中的变量 [$j] 不同;
  • 第 10 行:函数可以访问主程序中名为 [$variable] 的变量,方法是使用关键字 [global]。这里,该语句指的是主程序中的全局变量 [$i] ;
  • 第 28 行:函数 [f3] 没有把 [$i] 声明为全局变量;它的变量 [$i] 是局部变量,与主程序中的那个无关。

不建议使用 [global] :修改全局变量的函数难以理解和测试。更好的做法是让函数通过参数接收数据,并通过 [return] 返回结果。下一个示例就是这样做的。

3.4.2. 示例 2

脚本 [basics-03.php] 如下:

<?php

declare(strict_types=1);

// 变量的作用域对代码块而言是全局的
$i = 0;
{
    $i = 4;
    $i++;
}
print "i=$i\n";

结果:

> php basics-03.php
i=5

说明:

在某些语言中,在花括号内定义的变量其作用域仅限于这对花括号:在花括号之外无法访问。上面的结果表明,PHP 并非如此。第 8 行在花括号内使用的变量 [$i] 与第 6 行和第 11 行在花括号之外使用的是同一个变量。

3.5. 类型转换

PHP 中的变量没有固定的类型。类型可能在运行时随着赋给变量的值而改变。在涉及各种类型数据的运算中,PHP 解释器会执行隐式转换,把操作数转换为共同的类型。如果开发者不了解这些隐式转换,它们就可能成为难以发现的错误之源。下面是脚本 [basics-04.php],它演示了隐式转换和显式转换。我们先看第一部分:

<?php

// 传递参数时的严格类型
declare(strict_types=1);

// 隐式类型转换
// 类型 → bool
print "Conversion to a boolean------------------------------\n";
showBool("abcd", "abcd");
showBool("", "");
showBool("[1, 2, 3]", [1, 2, 3]);
showBool("[]", []);
showBool("null", null);
showBool("0.0", 0.0);
showBool("0", 0);
showBool("4.6", 4.6);
showBool("\"0\"", "0");

function showBool(string $prefix, mixed $var): void
{
    print "(bool) $prefix : ";
    // 在下面的测试中,$var 会被自动转换为布尔值
    if ($var) {
        print "true";
    } else {
        print "false";
    }
    print "\n";
}

说明:

  • 第 4 行:要求在指定了类型时,对函数的参数(以及其返回值的类型)进行严格的类型检查。我们稍后会解释这条指令;
  • 第 19 行:函数 [showBool] 的目的是演示当任意类型的值必须转换为布尔值时(第 23 行),PHP 解释器所执行的隐式(自动)转换;
  • 第 19 行:参数 [$prefix] 必须是 [string] 类型。参数 [$var] 的类型是 [mixed]:因此实参可以是任意类型。函数 [showBool] 不返回任何值([void]);
  • 第 23 行:在 [if ($var)] 语句中,[$var] 的值必须被转换为布尔值,这样 [if] 才能被求值。令人惊讶的是,PHP 解释器对提供给它的任何类型的值都会给出结果;
  • 第 9–17 行:[showBool] 的函数参数值将依次是:
    • 第 9 行:非空字符串:结果为 [true] (大小写不敏感,TRUE=true);
    • 第 10 行:空字符串:结果为 [false];
    • 第 11 行:非空数组:结果为 [true];
    • 第 12 行:空数组:结果为 [false];
    • 第 13 行:值 [null] (无值):结果为 [false];
    • 第 14 行:实数 0:结果为 [false];
    • 第 15 行:整数 0:结果为 [false];
    • 第 16 行:非 0 的实数(或整数):结果为 [true];
    • 第 17 行:一个陷阱:字符串 "0" 被转换为 [false],而任何其他非空字符串都被转换为 [true]。

屏幕上的输出结果证明了这一点:

Conversion to a boolean------------------------------
(bool) abcd : true
(bool)  : false
(bool) [1, 2, 3] : true
(bool) [] : false
(bool) null : false
(bool) 0.0 : false
(bool) 0 : false
(bool) 4.6 : true
(bool) "0" : false

我们继续看脚本的代码:

// 从字符串到数值类型的隐式类型转换
// 字符串 → 数字
print "Conversion string to number------------------------------\n";
showNumber("12");
showNumber("45.67");
showNumber("12abcd");
try {
    showNumber("abcd");
} catch (TypeError $error) {
    print "(abcd): error [" . $error->getMessage() . "]\n";
}

function showNumber(string $var): void
{
    $number = $var + 1;
    var_dump($number);
    print "($var): $number\n";
}

说明:

  • 第 43 行:函数 [showNumber] 接受 [string] 类型的参数,并且不返回结果([void]);
  • 第 45 行:这个参数用于算术运算,这会迫使 PHP 解释器尝试把 [$var] 转换为数字:
    • 第 34 行:会把字符串 "12" 转换为整数 12;
    • 第 35 行:会把字符串 "45.67" 转换为实数 45.67;
    • 第 36 行:字符串 "12abcd" 以数字开头。PHP 使用这个数字 12,但会发出警告;
    • 第 38 行:字符串 "abcd" 不包含数字。在 PHP 7 中,它会被转换为 0,仅给出一个简单的警告。自 PHP 8.0 起,这个运算不再可行:PHP 会抛出 [TypeError] 类型的错误,如果不捕获,它会终止脚本;
  • 第 37–41 行:[try { ... } catch (TypeError $error) { ... }] 结构可以捕获这个错误并继续执行。[$error->getMessage()] 是错误消息。异常将在后面的章节中介绍;现在只需知道,[catch] 块中的代码会在 [try] 块中的代码引发 [TypeError] 错误时被执行。

下面是执行结果:

Conversion string to number------------------------------
int(13)
(12): 13
float(46.67)
(45.67): 46.67

Warning: A non-numeric value encountered in .../php8-oct-2026/scripts-console/basics/basics-04.php on line 45
int(13)
(12abcd): 13
(abcd): error [Unsupported operand types: string + int]

函数 [var_dump] 显示其参数的类型和值:int(13) 是整数 13,float(46.67) 是浮点数 46.67。

请注意,[declare(strict_types=1)] 语句并没有阻止字符串 "12" 被转换为数字。这是重要的一点:严格模式只适用于向函数传递参数以及函数返回的结果,不影响由运算符(+、.、==……)或由 [if] 执行的转换。它所改变的是:

  • 没有 [declare(strict_types=1)] 时(即所谓的“强制”模式),如果函数期望得到 [int] 而传入的是字符串“12”,PHP 会把该字符串转换为整数 12;
  • 有 [declare(strict_types=1)] 时(严格模式),同样的调用会导致 [TypeError] 错误。实参必须恰好是期望的类型。有一个例外:在期望 [int] 的地方接受 [float] 。

这条语句必须是文件中的第一条语句,并且只作用于在该文件内发起的函数调用。我们将在所有脚本中使用它:它把悄无声息的转换(这是错误的来源)变成会被报告的错误。我们将在传递参数一节中看到一个例子。

我们继续看脚本代码中的显式类型转换:

// 显式类型转换
// 转为 int
print "Explicit conversion to int------------------------------\n";
showInt("12.45");
showInt(67.8);
showInt(true);
showInt(null);

function showInt(mixed $var): void
{
    print "parameter: ";
    var_dump($var);
    print "result of the conversion: ";
    var_dump((int) $var);
}

说明:

  • 第 58 行:函数 [showInt] 接受任意类型([mixed])的参数,并且不返回结果。它把参数 [$var] 转换为整数(第 63 行)。一般来说,要把类型为 [$var] 的变量转换为类型 T,写作 [(T) $var],其中 T 可以是:int、bool、float、string、array 或 object。旧版 PHP 中的记法 (integer)、(boolean)、(double) 和 (binary) 已经过时:PHP 8.5 会将它们标记为已弃用。而 (real) 语法则自 PHP 8.0 起被移除;
  • 第 53 行:把字符串 "12.45" 转换为整数 12;
  • 第 54 行:把浮点数 67.8 转换为整数 67(小数部分丢失);
  • 第 55 行:把布尔值 [true] 转换为整数 1(布尔值 [false] 转换为整数 0);
  • 第 56 行:把值 [null] 转换为整数 0。

屏幕显示的内容如下:

1
2
3
4
5
6
7
8
9
Explicit conversion to int------------------------------
parameter: string(5) "12.45"
result of the conversion: int(12)
parameter: float(67.8)
result of the conversion: int(67)
parameter: bool(true)
result of the conversion: int(1)
parameter: NULL
result of the conversion: int(0)

我们继续分析脚本,看把值显式转换为 [float] 类型的部分:

// 转为 float
print "Explicit conversion to float------------------------------\n";
showFloat("12.45");
showFloat(67);
showFloat(true);
showFloat(null);

function showFloat(mixed $var): void
{
    print "parameter: ";
    var_dump($var);
    print "result of the conversion: ";
    var_dump((float) $var);
}

说明:

  • 第 73 行:函数 [showFloat] 接受任意类型的参数,并且不返回结果;
  • 第 78 行:该参数的值被显式转换为 [float];
  • 第 68 行:把字符串 "12.45" 转换为实数 12.45;
  • 第 69 行:把整数 67 转换为实数 67;
  • 第 70 行:布尔值 [true] 被转换为实数 1(值 [false] 被转换为数字 0);
  • 第 71 行:值 [null] 被转换为实数 0。

屏幕输出显示了这一点:

1
2
3
4
5
6
7
8
9
Explicit conversion to float------------------------------
parameter: string(5) "12.45"
result of the conversion: float(12.45)
parameter: int(67)
result of the conversion: float(67)
parameter: bool(true)
result of the conversion: float(1)
parameter: NULL
result of the conversion: float(0)

最后,我们通过考察到 [string] 类型的转换来结束对该脚本的介绍:

// 转为 string
print "Explicit conversion to string------------------------------\n";
showString(5);
showString(6.7);
showString(false);
showString(null);

function showString(mixed $var): void
{
    print "parameter: ";
    var_dump($var);
    print "result of the conversion: ";
    var_dump((string) $var);
}

说明:

  • 第 88 行:函数 [showString] 接受任意类型的参数,并且不返回结果;
  • 第 93 行:参数值被转换为 [string] 类型;
  • 第 83 行:整数 5 将被转换为字符串 "5";
  • 第 84 行:浮点数 6.7 将被转换为字符串 "6.7";
  • 第 85 行:布尔值 [false] 将被转换为空字符串;
  • 第 86 行:值 [null] 将被转换为空字符串。

屏幕上的结果如下:

1
2
3
4
5
6
7
8
9
Explicit conversion to string------------------------------
parameter: int(5)
result of the conversion: string(1) "5"
parameter: float(6.7)
result of the conversion: string(3) "6.7"
parameter: bool(false)
result of the conversion: string(0) ""
parameter: NULL
result of the conversion: string(0) ""

3.6. 数组

3.6.1. 标准一维数组

PHP 中数组有两种记法:

$array = ["one", 2, "three"];
$opposites = ["small" => "big", "beautiful" => "ugly", "expensive" => "cheap"];

数组 1 称为数组(或列表),数组 2 称为字典或关联数组,其元素表示为 key => value。记法 [$opposites["beautiful"]] 指与键 "beautiful" 相关联的值,这里是字符串 "ugly"。数组 1 只是字典的一种变体,可以写成:

$array = [0 => "one", 1 => 2, 2 => "three"];

这样我们得到 [$array[2]="three"]。归根结底,只有字典。对于含 n 个元素的经典数组,键是区间 [0,n-1] 内的整数。

脚本 [basics-05.php] 演示了操作值数组的各种运算:

<?php

declare(strict_types=1);

// 经典数组
// 初始化
$tab1 = [0, 1, 2, 3, 4, 5];
// 遍历 - 1
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// 遍历 - 2
print "tab1 has " . count($tab1) . " elements\n";
foreach ($tab1 as $key => $value) {
    print "tab1[$key]=$value\n";
}
// 添加元素
$tab1[] = $i++;
$tab1[] = $i++;
// 遍历 - 3
print "tab1 has " . count($tab1) . " elements\n";
$i = 0;
foreach ($tab1 as $element) {
    print "tab1[$i]=$element\n";
    $i++;
}
// 删除最后一个元素
array_pop($tab1);
// 遍历 - 4
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// 删除第一个元素
array_shift($tab1);
// 遍历 - 5
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// 在数组末尾添加
array_push($tab1, -2);
// 遍历 - 6
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// 在数组开头添加
array_unshift($tab1, -1);
// 遍历 - 7
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// 第一个和最后一个元素(PHP 8.5)
print "first element: " . array_first($tab1) . ", last element: " . array_last($tab1) . "\n";

结果:

> php basics-05.php
tab1 has 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 has 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 has 8 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=7
tab1 has 7 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1 has 6 elements
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1 has 7 elements
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1[6]=-2
tab1 has 8 elements
tab1[0]=-1
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=-2
first element: -1, last element: -2

说明:

  • 第 15 行:使用 [foreach] 遍历数组。这个语法元素允许你用两种不同的语法遍历字典(因此也包括数组):[foreach ($dictionary as $key => $value)] 和 [foreach ($array as $value)]。第一种语法在每次迭代时返回一个(键,值)对,而第二种只返回值。PHP 7 课程在这里使用了函数 [each],它在当时就已经过时了:它在 PHP 8.0 中被移除。[foreach] 是遍历数组的标准方式;
  • 第 19 行:记法 [$array[] = value] 把元素 [value] 添加为 [$array] 的最后一个元素。这里,在第一个 [$i] 循环 [for] 之后等于 6:先添加 6,再添加 7;
  • 第 24 行:使用 [foreach] 的第二种语法进行迭代;
  • 第 29 行:函数 [array_pop($array)] 删除 [$array] 的最后一个元素;
  • 第 36 行:函数 [array_shift($array)] 删除 [$array] 的第一个元素。其余元素从 0 开始重新编号;
  • 第 43 行:函数 [array_push($array, value)] 把 [value] 添加为 [$array] 的最后一个元素;
  • 第 50 行:函数 [array_unshift($array, value)] 把 [value] 添加为 [$array] 的第一个元素;
  • 第 57 行:函数 [array_first] 和 [array_last] 随 PHP 8.5 引入,分别返回数组的第一个和最后一个元素(如果数组为空,则返回 [null] )。

3.6.2. 字典或关联数组

脚本 [basics-06.php] 如下:

<?php

declare(strict_types=1);

// 字典
$spouses = ["Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => ""];
// 遍历 - 1
print "Number of elements in the dictionary: " . count($spouses) . "\n";
foreach ($spouses as $key => $value) {
    print "spouses[$key]=$value\n";
}
// 按键对字典排序
ksort($spouses);
// 遍历 - 2
foreach ($spouses as $key => $value) {
    print "spouses[$key]=$value\n";
}
// 字典的键列表
$keys = array_keys($spouses);
for ($i = 0; $i < count($keys); $i++) {
    print "keys[$i]=$keys[$i]\n";
}
// 字典的值列表
$values = array_values($spouses);
for ($i = 0; $i < count($values); $i++) {
    print "values[$i]=$values[$i]\n";
}
// 经典数组是列表吗?是字典吗?
print "values is a list: " . var_export(array_is_list($values), true) . "\n";
print "spouses is a list: " . var_export(array_is_list($spouses), true) . "\n";
// 查找键
exists($spouses, "Jacques");
exists($spouses, "Lucette");
exists($spouses, "Jean");
// 键不存在时的默认值:运算符 ??
print "spouse of Lucette: " . ($spouses["Lucette"] ?? "unknown") . "\n";
// 删除一个键值对
unset($spouses["Jean"]);
print "Number of elements in the dictionary: " . count($spouses) . "\n";
foreach ($spouses as $key => $value) {
    print "spouses[$key]=$value\n";
}
// 结束
exit;

function exists(array $spouses, string $husband): void
{
    // 检查键 $husband 是否存在于字典 $spouses 中
    if (isset($spouses[$husband])) {
        print "The key [$husband] exists, associated with the value [$spouses[$husband]]\n";
    } else {
        print "The key [$husband] does not exist\n";
    }
}

结果:

> php basics-06.php
Number of elements in the dictionary: 4
spouses[Pierre]=Gisèle
spouses[Paul]=Virginie
spouses[Jacques]=Lucette
spouses[Jean]=
spouses[Jacques]=Lucette
spouses[Jean]=
spouses[Paul]=Virginie
spouses[Pierre]=Gisèle
keys[0]=Jacques
keys[1]=Jean
keys[2]=Paul
keys[3]=Pierre
values[0]=Lucette
values[1]=
values[2]=Virginie
values[3]=Gisèle
values is a list: true
spouses is a list: false
The key [Jacques] exists, associated with the value [Lucette]
The key [Lucette] does not exist
The key [Jean] exists, associated with the value []
spouse of Lucette: unknown
Number of elements in the dictionary: 3
spouses[Jacques]=Lucette
spouses[Paul]=Virginie
spouses[Pierre]=Gisèle

说明:

上面的代码把我们之前对简单数组所讲的内容应用到了字典上。我们只对新出现的内容加以说明:

  • 第 13 行:函数 [ksort] (按键排序)按键的自然顺序对字典排序;
  • 第 19 行:函数 [array_keys($dictionary)] 以数组形式返回字典的键列表;
  • 第 24 行:函数 [array_values($dictionary)] 以数组形式返回字典的值列表;
  • 第 29 行:函数 [array_is_list] (PHP 8.1)在数组的键依次为 0、1、2……时,即数组是列表时,返回 [true] 。函数 [var_export] 返回一个值的 PHP 表示(“true”或“false”);
  • 第 46 行:函数 [exists] 接受一个数组([array])和一个字符串([string]);
  • 第 49 行:函数 [isset($variable)] 返回 [true] 的条件是变量 [$variable] 存在且值不是 [null];否则返回 [false]。应用于数组元素时,它用来判断某个键是否存在。函数 [array_key_exists($key, $array)] 做同样的事,但它会返回 [true] ,即使与键关联的值是 [null];
  • 第 36 行:运算符 [??](“空合并”)在左操作数存在且不为 [null] 时返回左操作数,否则返回右操作数。这是为缺失的键获取默认值的简洁方式,而且不会产生警告;
  • 第 38 行:函数 [unset($variable)] 删除变量 [$variable],这里它是字典的一个元素。

3.6.3. 多维数组

脚本 [basics-07.php] 如下:

<?php

declare(strict_types=1);

// 经典多维数组
// 初始化
$multi = [[0, 1, 2], [10, 11, 12, 13], [20, 21, 22, 23, 24]];
// 遍历
for ($i1 = 0; $i1 < count($multi); $i1++) {
    for ($i2 = 0; $i2 < count($multi[$i1]); $i2++) {
        print "multi[$i1][$i2]=" . $multi[$i1][$i2] . "\n";
    }
}
// 多维字典
// 初始化
$multi = ["zero" => [0, 1, 2], "one" => [10, 11, 12, 13], "two" => [20, 21, 22, 23, 24]];
// 遍历
foreach ($multi as $key => $value) {
    for ($i2 = 0; $i2 < count($value); $i2++) {
        print "multi[$key][$i2]={$multi[$key][$i2]}\n";
    }
}

结果:

> php basics-07.php
multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi[zero][0]=0
multi[zero][1]=1
multi[zero][2]=2
multi[one][0]=10
multi[one][1]=11
multi[one][2]=12
multi[one][3]=13
multi[two][0]=20
multi[two][1]=21
multi[two][2]=22
multi[two][3]=23
multi[two][4]=24

说明:

  • 第 7 行:数组 [$multi] 的元素本身也是数组;
  • 第 11 行:在用引号括起来的字符串内,对 [$multi[$i1][$i2]] 的简单插值不起作用:PHP 只会求值到 [$multi[$i1]]。所以我们把这个表达式移出字符串,改用连接运算;
  • 第 16 行:数组 [$multi] 变成一个(键,值)字典,其中每个值都是一个数组;
  • 第 20 行:另一种解决办法:在用引号括起来的字符串内,记法 [{$expression}] 允许对复杂表达式求值。我们将在下一节再回到这一点。

3.7. 字符串

3.7.1. 记法

脚本 [basics-08.php] 如下:

<?php

declare(strict_types=1);

// 字符串表示法
$string1 = "one";
$string2 = 'one';
print "[$string1,$string2]\n";
// 在单引号之间,变量不会被求值
print '[$string1,$string2]' . "\n";
// 表示法 {$...} 界定要求值的表达式
$person = ["name" => "dupont", "age" => 34];
print "{$person['name']} is {$person['age']} years old\n";
// 多行字符串(heredoc)
$text = <<<END
    name: $string1
    age: {$person['age']}
    END;
print "$text\n";

结果:

1
2
3
4
5
6
> php basics-08.php
[one,one]
[$string1,$string2]
dupont is 34 years old
name: one
age: 34

说明:

  • 第 6–7 行:字符串可以用双引号或单引号括起来;
  • 第 8 行:用双引号括起来时,其中的变量会被求值;
  • 第 10 行:在单引号内,它们不会被求值:字符串按原样显示。同样,[\n] 在这里也不表示换行,因此要连接 ["\n"];
  • 第 13 行:记法 [{$...}] 允许在字符串中对比简单变量更复杂的表达式求值,这里是字典的元素。旧版 PHP 中的 [${variable}] 记法自 PHP 8.2 起已被弃用:不应再使用它;
  • 第 15–18 行:[heredoc] 语法允许字符串跨越多行。字符串从 [<<<END] 之后开始,到标记 [END] 结束 (名称是任意的)。其中的变量会被求值,就像它们被括在引号中一样。从 PHP 7.3 起,结束标记可以缩进:这时该缩进会从字符串的所有行中去除。

3.7.2. 比较

脚本 [basics-09.php] 如下:

<?php

// 严格遵守函数参数的类型
declare(strict_types=1);

// 比较函数
function compareStrings(string $string1, string $string2): void
{
    // 比较 string1 和 string2
    if ($string1 === $string2) {
        print "[$string1] is equal to [$string2]\n";
    } else {
        print "[$string1] is different from [$string2]\n";
    }
}

// 字符串比较测试
compareStrings("abcd", "abcd");
compareStrings("", "");
compareStrings("1", "");

// 查找子字符串(PHP 8)
$file = "taxpayersdata.txt";
print "[$file] contains [data]: " . var_export(str_contains($file, "data"), true) . "\n";
print "[$file] starts with [tax]: " . var_export(str_starts_with($file, "tax"), true) . "\n";
print "[$file] ends with [.json]: " . var_export(str_ends_with($file, ".json"), true) . "\n";
// 子字符串的位置
print "position of [data] in [$file]: " . strpos($file, "data") . "\n";
// 长度、大写
print "length of [$file]: " . strlen($file) . ", in uppercase: " . strtoupper($file) . "\n";
// 注意:strlen 按字节计数,mb_strlen 按字符计数
print "strlen(\"café\")=" . strlen("café") . ", mb_strlen(\"café\")=" . mb_strlen("café") . "\n";

结果:

> php basics-09.php
[abcd] is equal to [abcd]
[] is equal to []
[1] is different from []
[taxpayersdata.txt] contains [data]: true
[taxpayersdata.txt] starts with [tax]: true
[taxpayersdata.txt] ends with [.json]: false
position of [data] in [taxpayersdata.txt]: 9
length of [taxpayersdata.txt]: 17, in uppercase: TAXPAYERSDATA.TXT
strlen("café")=5, mb_strlen("café")=4

说明:

  • 第 10 行:我们本可以使用比较运算符 [] 而不是 [=]。后者限制更严格,它要求两个操作数的类型相同。请注意,这里它本可以被运算符 [] 取代,因为函数签名中两个参数的类型都被设为 [string]* 。不过,我们仍将继续使用 *[=];
  • 第 24 行:函数 [str_contains($string, $substring)] (PHP 8.0)返回 [true] ,如果 [$substring] 存在于 [$string] 中;
  • 第 25 行:函数 [str_starts_with] (PHP 8.0)检查字符串的开头;
  • 第 26 行:函数 [str_ends_with] (PHP 8.0)检查字符串的结尾;
  • 第 28 行:函数 [strpos($string, $substring)] 返回 [$substring] 在 [$string] 中的位置,其中第一个字符的位置为 0,若子串不存在则返回 [false] 。在 PHP 8 之前,检查子串是否存在要使用 [strpos(...) !== false],这是一种容易引起误解的写法,因为位置 0 会被转换为 [false]:[str_contains] 可读性要好得多;
  • 第 30 行:函数 [strlen] 返回字符串的长度,而 [strtoupper] 把它转换为大写;
  • 第 32 行:[strlen] 统计的是字节数,而不是字符数。课程文件采用 UTF-8 编码,其中一个带重音符号的字符占两个字节:“café”有 4 个字符,但有 5 个字节。扩展 [mbstring] 的函数(mb_strlen、mb_substr、mb_strtoupper……)则以字符为单位进行操作。

3.7.3. 字符串与数组之间的关系

脚本 [basics-10.php] 如下:

<?php

declare(strict_types=1);

// 字符串转数组
$string = "1:2:3:4";
$tab = explode(":", $string);
// 遍历数组
print "tab has " . count($tab) . " elements\n";
for ($i = 0; $i < count($tab); $i++) {
    print "tab[$i]=$tab[$i]\n";
}
// 数组转字符串
$string2 = implode(":", $tab);
print "string2=$string2\n";
// 我们添加一个空字段
$string .= ":";
print "string=$string\n";
$tab = explode(":", $string);
// 遍历数组
print "tab has " . count($tab) . " elements\n";
for ($i = 0; $i < count($tab); $i++) {
    print "tab[$i]=$tab[$i]\n";
} // 现在有 5 个元素,最后一个为空
// 我们再添加一个空字段
$string .= ":";
print "string=$string\n";
$tab = explode(":", $string);
// 遍历数组
print "tab has " . count($tab) . " elements\n";
for ($i = 0; $i < count($tab); $i++) {
    print "tab[$i]=$tab[$i]\n";
} // 现在有 6 个元素,最后两个为空

结果:

> php basics-10.php
tab has 4 elements
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
string2=1:2:3:4
string=1:2:3:4:
tab has 5 elements
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
string=1:2:3:4::
tab has 6 elements
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
tab[5]=

说明:

  • 第 7 行:函数 [explode($separator, $string)] 取出 [$string] 中由 [$separator] 分隔的各个字段。因此,[explode(":", $string)] 以数组形式取出 [$string] 中由字符串 ":" 分隔的各个元素;
  • 第 14 行:函数 [implode($separator, $array)] 执行与函数 [explode] 相反的操作。它返回一个由 [$array] 的元素组成、元素之间以 [$separator] 分隔的字符串;
  • 第 17 行:运算符 [.=] 把一个字符串追加到另一个字符串的末尾。结果表明,字符串末尾的空字段会在 [explode] 返回的数组中产生一个空元素。

3.7.4. 正则表达式

脚本 [basics-11.php] 如下:

<?php

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

// php 中的正则表达式
// 获取字符串的不同字段
// 模式:一串数字,两侧是任意字符
// 我们只想获取这串数字
$pattern = "/(\d+)/";
// 将字符串与模式进行匹配
comparePattern2String($pattern, "xyz1234abcd");
comparePattern2String($pattern, "12 34");
comparePattern2String($pattern, "abcd");

// 模式:一串数字,两侧是任意字符
// 我们想要这串数字以及它前后的字段
$pattern = "/^(.*?)(\d+)(.*?)$/";
// 将字符串与模式进行匹配
comparePattern2String($pattern, "xyz1234abcd");
comparePattern2String($pattern, "12 34");
comparePattern2String($pattern, "abcd");

// 模式 - dd/mm/yy 格式的日期
$pattern = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
comparePattern2String($pattern, "10/05/97");
comparePattern2String($pattern, "  04/04/01  ");
comparePattern2String($pattern, "5/1/01");

// 模式 - 十进制数
$pattern = "/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
comparePattern2String($pattern, "187.8");
comparePattern2String($pattern, "-0.6");
comparePattern2String($pattern, "4");
comparePattern2String($pattern, ".6");
comparePattern2String($pattern, "4.");
comparePattern2String($pattern, " + 4");

// 结束
exit;

// --------------------------------------------------------------------------
function comparePattern2String(string $pattern, string $string): void
{
    // 将字符串 $string 与模式 $pattern 比较
    // 我们将字符串与模式进行匹配
    $fields = [];
    $matches = preg_match($pattern, $string, $fields);
    // 显示结果
    print "\nResults($pattern,$string)\n";
    if ($matches === 1) {
        for ($i = 0; $i < count($fields); $i++) {
            print "fields[$i]=$fields[$i]\n";
        }
    } else {
        print "The string [$string] does not match the pattern [$pattern]\n";
    }
}

结果:

> php basics-11.php

Results(/(\d+)/,xyz1234abcd)
fields[0]=1234
fields[1]=1234

Results(/(\d+)/,12 34)
fields[0]=12
fields[1]=12

Results(/(\d+)/,abcd)
The string [abcd] does not match the pattern [/(\d+)/]

Results(/^(.*?)(\d+)(.*?)$/,xyz1234abcd)
fields[0]=xyz1234abcd
fields[1]=xyz
fields[2]=1234
fields[3]=abcd

Results(/^(.*?)(\d+)(.*?)$/,12 34)
fields[0]=12 34
fields[1]=
fields[2]=12
fields[3]= 34

Results(/^(.*?)(\d+)(.*?)$/,abcd)
The string [abcd] does not match the pattern [/^(.*?)(\d+)(.*?)$/]

Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,10/05/97)
fields[0]=10/05/97
fields[1]=10
fields[2]=05
fields[3]=97

Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,  04/04/01  )
fields[0]=  04/04/01
fields[1]=04
fields[2]=04
fields[3]=01

Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,5/1/01)
The string [5/1/01] does not match the pattern [/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/]

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,187.8)
fields[0]=187.8
fields[1]=
fields[2]=187.8

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,-0.6)
fields[0]=-0.6
fields[1]=-
fields[2]=0.6

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4)
fields[0]=4
fields[1]=
fields[2]=4

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,.6)
fields[0]=.6
fields[1]=
fields[2]=.6

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4.)
fields[0]=4.
fields[1]=
fields[2]=4.

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/, + 4)
fields[0]= + 4
fields[1]=+
fields[2]=4

说明:

这里,我们使用正则表达式从字符串中提取各个字段。正则表达式使我们能够克服 [explode] 函数的局限。其原理是使用 [preg_match] 函数把字符串与另一个称为模式的字符串进行比较:[$matches = preg_match($pattern, $string, $fields)] (第 48 行)。如果能在字符串中找到该模式,函数 [preg_match] 返回整数 1,否则返回 0。若找到,[$fields[0]] 表示与模式相对应的子串。此外,如果模式包含用括号括起来的子模式,[$fields[1]] 就是 [$string] 中与第一个子模式相对应的部分,[$fields[2]] 是 [$string] 中与第二个子模式相对应的部分,依此类推。让我们回到脚本:

  • 第 10 行:该模式匹配字符串中任意位置出现的由一个或多个(+)数字(\d)组成的序列。此外,该模式还定义了一个用括号括起来的子模式;
  • 第 12 行:把模式 /(\d+)/ 与字符串 "xyz1234abcd" 进行匹配。我们看到子串 1234 与该模式匹配。因此,[$fields[0]] 等于 "1234"。此外,该模式有一个用括号括起来的子模式。我们将得到 [$fields[1]="1234"];
  • 第 13 行:把模式 /(\d+)/ 与字符串 "12 34" 进行比较。我们看到子串 12 和 34 都与该模式匹配。比较在第一个与模式匹配的子串处停止。因此,我们将有 [$fields[0]=12] 和 [$fields[1]=12];
  • 第 14 行:把模式 /(\d+)/ 与字符串 "abcd" 进行比较。没有找到匹配;
  • 第 51 行:[preg_match] 返回一个整数(如果模式有错误则返回 [false] ):它要与 1 进行严格比较。

下面解释后面代码中使用的模式:

$pattern = "/^(.*?)(\d+)(.*?)$/";

匹配字符串的开头(^),后跟零个或多个(*)任意字符(.),再后跟一个或多个(+)数字,再后跟零个或多个(*)任意字符(.)。模式 (.*) 匹配零个或多个任意字符。这样的模式可以匹配任何字符串。因此,在模式 /^(.*)(\d+)(.*)$/ 中,第一个子模式 (.*) 会匹配除最后一个数字之外的所有数字,只给子模式 (\d+) 留下最后一个数字。模式 (.*?)(\d+) 匹配 0 个或多个任意字符,直到下一个子模式(?)为止,在这里下一个子模式就是 \d+。因此,数字不再被模式 (.*) 捕获。上面的模式因此匹配 [字符串的开头(^)、由任意字符组成的序列(.*?)、由一个或多个数字组成的序列(\d+)、由任意字符组成的序列(.*?)、字符串的结尾($)]。

$pattern = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";

匹配 [字符串的开头(^)、由 0 个或多个空格组成的序列(\s*)、2 个数字(\d\d)、字符 /(\/)、2 个数字、/、2 个数字、由 0 个或多个空格组成的序列(\s*)、字符串的结尾($)]。

$pattern = "/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";

匹配 [字符串的开头(^)、0 个或多个空格(\s*)、出现 0 次或 1 次(?)的 + 或 - 符号([+-])、由 0 个或多个空格组成的序列(\s*)、1 个或多个数字后跟一个小数点再后跟零个或多个数字(\d+\.\d*),或者(|)一个小数点(\.)后跟一个或多个数字(\d+),或者(|)一个或多个数字(\d+)、由 0 个或多个空格组成的序列(\s*)]。PHP 7 课程把它写成 [+|-]:在方括号内,字符 | 没有特殊含义,因此这个模式还接受数字前面的 | 符号。[+-] 才是正确的写法。

注意:正则表达式中的术语 [space] 指一组字符:空白、换行符 \n、制表符 \t、回车符 \r、换页符 \f……

3.8. 函数

3.8.1. 参数传递方式

脚本 [basics-12.php] 如下:

<?php

// 参数如何传递给函数
// 严格遵守参数类型
declare(strict_types=1);

function f(int &$i, int $j): void
{
    // $i 将按引用获取
    // $j 将按值获取
    $i++;
    $j++;
    print "f[i,j]=[$i,$j]\n";
}

// 测试
$i = 0;
$j = 0;
// $i 和 $j 被传递给函数 f
f($i, $j);
print "test[i,j]=[$i,$j]\n";

结果:

1
2
3
> php basics-12.php
f[i,j]=[1,1]
test[i,j]=[1,0]

说明:

上面的代码演示了向函数传递参数的两种方式。请看下面的例子:

1
2
3
4
5
6
7
8
9
function f(int &$a, int $b): void
{
    …
}

// 主程序
$i = 10;
$j = 20;
f($i, $j);
  • 第 1 行:定义形参 [$a] 和 [$b] ,它们属于函数 [f]。该函数处理这两个形参;
  • 第 9 行:调用函数 [f] ,传入两个实参 [$i] 和 [$j]。形参([$a]、[$b])与实参([$i]、[$j])之间的关系由第 1 行和第 9 行定义:
    • [&$a]:符号 & 表示形参 [$a] 将取得实参 [$i] 的地址作为值。换句话说,[$a] 和 [$i] 是对同一内存位置的两个引用。操作形参 [$a] 等同于操作实参 [$i]。代码的执行证明了这一点。这种传递方式适用于输出参数。这种传递方式称为“按引用传递”;
    • [$b]:形参 [$b] 将取得实参 [$j] 的值。这是按值传递。形参和实参是两个不同的变量。操作形参 [$b] 对实参 [$j] 没有影响。代码的执行证明了这一点。这种传递方式适用于输入参数。

考虑函数 [swap],它接受两个形参:[$a] 和 [$b]。该函数交换这两个参数的值。因此,当调用 [swap($i, $j)] 时,调用代码期望这两个实参的值被交换。所以它们是输出参数(会被修改)。因此我们这样写:

1
2
3
4
function swap(mixed &$a, mixed &$b): void
{
    [$a, $b] = [$b, $a];
}

注意:有人可能认为,对于大型数据集、数组和字典,按引用传递也很合适,可以避免复制它们。这是不必要的:实际上,只有当函数修改按值传递的数组时,PHP 才会复制它。因此,按引用传递应当只用于输出参数。

下面的脚本 [basics-13.php],展示了更多示例:

<?php

// 参数如何传递
// 此脚本中没有 declare(strict_types=1):我们处于“强制转换”模式

function f(&$i, $j)
{
    // $i 将按引用获取
    // $j 将按值获取
    $i++;
    $j++;
    print "f[i,j]=[$i,$j]\n";
}

function g(int &$i, int $j): void
{
    // $i 将按引用获取
    // $j 将按值获取
    $i++;
    $j++;
    print "g[i,j]=[$i,$j]\n";
}

// 测试
$i = 0;
$j = 0;
// $i 和 $j 被传递给函数 f
f($i, $j);
print "test[i,j]=[$i,$j]\n";
// $i 和 $j 被传递给函数 g
g($i, $j);
print "test[i,j]=[$i,$j]\n";
// 我们向 f 传递 float 参数
$a = 5.0;
$b = 6.2;
f($a, $b);
print "test[a,b]=[$a,$b]\n";
// 我们向 g 传递 float 参数
$a = 5.0;
$b = 6.0;
g($a, $b);
print "test[a,b]=[$a,$b]\n";

说明:

  • 第 4 行:与本课程所有其他脚本不同,这个脚本不包含 [declare(strict_types=1)] 语句:PHP 以“强制”模式运行;
  • 第 6–13 行:上一段讨论的 [f] 函数,但参数没有类型;
  • 第 15–22 行:函数 [g] 做的事与函数 [f] 相同,但指定了所期望参数的类型。它期望两个 [int] 类型的参数。我们想看看,当传给函数的实参与函数所期望的类型不符时会发生什么;
  • 第 25–26 行:[$i] 和 [$j] 是两个整数;
  • 第 28 行:用期望类型的参数调用函数 [f] ;
  • 第 31 行:用期望类型的参数调用函数 [g] ;
  • 第 34–35 行:变量 [$a] 和 [$b] 的类型为 [float];
  • 第 36 行:调用函数 [f] ,参数类型为 [float];
  • 第 39–41 行:调用函数 [g] ,参数类型为 [float],而这不是所期望的类型。

结果:

1
2
3
4
5
6
7
8
9
> php basics-13.php
f[i,j]=[1,1]
test[i,j]=[1,0]
g[i,j]=[2,1]
test[i,j]=[2,0]
f[i,j]=[6,7.2]
test[a,b]=[6,6.2]
g[i,j]=[6,7]
test[a,b]=[6,6]
  • 函数 [f] 的参数没有类型,它接受了这两个 [float] 类型的参数,并作了如下处理:[$i] 为 6.0(显示为 6),而 [$j] 为 7.2;
  • 函数 [g] 接受了这两个 [float] 类型的参数,但把它们转换成了 [int] 类型。从按引用传递的变量 [$a] 中可以看出这一点,它已经变成了整数 6。

浮点数 5.0 和 6.0 没有小数部分:把它们转换为整数不会造成任何信息丢失。那么浮点数 5.3 会怎样呢?在 PHP 7 中,它会被悄悄地转换为整数 5。自 PHP 8.1 起,这种会丢失信息的转换已被标记为弃用:它将在 PHP 的未来版本中变成错误。

现在让我们在严格模式下做同样的事。脚本 [basics-13b.php] 与脚本 [basics-13.php] 完全相同,只是以如下语句开头:

declare(strict_types=1);

这条指令规定必须遵守形参的类型。如果不遵守,就会报告错误。执行结果如下:

> php basics-13b.php
f[i,j]=[1,1]
test[i,j]=[1,0]
g[i,j]=[2,1]
test[i,j]=[2,0]
f[i,j]=[6,7.2]
test[a,b]=[6,6.2]

Fatal error: Uncaught TypeError: g(): Argument #1 ($i) must be of type int, float given, called in .../php8-oct-2026/scripts-console/basics/basics-13b.php on line 42 and defined in .../php8-oct-2026/scripts-console/basics/basics-13b.php:16
Stack trace:
#0 .../php8-oct-2026/scripts-console/basics/basics-13b.php(42): g(5.0, 6.0)
#1 {main}
  thrown in .../php8-oct-2026/scripts-console/basics/basics-13b.php on line 16

PHP 解释器抛出了 [TypeError] 错误,表明传给函数 [g] 的第一个参数类型不对:g(): Argument #1 ($i) must be of type int; float was provided。消息指出了出错调用所在的行号(42)以及函数定义所在的行号(16)。由于这个错误没有被捕获(没有 [try / catch]),脚本终止。建议尽可能对参数类型保持严格,以便检测函数调用错误:这就是课程中所有脚本都以 [declare(strict_types=1)] 开头的原因。

3.8.2. PHP 8 中的函数参数

PHP 8 大大增强了函数的声明和调用。脚本 [basics-14.php] 演示了这些新特性:

<?php

// PHP 8 中的函数参数
declare(strict_types=1);

// 1 - 带默认值的参数
function greeting(string $name, string $phrase = "Hello", bool $uppercase = false): string
{
    $message = "$phrase $name";
    return $uppercase ? strtoupper($message) : $message;
}

print greeting("Pierre") . "\n";
print greeting("Pierre", "Good evening") . "\n";
// 2 - 命名参数(PHP 8.0):可以跳过某个参数,并以任意顺序给出
print greeting("Pierre", uppercase: true) . "\n";
print greeting(uppercase: true, phrase: "Hi", name: "Paul") . "\n";
// 预定义函数也接受命名参数
print str_pad(string: "7", length: 3, pad_string: "0", pad_type: STR_PAD_LEFT) . "\n";

// 3 - 联合类型(PHP 8.0):参数可以是所列类型之一
function double(int|float $number): int|float
{
    return 2 * $number;
}

var_dump(double(4));
var_dump(double(4.5));

// 4 - 可空类型:?string 等价于 string|null
function length(?string $string): int
{
    // 如果左操作数为 null,?? 运算符返回其右操作数
    return strlen($string ?? "");
}

print "length(\"abc\")=" . length("abc") . ", length(null)=" . length(null) . "\n";

// 5 - mixed 类型(PHP 8.0)和 match 表达式(PHP 8.0)
function describe(mixed $value): string
{
    // match 使用 === 进行比较并返回一个值
    return match (true) {
        is_int($value), is_float($value) => "the number $value",
        is_string($value) => "the string [$value]",
        is_bool($value) => "the boolean " . ($value ? "true" : "false"),
        is_array($value) => "an array of " . count($value) . " element(s)",
        default => "a value of type " . get_debug_type($value),
    };
}

foreach ([12, 3.5, "abc", false, [1, 2], null] as $value) {
    print describe($value) . "\n";
}

// 对一个值进行 match
$children = 3;
$shares = match ($children) {
    0 => 0.0,
    1, 2 => $children * 0.5,
    default => 1 + ($children - 2) * 1.0,
};
print "$children child(ren) bring $shares share(s)\n";

// 6 - 可变数量的参数(variadic)和 ...(展开)运算符
function sum(int|float ...$numbers): int|float
{
    // $numbers 是一个数组
    return array_sum($numbers);
}

print "sum()=" . sum() . "\n";
print "sum(1, 2, 3)=" . sum(1, 2, 3) . "\n";
$values = [10, 20, 30.5];
// 数组被“展开”为实际参数
print "sum(...\$values)=" . sum(...$values) . "\n";
// ... 运算符还可以用来合并数组
$all = [0, ...$values, 40];
print "all=[" . implode(",", $all) . "]\n";

结果:

> php basics-14.php
Hello Pierre
Good evening Pierre
HELLO PIERRE
HI PAUL
007
int(8)
float(9)
length("abc")=3, length(null)=0
the number 12
the number 3.5
the string [abc]
the boolean false
an array of 2 element(s)
a value of type null
3 child(ren) bring 2 share(s)
sum()=0
sum(1, 2, 3)=6
sum(...$values)=60.5
all=[0,10,20,30.5,40]

说明:

  • 第 7 行:参数 [$phrase] 和 [$uppercase] 具有默认值。调用函数时可以省略它们(第 13 行),这时它们取默认值;
  • 第 10 行:三元运算符 [condition ? value1 : value2] 在条件为真时返回 [value1] ,条件为假时则返回 [value2];
  • 第 16 行:命名参数(PHP 8.0)。实参前面写上形参的名称,后跟一个冒号(:)。这样你就可以在不指定第二个参数的情况下为第三个参数赋值,第二个参数保持其默认值;
  • 第 17 行:使用命名参数时,参数的顺序不再重要。这提高了代码的可读性:[uppercase: true] 比单独一个 [true] 更具描述性;
  • 第 19 行:PHP 的预定义函数也接受命名参数。它们的名称是在 php.net 文档中列出的名称;
  • 第 22 行:联合类型 [int|float] (PHP 8.0)表示参数可以是 [int] 或 [float]。返回结果同样如此;
  • 第 31 行:类型 [?string] 是可空类型:参数是字符串或值 [null]。这是 [string|null] 的简写记法。注意:在 PHP 7 中,人们常常写成 [string $string = null] 来达到同样的效果。这种记法(“隐式可空”)自 PHP 8.4 起已被弃用:必须写成 [?string $string = null];
  • 第 34 行:运算符 [??],我们之前已经遇到过:如果 [$string] 等于 [null],就使用空字符串。事实上,自 PHP 8.1 起,把 [null] 传给预定义函数的不可为空参数(例如这里的 [strlen(null)])已被弃用;
  • 第 40 行:类型为 [mixed] 的参数接受任何值,包括 [null];
  • 第 43–49 行:表达式 [match] (PHP 8.0)。它把括号中的值与 => 箭头左侧的各个值进行比较,并返回第一个比较为真的箭头右侧的值。使用 [match (true)] 时,条件写在左侧:第一个为真的条件优先。多个值可以用逗号分隔(第 44 行)。[default] 涵盖所有其他情况;
  • 第 48 行:函数 [get_debug_type] (PHP 8.0)返回值的类型名称,其写法与代码中一致:int、float、string、null,或对象的类名。[gettype] 则相反,返回的是 integer 或 double 之类的历史名称;
  • 第 58–62 行:[match] 应用于一个值。这里,变量 [$children] 依次与值 0、1、2 比较;否则,适用 [default] 分支。与 [switch] 语句([match] 实际上取代了它)不同,比较使用 [===] 进行,[match] 是返回值的表达式,而且无需担心 [break] 语句。如果没有合适的分支,并且没有 *[default]*,则 *[match] 会抛出 *[UnhandledMatchError] 错误;
  • 第 66 行:[int|float ...$numbers] 是可变参数:函数接受任意数量的实参(甚至一个都没有),PHP 会把它们收集到数组 [$numbers] 中。可变参数始终是最后一个参数;
  • 第 76 行:放在调用中数组之前的 [...] (展开)运算符会把数组“展开”:它的元素成为函数的实参。[sum(...$values)] 等价于 [sum(10, 20, 30.5)];
  • 第 78 行:同一个运算符还允许把一个数组的元素插入另一个数组中。

3.8.3. 函数返回的结果

脚本 [basics-15.php] 如下:

<?php

// 严格模式下的类型
declare(strict_types=1);

// 函数返回的结果
// 函数可以在数组中返回多个值
[$res1, $res2, $res3] = f1(10);
print "[$res1,$res2,$res3]\n";
$res = f1(10);
for ($i = 0; $i < count($res); $i++) {
    print "f1: res[$i]=$res[$i]\n";
}
// 关联数组也可以被“解构”
["min" => $min, "max" => $max] = minMax([4, -2, 17, 8]);
print "minMax: [min=$min,max=$max]\n";

// 函数可以返回一个对象
$res = f2(10);
print "f2: [$res->res1,$res->res2,$res->res3]\n";
// 是哪种对象?
print "kind of object: ";
var_dump($res);

// 我们对函数 f3 做同样的事
$res = f3(10);
print "f3: [$res->res1,$res->res2,$res->res3]\n";
// 是哪种对象?
print "kind of object: ";
var_dump($res);

// 函数可以返回一个对象或 null
$res = f4(10);
// 如果 $res 为 null,nullsafe 运算符 ?-> 返回 null 而不是引发错误
print "f4(10): res1=" . ($res?->res1 ?? "none") . "\n";
$res = f4(-10);
print "f4(-10): res1=" . ($res?->res1 ?? "none") . "\n";

// 结束
exit;

// 函数 f1
function f1(int $value): array
{
    // 返回一个数组 ($value+1,$value+2,$value+3)
    return [$value + 1, $value + 2, $value + 3];
}

// 函数 minMax
function minMax(array $numbers): array
{
    // 返回一个关联数组
    return ["min" => min($numbers), "max" => max($numbers)];
}

// 函数 f2
function f2(int $value): object
{
    // 返回一个对象 ($value+1,$value+2,$value+3)
    // 通过将关联数组转换为对象获得
    return (object) ["res1" => $value + 1, "res2" => $value + 2, "res3" => $value + 3];
}

// 函数 f3 - 与函数 f2 作用相同
function f3(int $value): object
{
    // 返回一个对象 ($value+1,$value+2,$value+3)
    $res = new stdClass();
    $res->res1 = $value + 1;
    $res->res2 = $value + 2;
    $res->res3 = $value + 3;
    // 返回该对象
    return $res;
}

// 函数 f4 - 如果 $value 为正则返回一个对象,否则返回 null
function f4(int $value): ?object
{
    return $value >= 0 ? f3($value) : null;
}

结果:

> php basics-15.php
[11,12,13]
f1: res[0]=11
f1: res[1]=12
f1: res[2]=13
minMax: [min=-2,max=17]
f2: [11,12,13]
kind of object: object(stdClass)#1 (3) {
  ["res1"]=>
  int(11)
  ["res2"]=>
  int(12)
  ["res3"]=>
  int(13)
}
f3: [11,12,13]
kind of object: object(stdClass)#2 (3) {
  ["res1"]=>
  int(11)
  ["res2"]=>
  int(12)
  ["res3"]=>
  int(13)
}
f4(10): res1=11
f4(-10): res1=none

说明:

  • 前面的程序表明,PHP 函数可以以数组或对象的形式返回一组结果,而不只是单个结果。对象的概念将在后面的章节中解释;
  • 第 43–47 行:函数 [f1] 以数组([array])的形式返回多个值;
  • 第 8 行:返回的数组被解包到三个变量中;
  • 第 15 行:解构也适用于关联数组:对每个变量指定要获取的值的键。函数 [minMax] 返回一个字典(第 53 行)。预定义函数 [min] 和 [max] 返回数组中最小和最大的元素;
  • 第 57–62 行:函数 [f2] 以对象([object])的形式返回多个值。它通过运算符 [(object)] 把关联数组转换为对象来做到这一点:数组中的每个键都成为对象的一个属性;
  • 第 65–74 行:函数 [f3] 与函数 [f2] 做的事相同,但它显式地创建一个 [stdClass] 类型的对象(第 68 行),然后向其中添加属性。对象 O 的属性 A 记作 [$O->A];
  • 第 23 行:函数 [var_dump] 可以让我们看到对象的类型及其内容。在结果中,我们看到该对象的类型为 [stdClass],其属性 [res1] 的类型为整数,值为 11,等等。类型后面的编号 #1 或 #2 是对象的内部编号;
  • 第 77 行:返回类型 [?object] 表示函数 [f4] 返回一个对象或 [null];
  • 第 35–37 行:空安全运算符 [?->] (PHP 8.0)。如果 [$res] 等于 [null],则表达式 [$res?->res1] 等于 [null] 而不会引发错误;随后运算符 [??] 把 [null] 替换为“none”。在这里,单靠运算符 [??] 就足够了,因为它并不表示属性不存在。运算符 [?->] 在处理对象及其方法时将特别有用:[$client?->getAddress()?->getCity()]。

注意:PHP 7 课程中有一个函数写了 [$res->res1 = ...] ,却没有事先创建对象 [$res]。PHP 7 此时会默认创建一个 [stdClass] 对象,只给出一个简单的警告。自 PHP 8.0 起,这是一个致命错误(Attempt to assign property on null):对象必须在使用之前创建。

3.8.4. 函数也是值

在 PHP 中,函数可以存储在变量中,可以作为参数传递给另一个函数,也可以作为结果返回。脚本 [basics-17.php] 演示了编写和使用这些函数的不同方式:

<?php

// 函数也是值
declare(strict_types=1);

$numbers = [4, -2, 17, 8, -5];

// 1 - 赋给变量的匿名函数
$square = function (int $x): int {
    return $x * $x;
};
print "square(5)=" . $square(5) . "\n";

// 2 - 作为参数传给预定义函数的匿名函数
// array_map 将该函数应用于数组的每个元素
$squares = array_map($square, $numbers);
print "squares=[" . implode(",", $squares) . "]\n";

// 3 - 使用外部变量的匿名函数:use 关键字
$threshold = 5;
$large = array_filter($numbers, function (int $x) use ($threshold): bool {
    return $x > $threshold;
});
print "numbers > $threshold: [" . implode(",", $large) . "]\n";

// 4 - 箭头函数(PHP 7.4):单个表达式,外部变量自动捕获
$positives = array_filter($numbers, fn(int $x): bool => $x >= 0);
print "positives=[" . implode(",", $positives) . "]\n";
// 使用比较函数排序:<=> 运算符返回 -1、0 或 1
$sorted = $numbers;
usort($sorted, fn(int $a, int $b): int => $b <=> $a);
print "descending sort=[" . implode(",", $sorted) . "]\n";

// 5 - 在数组中搜索(PHP 8.4)
print "first negative: " . array_find($numbers, fn(int $x): bool => $x < 0) . "\n";
print "at least one > 10: " . var_export(array_any($numbers, fn(int $x): bool => $x > 10), true) . "\n";
print "all > -10: " . var_export(array_all($numbers, fn(int $x): bool => $x > -10), true) . "\n";

// 6 - 一等可调用语法(PHP 8.1):functionName(...)
$uppercase = strtoupper(...);
print $uppercase("hello") . "\n";
$names = ["dupont", "durand", "martin"];
print "names=[" . implode(",", array_map(ucfirst(...), $names)) . "]\n";

// 7 - 管道运算符 |>(PHP 8.5):左侧的结果被传给右侧的函数
$result = "  Hello everybody out there  "
    |> trim(...)
    |> strtolower(...)
    |> (fn(string $s): string => str_replace(" ", "-", $s));
print "result=[$result]\n";
// 不使用管道运算符的等价写法
$result = str_replace(" ", "-", strtolower(trim("  Hello everybody out there  ")));
print "result=[$result]\n";

结果:

> php basics-17.php
square(5)=25
squares=[16,4,289,64,25]
numbers > 5: [17,8]
positives=[4,17,8]
descending sort=[17,8,4,-2,-5]
first negative: -2
at least one > 10: true
all > -10: true
HELLO
names=[Dupont,Durand,Martin]
result=[hello-everybody-out-there]
result=[hello-everybody-out-there]

说明:

  • 第 9–11 行:一个匿名(无名)函数被赋给变量 [$square]。注意末尾的分号:这是一个赋值语句;
  • 第 12 行:通过变量调用该函数;
  • 第 16 行:预定义函数 [array_map] 把作为第一个参数传入的函数应用于作为第二个参数传入的数组的每个元素,并返回结果数组;
  • 第 21–23 行:预定义函数 [array_filter] 返回数组中使作为第二个参数传入的函数返回 [true] 的元素。匿名函数并不知道周围代码中的变量:关键字 [use ($threshold)] 让它能够访问变量 [$threshold]。请注意,[array_filter] 会保留所选元素的键;这在这里没有影响,因为 [implode] 只使用值;
  • 第 27 行:箭头函数(PHP 7.4):[fn(parameters) => expression]。它只包含一个表达式,该表达式的值就是函数的结果。它自动拥有对周围代码中变量的读取权限:无需 [use]。这是编写作为参数传递的小函数最简洁的方式;
  • 第 31 行:函数 [usort] 使用一个比较函数对数组排序,该比较函数接受两个元素 [$a] 和 [$b],并根据 [$a] 应排在 [$b] 之前、与其同级还是之后,返回负数、零或正数。运算符 [<=>] (“太空船”)恰好返回 -1、0 或 1。通过写成 [$b <=> $a] 而不是 [$a <=> $b],我们就得到降序排序。请注意,[usort] 会修改传给它的数组(按引用传递):因此我们排序的是一个副本([$sorted]),它复制自数组 [$numbers];
  • 第 35 行:函数 [array_find]、[array_any]、和 [array_all] 是随 PHP 8.4 引入的。[array_find] 返回第一个使函数返回 [true] 的元素(如果没有,则返回 [null] ),[array_any] 在至少有一个元素满足条件时返回 [true] ,而 [array_all] 则要求所有元素都满足;
  • 第 40 行:一等可调用语法(PHP 8.1):[functionName(...)],括号之间有三个点,它并不调用函数,而是把函数本身作为 [Closure] 对象返回。然后可以把它当作匿名函数使用;
  • 第 43 行:预定义函数 [ucfirst] (首字母大写)被传给 [array_map];
  • 第 46–49 行:管道运算符 [|>] (PHP 8.5)。表达式 [value |> function] 以该值作为唯一的参数调用函数。各个调用按阅读顺序从左到右串联:用 [trim] 去掉首尾空格,用 [strtolower] 把文本转换为小写,然后把空格替换为连字符。与 [|>] 一起使用的箭头函数必须用括号括起来;
  • 第 52 行:不使用管道运算符的同样写法。函数是嵌套的,要从内向外阅读,与执行顺序相反。

3.9. 文本文件

脚本 [basics-16.php] 如下:

<?php

// 严格遵守函数参数的类型
declare(strict_types=1);

// 顺序处理文本文件
// 它是一组形如 login:pwd:uid:gid:info:dir:shell 的行
// 每一行以 login => [uid, gid, info, dir, shell] 的形式放入字典
// 我们设置文件名
$INFO = "info.txt";
// 我们以创建方式打开它
$file = fopen($INFO, "w");
if ($file === false) {
    print "Error opening the file $INFO for writing\n";
    exit;
}
// 我们生成任意内容
for ($i = 0; $i < 100; $i++) {
    fputs($file, "login$i:pwd$i:uid$i:gid$i:info$i:dir$i:shell$i\n");
}
// 我们关闭文件
fclose($file);

// 我们处理它 - fgets 保留行尾标记
// 这样读取空行时就不会得到空字符串
// 我们以读取方式打开它
$file = fopen($INFO, "r");
if ($file === false) {
    print "Error opening the file $INFO for reading\n";
    exit;
}

// 信息字典
$dict = [];
// 行的长度少于 1000 个字符
// 读取一行到行尾标记处停止
// 或到文件结束标记处停止
while (($line = fgets($file, 1000)) !== false) {
    // 如果存在行尾标记,则将其删除
    $line = cutNewLineChar($line);
    // 我们把这一行放入数组
    $info = explode(":", $line);
    // 我们获取 login
    $login = array_shift($info);
    // 我们忽略 pwd
    array_shift($info);
    // 我们在字典中创建一个条目
    $dict[$login] = $info;
}
// 我们关闭它
fclose($file);

// 使用字典
displayInfo($dict, "login10");
displayInfo($dict, "X");

// 读取文本文件的另一种方式:file 函数
$lines = file($INFO, FILE_IGNORE_NEW_LINES);
print "the file $INFO has " . count($lines) . " lines, the last one is [" . array_last($lines) . "]\n";

// 结束
exit;

// --------------------------------------------------------------------------
function displayInfo(array $dict, string $key): void
{
    // 如果字典 $dict 中存在与 key 关联的值,则显示它
    if (isset($dict[$key])) {
        // 值存在 - 它是数组吗?
        $value = $dict[$key];
        if (is_array($value)) {
            print "[$key," . implode(":", $value) . "]\n";
        } else {
            // $value 不是数组
            print "[$key,$value]\n";
        }
    } else {
        // $key 不是字典 $dict 的键
        print "the key [$key] does not exist\n";
    }
}

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

由脚本创建的 [info.txt] 文件:

1
2
3
4
5
6
login0:pwd0:uid0:gid0:info0:dir0:shell0
login1:pwd1:uid1:gid1:info1:dir1:shell1
login2:pwd2:uid2:gid2:info2:dir2:shell2
…
login98:pwd98:uid98:gid98:info98:dir98:shell98
login99:pwd99:uid99:gid99:info99:dir99:shell99

结果:

1
2
3
4
> php basics-16.php
[login10,uid10:gid10:info10:dir10:shell10]
the key [X] does not exist
the file info.txt has 100 lines, the last one is [login99:pwd99:uid99:gid99:info99:dir99:shell99]

说明:

  • 第 12 行:[fopen(file_name, "w")] 以写模式(w=write)打开文件 [file_name] 。如果文件不存在,就创建它;如果存在,就清空它。文件创建在当前目录,即运行脚本时所在的目录。如果创建失败,[fopen] 会发出警告并返回值 [false];
  • 第 13 行:通过将 [fopen] 的结果与 [false] 严格比较来测试它;
  • 第 19 行:[fputs($file, $string)] 把 [$string] 写入文件 [$file]。这里,字符串以行尾标记 [\n] 结束;
  • 第 22 行:[fclose($file)] 关闭文件 [$file];
  • 第 27 行:[fopen(file_name, "r")] 以读模式(r=read)打开文件 [file_name] 。如果打开文件失败(例如文件不存在),[fopen] 返回值 [false];
  • 第 34 行:字典在被填充之前先初始化为空。PHP 会在第一次执行 [$dict[$login] = ...] 赋值时创建该数组,但如果文件是空的,这个变量就不会存在,使用它就会触发警告;
  • 第 38 行:[fgets($file, 1000)] 读取文件的下一行,最多 1000 个字符。[while (($line = fgets($file, 1000)) !== false) {...}] 操作由两个连续的操作组成:1) [$line = fgets(...)] 和 2) [while ($line !== false)]。读完文件的最后一个字符之后,函数 [fgets] 返回值 [false],并且 [while] 循环停止。这里,函数 [fgets] 尝试最多读取 1000 个字符,但一遇到行尾字符就停止。由于这里所有行都少于 1000 个字符,[fgets] 每次读取一行文本,包括行尾字符。PHP 7 课程写的是 [while ($line = fgets($file, 1000))]:如果最后一行只有 "0",且没有行尾字符,循环就会过早停止,因为字符串 "0" 会被转换为 [false]。严格比较 [!== false] 避免了这个陷阱;
  • 第 40 行:函数 [cutNewLineChar] 删除所有行尾字符;
  • 第 44 行:函数 [array_shift($array)] 删除 [$array] 的第一个元素并将其作为结果返回;
  • 第 46 行:这里,我们忽略 [array_shift] 返回的结果;
  • 第 58 行:读取文本文件的另一种方式。函数 [file] 返回一个包含文件中所有行的数组。使用选项 [FILE_IGNORE_NEW_LINES] 时,行尾字符会被去掉。这比 [fgets] 循环更简单,但整个文件会被加载到内存中:对于非常大的文件,仍然最好逐行读取;
  • 第 71 行:函数 [is_array($variable)] 返回 [true] 的条件是 [$variable] 是数组,否则返回 [false] ;
  • 第 84 行:行尾字符在 Windows 系统上是字符串 "\r\n",在 Unix 系统上是 "\n"。函数 [rtrim($string, $characters)] 删除出现在 [$characters] 中的所有字符(这里是 \r 和 \n),这些字符位于 [$string] 的末尾。如果没有第二个参数,[rtrim] 会删除所有“空格”(空白字符、制表符、换行符等);函数 [trim] 则在字符串的两端做同样的事。

3.10. JSON 的编码/解码

文件夹 [scripts-console/json] 中包含本节的脚本:

1
2
3
4
5
json
├── family.json
├── json-01.php
├── json-02.php
└── json-03.php

JSON(JavaScript Object Notation)编码/解码在作为本文档主线的练习中会被大量使用。脚本 [json-01.php, json-02.php, json-03.php] 解释了在本文档其余部分中你需要了解的内容。

脚本 [json-01.php] 如下:

<?php

declare(strict_types=1);

$array1 = ["lastName" => "séléné", "firstName" => "bénédicte", "age" => 34];
// 对数组 array1 进行 JSON 编码,Unicode 字符被转义
print "JSON encoding of the array array1 with escaped Unicode characters\n";
$json1 = json_encode($array1);
print "json1=$json1\n";
// 对数组 array1 进行 JSON 编码,Unicode 字符不转义
print "JSON encoding of the array array1 with unescaped Unicode characters\n";
$json2 = json_encode($array1, JSON_UNESCAPED_UNICODE);
print "json2=$json2\n";
// JSON 解码为关联数组
print "JSON decoding of json2 into an associative array\n";
$array2 = json_decode($json2, true);
var_dump($array2);
foreach ($array2 as $key => $value) {
    print "$key:$value\n";
}
// JSON 解码为对象
print "JSON decoding of json2 into a stdClass object\n";
$object2 = json_decode($json2);
var_dump($object2);
print "firstName=$object2->firstName\n";
print "lastName=$object2->lastName\n";
print "age=$object2->age\n";

结果:

> php json-01.php
JSON encoding of the array array1 with escaped Unicode characters
json1={"lastName":"s\u00e9l\u00e9n\u00e9","firstName":"b\u00e9n\u00e9dicte","age":34}
JSON encoding of the array array1 with unescaped Unicode characters
json2={"lastName":"séléné","firstName":"bénédicte","age":34}
JSON decoding of json2 into an associative array
array(3) {
  ["lastName"]=>
  string(9) "séléné"
  ["firstName"]=>
  string(11) "bénédicte"
  ["age"]=>
  int(34)
}
lastName:séléné
firstName:bénédicte
age:34
JSON decoding of json2 into a stdClass object
object(stdClass)#1 (3) {
  ["lastName"]=>
  string(9) "séléné"
  ["firstName"]=>
  string(11) "bénédicte"
  ["age"]=>
  int(34)
}
firstName=bénédicte
lastName=séléné
age=34

说明:

  • 第 8 行:函数 [json_encode] 把其参数转换为 JSON 字符串。在得到的字符串中,带重音的字符 é 被替换成了它的 Unicode 码,以 \u 开头;
  • 第 12 行:我们重复同样的过程,这一次指定 Unicode 字符应按原样保留。得到的 JSON 字符串可读性好得多;
  • 第 16–20 行:我们执行相反的操作。我们把 JSON 字符串转换为关联数组:这是 [true] 这个参数的作用,它是 [json_decode] 的第二个参数。结果表明,我们确实得到了一个关联数组;
  • 第 23–27 行:如果没有参数 [true],[json_decode] 会把 JSON 字符串转换为 [stdClass] 类型的对象。对象 O 的属性 A 记作 [$O->A]。

多层数组可以编码为 JSON,如下面的脚本 [json-02.php] 所示:

<?php

declare(strict_types=1);

$array = [
    "lastName" => "séléné", "firstName" => "bénédicte", "age" => 34,
    "husband" => ["lastName" => "icariù", "firstName" => "ignacio", "age" => 35],
    "children" => [
        ["firstName" => "angèle", "age" => 8],
        ["firstName" => "andré", "age" => 2],
    ],
];
// 对多层数组进行 JSON 编码
print "JSON encoding of a multi-level array\n";
$json = json_encode($array, JSON_UNESCAPED_UNICODE);
print "json=$json\n";
// 同样的编码,以易读的方式呈现
print "JSON encoding with the JSON_PRETTY_PRINT option\n";
print json_encode($array["husband"], JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT) . "\n";

结果:

1
2
3
4
5
6
7
8
9
> php json-02.php
JSON encoding of a multi-level array
json={"lastName":"séléné","firstName":"bénédicte","age":34,"husband":{"lastName":"icariù","firstName":"ignacio","age":35},"children":[{"firstName":"angèle","age":8},{"firstName":"andré","age":2}]}
JSON encoding with the JSON_PRETTY_PRINT option
{
    "lastName": "icariù",
    "firstName": "ignacio",
    "age": 35
}

说明:

在 JSON 字符串中:

  • 非关联数组(列表)用方括号 [] 括起来;
  • 关联数组用花括号 {} 括起来。

第 19 行:[json_encode] 的选项使用 | 运算符(按位或)组合。选项 [JSON_PRETTY_PRINT] 生成跨多行缩进的 JSON 字符串,使其更易读。

脚本 [json-03.php] 演示如何处理如下 JSON 文件 [family.json]:

{
    "wife": {
        "lastName": "séléné",
        "firstName": "bénédicte",
        "age": 34
    },
    "husband": {
        "lastName": "icariù",
        "firstName": "ignacio",
        "age": 35
    },
    "children": [
        {
            "firstName": "angèle",
            "age": 8
        },
        {
            "firstName": "andré",
            "age": 2
        }
    ]
}

脚本 [json-03.php] 如下:

<?php

declare(strict_types=1);

// 读取 JSON 文件
$json = file_get_contents("family.json");
// 读取的内容是有效的 JSON 吗?(PHP 8.3)
if ($json === false || !json_validate($json)) {
    print "The file [family.json] is missing or does not contain valid JSON\n";
    exit;
}
// JSON 解码为对象
$family1 = json_decode($json);
print "----family1\n";
var_dump($family1);
// JSON 解码为关联数组
print "----family2\n";
$family2 = json_decode($json, true);
var_dump($family2);

说明:

  • 第 6 行:函数 [file_get_contents] 读取名为 [family.json] 的文件的内容,并把它存入变量 [$json]。如果读取操作失败,则返回 [false] ;
  • 第 8 行:如果作为参数传入的字符串是有效的 JSON,函数 [json_validate] (PHP 8.3)返回 [true] 。以前,必须先解码字符串,然后调用函数 [json_last_error];
  • 第 13–19 行:然后字符串被解码为对象,再解码为关联数组。

结果:

> php json-03.php
----family1
object(stdClass)#2 (3) {
  ["wife"]=>
  object(stdClass)#1 (3) {
    ["lastName"]=>
    string(9) "séléné"
    ["firstName"]=>
    string(11) "bénédicte"
    ["age"]=>
    int(34)
  }
  ["husband"]=>
  object(stdClass)#3 (3) {
    ["lastName"]=>
    string(7) "icariù"
    ["firstName"]=>
    string(7) "ignacio"
    ["age"]=>
    int(35)
  }
  ["children"]=>
  array(2) {
    [0]=>
    object(stdClass)#4 (2) {
      ["firstName"]=>
      string(7) "angèle"
      ["age"]=>
      int(8)
    }
    [1]=>
    object(stdClass)#5 (2) {
      ["firstName"]=>
      string(6) "andré"
      ["age"]=>
      int(2)
    }
  }
}
----family2
array(3) {
  ["wife"]=>
  array(3) {
    ["lastName"]=>
    string(9) "séléné"
    ["firstName"]=>
    string(11) "bénédicte"
    ["age"]=>
    int(34)
  }
  ["husband"]=>
  array(3) {
    ["lastName"]=>
    string(7) "icariù"
    ["firstName"]=>
    string(7) "ignacio"
    ["age"]=>
    int(35)
  }
  ["children"]=>
  array(2) {
    [0]=>
    array(2) {
      ["firstName"]=>
      string(7) "angèle"
      ["age"]=>
      int(8)
    }
    [1]=>
    array(2) {
      ["firstName"]=>
      string(6) "andré"
      ["age"]=>
      int(2)
    }
  }
}
  • 结果的第一部分显示了对 JSON 文件 [family.json] 解码得到的对象:JSON 对象变成了 [stdClass] 对象,而 JSON 的子女列表变成了 PHP 数组;
  • 第二部分显示了对同一 JSON 解码得到的关联数组:所有 JSON 对象都变成了关联数组。