原文链接：https://xiets.blog.csdn.net/article/details/130892395
版权声明：原创文章禁止转载
专栏目录：PHP 专栏（总目录）
- PHP 文档： https://www.php.net/docs.php
- PHP 中文手册：https://www.php.net/manual/zh/
- PHP 函数 API：https://www.php.net/manual/zh/funcref.php
安装 PHP 解释器有多种方式，最简单的方式是通过软件包管理工具直接命令安装：
brew install php # MacOS
scoop install php # Windows
apt install php # Linux (Ubuntu)
系统中需要有安装对应的软件包管理工具。
1. 语法
PHP 源码文件和脚本代码：
PHP 源码文件默认扩展名为 .php，源码文件中的 PHP 脚本代码以 <?php 开始，以 ?> 结束。PHP 脚本的语句使用 ; 结束。
如果使用 PHP 写前端动态页面，PHP 源码文件通常包含在 HTML 中：
<!DOCTYPE html>
<html lang="en">
<head></head>
<body>
<?php
echo "Hello 世界";
?>
<h1>PHP PAGE</h1>
<?php
$x = 2;
$y = 3;
$z = 2 + 3;
echo $z;
?>
</body>
</html>
如果 php 源文件内只有 php 脚本，可以省略结束标签 ?>：
<?php
$x = 2;
$y = 3;
$z = 2 + 3;
echo $z;
运行 PHP 脚本：
包含 PHP 脚本代码的 .php 源文件通常放在服务器上，访问此文件时由服务器把源码文件内的 <?php ... ?> 脚本代码解析后将纯 (HTML) 文本返回给客户端。php 内置了一个 web 服务器，可以在终端运行 php -S <addr>:<port> [-t docroot] [router] 启动一个简易的 web 服务器，然后在本地用浏览器访问 php 文件。
除了在服务器端运行 PHP 脚本文件外，也可以在本地安装 php 解释器，在终端运行 php file.php 命令直接解释运行 php 脚本源文件，结果输出到终端。
PHP 脚本中的注释：
<?php
echo "PHP 的注释和大多数语言一样";
// 双斜杠单行注释
/*
多行注释
多行注释
多行注释
*/
?>
2. 变量与常量
2.1 变量
PHP 变量：
- PHP 是弱类型语言，声明变量时不需要指定变量的数据类型，PHP 解释器会根据变量值自动把变量转换为对应的数据类型。
- PHP 变量均以
$符号开始，后面跟着变量的具体名称。 - 变量名以字符或下划线
_开头，变量可以包含字母、数字 和 下划线_，不能包含空格。 - 变量名区分大小写。
代码示例：
<?php
$x = 2; // 声明一个变量, 变量名为 x, 后面使用变量时也需要加上 $ 符号。
$y = 3;
$z = $x + $y;
echo $z;
$text = "Hello 世界";
echo $text;
$text = 100; // PHP 是弱类型语言, 已定义的变量, 可以用其他数据类型的值重新赋值并改变其数据类型。
echo $text;
变量定义后，可以调用 unset($var_name) 函数删除：
<?php
$a = 3; // 声明变量
echo $a;
unset($a); // 删除变量 (可同时删除多个)
// echo $a; // 变量删除后就变为了未定义, 不可再使用
2.2 变量作用域
在函数内定义的变量（包括形式参数）作用域仅在函数内，称为 局部变量。在函数外定义的变量，作用域为整个脚本文件，称为 全局变量。函数内访问全局变量，需要先使用 global 关键字声明。
代码示例：
<?php
$x = 123; // 全局变量, 作用域为整个脚本文件
$y = 456; // 全局变量, 作用域为整个脚本文件
function test_fun($a) { // 形式参数属于函数内的局部变量, 作用域仅在函数内
echo $a, "\n";
$b = 456; // 函数内的局部变量, 作用域仅在函数内
echo $b, "\n";
global $x; // 函数内使用全局变量, 必须先使用 global 关键字声明
echo $x, "\n";
$y = 789; // 如果不先使用 global 声明, 函数内使用了与外部同名的变量,
echo $y, "\n"; // 则表示的是函数内新定义局部变量 (与外部同名的全局变量无关, 也不影响外部的同名全局变量)。
}
test_fun("Hello");
echo $x, "\n";
2.3 静态变量
定义变量时，变量前面使用 static 关键字修饰，此变量则变为静态变量。静态变量只会在第一次执行到 static 语句处初始化一次，之后便一直存在并在作用域范围内可用，后续每次执行到此处都不会再重新初始化。
代码示例：
<?php
function test_fun() {
static $x = 1; // 代码第一次运行到此处时, 声明变量 x 并用等号右边的值初始化, 之后每次运行到此处时都将不处理。
echo $x;
$x++;
}
test_fun();
test_fun();
test_fun();
// 输出: 123
2.4 常量
常量定义后，值不可改变。PHP 常量的标识符前面不需要加 $ 符号，PHP 常量的作用域是整个脚本文件。PHP 定义常量有两种方式。
（1）通过调用 define() 函数定义常量，函数语法：
bool define(string $constant_name, mixed $value, bool $case_insensitive = false);
// $constant_name 常量名称, 字符串类型, 常量名前面不需要加 $
// $value 常量值
// $case_insensitive 是否不敏感大小写, true 表示不敏感大小写, 默认为 false 表示大小写敏感
// 返回值为 bool 定义成功返回 true, 失败返回 false
（2）使用 const 关键字定义常量：
// 使用 const 定义常量必须在顶层作用域位置 (不能在函数内定义, 也不能在条件语句内定义)
const CONST_NAME = "const_value";
代码示例：
<?php
// 定义区分大小写的常量 HELLO = "world"
define("HELLO", "world");
// 定义常量
const PI = 3.14159;
// 访问常量
echo HELLO, "\n", PI;
// 可以使用 constant() 函数获取指定名称的常量值。PHP_EOL 是 PHP 预定义常量, 表示换行符。
echo constant("HELLO"), PHP_EOL, constant("PI");
PHP 预定义了一些常量，可以在全局直接使用，如 PHP_VERSION、PHP_OS、PHP_EOL、PHP_BINARY 等，具体参考：https://www.php.net/manual/zh/reserved.constants.php。
2.5 魔术常量
PHP 有一些常量的值随着他们在代码中的位置改变而改变，称为 魔术常量。
PHP 魔术常量：
| # | 常量名 | 说明 |
|---|---|---|
| 1 | __LINE__ | 文件中当前行号。 |
| 2 | __FILE__ | 文件的完整路径。 |
| 3 | __DIR__ | 文件所在目录，等价于 dirname(__FILE__)。除非是根目录，否则目录不包括末尾的斜杠。 |
| 4 | __FUNCTION__ | 当前函数的名称，匿名函数则为 {closure}。 |
| 5 | __CLASS__ | 当前类的名称，包括其被声明的作用域 (如 Foo\Bar)。当用在 trait 方法中时，__CLASS__ 是调用 trait 方法的类的名称。 |
| 6 | __TRAIT__ | Trait 的名称，包括其被声明的作用域 (如 Foo\Bar)。 |
| 7 | __METHOD__ | 类的方法名。 |
| 8 | __NAMESPACE__ | 当前命名空间名称。 |
| 9 | ClassName::class | 完整的类名。 |
代码示例：
<?php
function test_fun() {
echo "test_fun: start", PHP_EOL;
echo "test_fun: current line number: ", __LINE__, PHP_EOL;
echo "test_fun: current function name: ", __FUNCTION__, PHP_EOL;
echo "test_fun: end", PHP_EOL;
}
test_fun();
echo "current line number: ", __LINE__, PHP_EOL;
echo "current file: ", __FILE__, PHP_EOL;
echo "current dir: ", __DIR__, PHP_EOL;
2.6 检查变量和常量是否存在
检查变量和常量是否存在的函数或语言结构：
defined(string $constant_name): bool：检查指定名称的常量是否被定义 (不包括魔术常量)isset($var): bool：判断指定变量是否被定义
<?php
const AA = "ABC";
var_dump(defined("AA")); // bool(true)
var_dump(defined("BB")); // bool(false)
var_dump(isset($aa)); // bool(false)
$aa = 0;
var_dump(isset($aa)); // bool(true)
3. 数据类型
PHP 支持的类型：
- 标量类型：整数(
int/integer)、浮点数(float/double)、布尔型(bool)、字符串(string) - 复合类型：数组(
array)、对象(object) - 特殊类型：资源类型(
resource)、空值(NULL)
3.1 标量类型
3.1.1 整数(int/integer)
整数(int/integer)：
<?php
$a = 100; // 十进制表示的整数
$b = 0xFF; // 十六进制表示的整数 (0x开头), 值为 255
$c = 010; // 八进制表示的整数 (0开头), 值为 8
$d = 0b0111; // 二进制表示的整数 (0b开头), 值为 7
echo $a, ", ", $b, ", ", $c, ", ", $d, PHP_EOL; // 输出: 100, 255, 8, 7
// PHP 整数变量的大小在 32 位系统上为 4 个字节, 64 位系统上为 8 个字节。
// PHP 内置常量 PHP_INT_SIZE, PHP_INT_MIN, PHP_INT_MAX 分别表示在当前系统上整数的 大小(字节)、最小值、最大值。
// PHP 整数不支持无符号类型。
// 整数进制之间的转换函数
bin2hex(string $str): string // 二进制转换为十六进制
hex2bin(string $data): string // 十六禁止转换为二进制
hexdec(string $hex_string): number // 十六进制转换为十进制
dechex(int $number): string // 十进制转换为十六进制
octdec(string $octal_string): number // 八进制转换为十进制
decoct(int $number): string // 十进制转换为八进制
bindec(string $binary_string): number // 二进制转换为十进制
decbin(int $number): string // 十进制转换为二进制
3.1.2 浮点数(float/double)
浮点数(float/double)：
<?php
$f1 = 3.14159; // 声明浮点类型的变量
$f2 = -0.56;
$f3 = 3.0E5; // 浮点类型可以使用科学计数法表示
$f4 = 1.0E-6;
echo $f1, ", ", $f2, ", ", $f3, ", ", $f4, PHP_EOL; // 3.14159, -0.56, 300000, 1.0E-6
// PHP 浮点类型相关的一些常量
echo PHP_FLOAT_DIG, PHP_EOL; // 15
echo PHP_FLOAT_EPSILON, PHP_EOL; // 2.2204460492503E-16
echo PHP_FLOAT_MIN, PHP_EOL; // 2.2250738585072E-308
echo PHP_FLOAT_MAX, PHP_EOL; // 1.7976931348623E+308
3.1.3 布尔型(bool)
布尔型(bool)：
<?php
$x = true; // 声明布尔型变量 (大小写不敏感)
$y = false;
$b1 = 3 > 2; // 比较运算的结果为布尔型
$b2 = 3 < 2;
echo "-$x,$y,$b1,$b2-"; // 输出: -1,,1,-
// 布尔型变量一般有两个值: true 和 false, 分别表示 真 或 假。
// 比较运算 和 逻辑运算 的结果为 布尔型。布尔型一般用于条件判断。
// 当运算符、函数、流程控制 需要一个布尔型的值时, 任何类型都可以自动转换为布尔型的值。
// 0, 0.0, 空字符串, 空数组, null 转换为布尔型时都是 false。
// 布尔型的值参与数学运算时 true 为 1, false 为 0;
// 布尔型的值参与字符串运算时 true 为 "1", false 为 "";
3.1.4 字符串(string)
字符串(string)：
<?php
// 字符串使用 单引号、双引号、定界符 三种字面定义方式。
/**
* 单引号字符串, 内部的字符原生输出 (不支持转义)
*/
$s1 = 'Hello\nWorld';
echo $s1;
/* 输出:
Hello\nWorld
*/
/**
* 双引号字符串, 内部支持 斜杠("\") 转义符, 并支持嵌入变量
*/
$s2 = "Hello\nWorld";
echo $s2;
/* 输出:
Hello
World
*/
// 变量可以直接嵌入到双引号内的字符串拼接, 嵌入格式: {$var_name} 或 $var_name
$name = "tom"; $age = 30;
$s3 = "name: {$name}, age: $age\n";
echo $s3;
/* 输出:
name: tom, age: 30
*/
/**
* 定界符字符串, 使用 <<< 开头, 后面紧跟着一个 自定义的标识符 用于标记字符串结尾 (比如"EOT"),
* 在定界符内的字符串可以包含除了 自定义结尾标识符(EOT) 外的任意字符。定界符字符串内不能使用转义。
* 定界符的 开头(<<<EOT) 和 结尾(EOT) 必须单独占一行, 字符串实际内容在两者的中间 (不包括开头行尾部 和 结尾行头部 的换行符)。
*/
$s4 = <<<EOT
Hello
你好
World
EOT;
echo "-", $s4, "-";
/* 输出:
-Hello
你好
World-
*/
PHP 预置了许多操作字符串的函数，详见：https://www.php.net/manual/zh/ref.strings.php
常用的字符串函数：
strlen(string $string): int // 获取字符串长度 (返回字节数, 不是字符串)
ltrim(string $str, string $character_mask = ?): string // 删除左边的空白字符 (或其他字符)
rtrim(string $str, string $character_mask = ?): string // 删除右边的空白字符 (或其他字符)
trim(string $str, string $character_mask = " \t\n\r\0\x0B"): string // 删除首尾空白字符 (或其他字符)
strpos(string $haystack, mixed $needle, int $offset = 0): int // 查找字符首次出现的位置
stripos(string $haystack, string $needle, int $offset = 0): int // 查找字符首次出现的位置 (不区分大小写)
strrpos(string $haystack, string $needle, int $offset = 0): int // 查找字符最后一次次出现的位置
strripos(string $haystack, string $needle, int $offset = 0): int // 查找字符最后一次次出现的位置 (不区分大小写)
substr(string $string, int $offset, ?int $length = null): string // 截取子字符串 (字节级别截取)
substr_replace(mixed $string, mixed $replacement, mixed $start, mixed $length = ?): mixed // 替换指定位置的子字符串
str_replace(mixed $search, mixed $replace, mixed $subject, int &$count = ?): mixed // 字符串搜索替换
substr_count(string $haystack, string $needle, int $offset = 0, ?int $length = null): int // 计算子字符串出现的次数
str_split(string $string, int $split_length = 1): array // 字符串转换为数组
strtok(string $string, string $token): string|false // 使用 token 分隔字符串
explode(string $separator, string $string, int $limit = PHP_INT_MAX): array // 使用 separator 分隔字符 string (返回分隔后的数组)
strtoupper(string $string): string // 转换为大写
strtolower(string $string): string // 转换为小写
chr(int $ascii): string // ASCII码点 转换为 字符(串)
ord(string $string): int // 转换字符串第一个字节为 0-255 之间的值
3.2 复合类型
3.2.1 数组(array)
数组(array) 是 PHP 中重要的复合数据类型，可以存储任意多个、任意类型的数据，数组容量自动根据存储的数据大小自动调整。普通数组、列表、散列表、字典、集合、栈、队列 等很多复杂的数据结构都可以通过 数组(array) 和 内置的数组函数 实现。数组的所有元素值都映射到一个键上，数组的键一般为 整数(int/integer) 或 字符串(string)，值可以是任意类型。数组的创建也有多种方式。
创建数组：
<?php
/**
* 1. 直接赋值创建数组
*/
$arr1[0] = 100; // 创建数组变量 arr1, 并创建 值为 0 的键, 键对应的元素值为 100
$arr1[1] = 3.14; // 创建 值为1的键, 键对应的元素值为 3.14
$arr1[2] = "hello";
$arr1[] = "wrold"; // 不指定 key, 直接赋值, 则 key 为已存在的整数 key 最大值递增 1。如果数组变量 arr1 不存在则会先创建。
echo "arr length: ", count($arr1), PHP_EOL; // 使用 count() 函数计算数组的大小, 输出: arr length: 4
echo $arr1[0], ", ", $arr1[1], ", ", $arr1[2], PHP_EOL; // 通过数组的键名访问数组元素, 输出: 100, 3.14, hello
var_dump($arr1);
/* 输出:
array(4) {
[0]=>
int(100)
[1]=>
float(3.14)
[2]=>
string(5) "hello"
[3]=>
string(5) "wrold"
}
*/
$arr2[0] = 100; // 数组的索引(键名)可以是任意类型, 如果是整数, 索引值也不需要连续
$arr2[5] = 101;
$arr2["hello"] = 102; // 可以使用非数字作为下标 (称为 关联数组)
echo "arr length: ", count($arr2), PHP_EOL; // 输出: arr length: 3
var_dump($arr2);
/* 输出:
array(3) {
[0]=>
int(100)
[5]=>
int(101)
["hello"]=>
int(102)
}
*/
/**
* 2. 使用 array() 语言结构创建数组
*/
$arr3 = array(0 => 123, "hello" => "world"); // 通过 key => value 的形式传入多个参数生成数组
echo $arr3[0], ", ", $arr3["hello"], PHP_EOL; // 输出: 123, world
var_dump($arr3);
/* 输出:
array(2) {
[0]=>
int(123)
["hello"]=>
string(5) "world"
}
*/
$arr4 = array(456, 3.14, "你好"); // 如果不指定 key, 则 key 默认为从 0 开始递增的整数
echo $arr4[0], ", ", $arr4[1], ", ", $arr4[2], PHP_EOL; // 输出: 456, 3.14, 你好
var_dump($arr4);
/* 输出:
array(3) {
[0]=>
int(456)
[1]=>
float(3.14)
[2]=>
string(6) "你好"
}
*/
$arr5 = array(10, "aa" => "AA", 20); // 可以部分指定 key, 没指定 key 的则使用从 0 开始递增的整数分配 key
var_dump($arr5);
/* 输出:
array(3) {
[0]=>
int(10)
["aa"]=>
string(2) "AA"
[1]=>
int(20)
}
*/
$arr6 = array(10, "aa" => "AA", 0 => 20); // 分配 key 是从左到右的, 这里首个元素分配的 key 为 0,
var_dump($arr6); // 最后一个元素又指定 key 为 0, 则默认会覆盖前面的相同 key 的元素。
/* 输出:
array(2) {
[0]=>
int(20)
["aa"]=>
string(2) "AA"
}
*/
/**
* 3. 数组的精简写法, PHP5.4 开始可以使用 [] 直接创建数组
*/
$arr7 = [10, 2.5, false, "abc"];
var_dump($arr7);
/* 输出:
array(4) {
[0]=>
int(10)
[1]=>
float(2.5)
[2]=>
bool(false)
[3]=>
string(3) "abc"
}
*/
$arr8 = [88, "abc" => "ABC"];
var_dump($arr8);
/* 输出:
array(2) {
[0]=>
int(88)
["abc"]=>
string(3) "ABC"
}
*/
/**
* 4. 多维数组, PHP 数组的 索引(键) 和 元素值 都可以是任意类型, 只要把数组作为元素值就实现了多维数组
*/
$arr9 = [
[1, 2, 3],
[4, 5, 6]
];
var_dump($arr9[0]); // $arr9[0] 的值为数组 [1, 2, 3]
/* 输出
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
*/
var_dump($arr9);
/* 输出
array(2) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
}
*/
遍历数组：
<?php
// 创建索引从 0 开始整数递增的数组
$arr1 = [10, 3.14, true, "Hello 世界", null];
// 如果数组的索引(键名)是从 0 开始的连续整数, 可以使用 for 循环通过下标遍历
for ($i = 0; $i < count($arr1); $i++) {
echo $i, " => ", $arr1[$i], PHP_EOL;
}
/* 输出:
0 => 10
1 => 3.14
2 => 1
3 => Hello 世界
4 =>
*/
// 使用 foreach 循环变量数组 (as 右边只有一个参数接收遍历值, 则此参数值为数组元素值)
foreach ($arr1 as $value) {
echo $value, PHP_EOL;
}
/* 输出:
10
3.14
1
Hello 世界
*/
// 使用 foreach 循环变量数组 (as 右边使用 $key => $value 接收遍历值)
foreach ($arr1 as $key => $value) {
echo $key, " => ", $value, PHP_EOL;
}
/* 输出:
0 => 10
1 => 3.14
2 => 1
3 => Hello 世界
4 =>
*/
// foreach 可以遍历任意 key 类型的数组
$arr2 = ["hello" => "world", 1024, "aa" => "AA"];
foreach ($arr2 as $key => $value) {
echo $key, " => ", $value, PHP_EOL;
}
/* 输出:
hello => world
0 => 1024
aa => AA
*/
PHP 内置了许多操作数据的函数，参考：https://www.php.net/manual/zh/ref.array.php。
常用数组函数：
count(Countable|array $value, int $mode = COUNT_NORMAL): int // 返回数组元素数量
array_is_list(array $array): bool // 判断数组是否为 list, 如果数组的 key 是从 0 开始的连续整数, 则该数组为 list。
in_array(mixed $needle, array $haystack, bool $strict = false): bool // 判断数组中是否包含某个元素值
array_key_exists(string|int $key, array $array): bool // 判断数组中是否存储某个键名
array_key_first(array $array): int|string|null // 返回数组的首个键, 不存在返回 null。
array_key_last(array $array): int|string|null // 返回数组的最后一个键, 不存在返回 null。
array_keys(array $array): array // 返回数组的所有键, 以列表(key为0开始的连续整数的数组)的方式返回, 空数组则返回空列表。
array_values(array $array): array // 返回数组的所有值, 以列表的形式返回。
array_push(array &$array, mixed $value1, mixed $... = ?): int // 入栈, 添加元素到数组末尾
array_pop(array &$array): mixed // 出栈, 移出数组末尾的元素
array_splice(array &$array, int $offset, ?int $length = null, mixed $replacement = []): array // (插入元素) 去掉数组中的某一部分并用其它值取代
unset($array[key]) // 删除数组中的某个元素
array_rand(array $array, int $num = 1): int|string|array // 从数组中随机取出一个或多个随机键 (不删除元素)
array_slice(array $array, int $offset, ?int $length = null, bool $preserve_keys = false): array // 从数组中取出一段 (数组切片/子数组)
array_flip(array $array): array // 交互数组中的键和值, 交互后的键必须是 int 或 string 类型, 交互后相同的 key 会被后者覆盖。
array_reverse(array $array, bool $preserve_keys = false): array // 返回顺序相反的数组
array_unique(array $array, int $flags = SORT_STRING): array // 移除数组中重复的值
array_replace(array $array, array ...$replacements): array // 根据键名替换数组中的值
range(string|int|float $start, string|int|float $end, int|float $step = 1): array // 根据范围创建数组
list(mixed $var, mixed ...$vars = ?): array // 把数组元素逐个赋值给括号内的一组变量。这不是真正函数, 而是语言结构。
array_map(?callable $callback, array $array, array ...$arrays): array // 为数组的每个元素值应用回调函数后形成新数组返回 (key 不变)。
array_merge(array ...$arrays): array // 合并多个数组, 返回合并后的新数组
sort(array &$array, int $flags = SORT_REGULAR): bool // 对数组元素值升序排序 (原有的键将被删除, 重新使用从 0 开始递增的整数作为键)
rsort(array &$array, int $flags = SORT_REGULAR): bool // 对数组元素值降序排序 (原有的键将被删除, 重新使用从 0 开始递增的整数作为键)
arsort(array &$array, int $flags = SORT_REGULAR): bool // 对数组元素值进行升序排序并保持索引关系 (键顺序不变)
asort(array &$array, int $flags = SORT_REGULAR): bool // 对数组元素值进行降向排序并保持索引关系 (键顺序不变)
ksort(array &$array, int $flags = SORT_REGULAR): bool // 根据数组键名升序排序
krsort(array &$array, int $flags = SORT_REGULAR): bool // 根据数组键名降序排序
shuffle(array &$array): bool // 随机打乱数组顺序
3.2.2 对象(object)
PHP5 开始支持面向对象编程，类的实例变量为对象类型：
<?php
class Person {
var string $name;
var int $age;
function __construct(string $name, int $age) {
$this->name = $name;
$this->age = $age;
}
function say() {
echo "Person: name=$this->name, age=$this->age\n";
}
}
$p = new Person("Tom", 20); // 创建对象
$p->say(); // 输出: Person: name=Tom, age=20
var_dump($p);
/* 输出:
object(Person)#1 (2) {
["name"]=>
string(3) "Tom"
["age"]=>
int(20)
}
*/
3.3 特殊类型
3.3.1 资源类型(resource)
资源类型(resource) 是特殊类型变量，保存了对外部资源的一个引用，比如：打开的文件、数据库连接、图形画布区域等。资源类型变量创建后，不再需要使用时都应该被及时释放。
<?php
$filepath = "index.php";
$file = fopen($filepath, "r"); // $file 是资源类型的变量 (打开的文件)
var_dump($file); // 输出: resource(5) of type (stream)
$text = fread($file, filesize($filepath));
echo $text;
fclose($file);
3.3.2 空值(NULL)
null 或 NULL (不区分大小写) 表示空值（没有值），空值可以赋值给任意任何变量。null 值的类型也是 null。
<?php
$a = null;
var_dump($a); // 输出: NULL
echo gettype(null); // 输出: NULL
3.4 类型转换
每一个数据变量都有对应的类型，具有相同类型的数据才能做相关操作。在 PHP 中，不同类型的变量进行混合运算时，通常会先自动转换为相同的类型。也可以调用具体的转换函数强制转换类型。
变量类型相关函数：
var_dump(mixed $value, mixed ...$values): void：输出指定值的类型和值。gettype(mixed $value): string：获取指定值的数据类型，如: “integer”, “double”, “boolean”, “string”, “NULL”, “array”, “resource”, “unknown type” 等。
3.4.1 自动类型转换
通常只有 4 种标量类型 (int, float, string, bool) 才能自动转换类型。
自动类型转换规则：
bool参与数学运算时，true将转换为整数 1，false将转换为整数 0。null值参与数学运算时，将转换为整数 0。int和float一起运算时，int将被转换为float后再参与运算。string和 数值型(int或float) 一起运行时,string将被转换为数值型后再做数学运算（字符串没有小数点则转换为int，有小数点则转换为float）。- 其他类型作为用于判断的
bool是，数值0、空字符串、null、空数组 将转为false。
<?php
$a = 10 + true;
var_dump($a); // 输出: int(11)
$b = 10 + (1 != 1);
var_dump($b); // 输出: int(10)
$c = 10 + null;
var_dump($c); // 输出: int(10)
$d = 10 + 3.14;
var_dump($d); // 输出: float(13.14)
$e = "125" + 5;
var_dump($e); // 输出: int(130)
$f = "12.5" + 5;
var_dump($f); // 输出: float(17.5)
3.4.2 强制类型转换
PHP 强制类型转换和大多数语言一样，在变量前面加括号，括号内为转换的目标类型。也可以调用具体的转换函数或使用 settype() 函数转换数据类型。
数据类型转换函数，参考：https://www.php.net/manual/zh/ref.var.php。
intval(mixed $value, int $base = 10): int // 获取变量的整数值, 如果 $value 是 float, 则直接截断小数点后面部分(非四舍五入)
floatval(mixed $value): float // 获取变量的浮点值
doubleval(mixed $value): float // 获取变量的浮点值
boolval(mixed $value): bool // 获取变量的布尔值
strval(mixed $value): string // 获取变量的字符串值
settype(mixed &$var, string $type): bool // 指定变量设置为新的类型, $type 的值为 "boolean", "int"/"integer", "float", "string", "array", "object", "null"。
代码示例：
<?php
$a = (int) 8.99;
var_dump($a); // 输出: int(8)
$a = "8.99";
settype($a, "int");
var_dump($a); // 输出: int(8)
3.5 类型判断
数据类型判断函数，参考：https://www.php.net/manual/zh/ref.var.php。
常用类型判断函数：
is_null(mixed $var): bool // 检测变量是否为 null
is_int(mixed $value): bool // 检测变量是否是整数
is_integer(mixed $value): bool // is_int() 的别名
is_long(mixed $value) // is_int() 的别名
is_float(mixed $var): bool // 检测变量是否是浮点型
is_double(mixed $var): bool // is_float() 的别名
is_real(mixed $var): bool // is_float() 的别名
is_bool(mixed $value): bool // 检测变量是否是布尔值
is_string(mixed $var): bool // 检测变量是否是字符串
is_numeric(mixed $value): bool // 检测变量是否为数字或数字字符串
is_array(mixed $var): bool // 检测变量是否是数组
is_object(mixed $var): bool // 检测变量是否是一个对象
is_callable(callable $name, bool $syntax_only = false, string &$callable_name = ?): bool // 检测参数是否为合法的可调用结构
is_countable(mixed $value): bool // 验证变量的内容是可数的值
is_iterable(mixed $value): bool // 验证变量的内容是否为可迭代值
is_resource(mixed $var): bool // 检测变量是否为资源类型
is_scalar(mixed $value): bool // 检测变量是否是一个标量
3.6 伪类型
伪类型不是 PHP 语言的基本类型，因为 PHP 是弱类型语言，一些函数中一个参数可以接受多种类型的数据。为了确保代码的可读性，函数参数前面可以加上伪类型说明参数可接受的数据类型。
常用的为类型：
mixed：表示任意类型。callable：表示回调函数类型。
4. 输入与输出
4.1 基本输出: echo 和 print
PHP 有两个基本输出方式：echo 和 print。echo 可以输出一个或多个值（多个值之间使用 , 分隔），没有返回值。print 只能输出一个值，有返回值且始终返回 1。
echo 和 print 是语言结构，不是真正的函数，使用时不需要像调用函数一样加括号（如果加括号，实际上括号作用在了输出值参数中，属于输出值表达式，不属于 echo/print）。
代码示例：
<?php
$z = 100;
echo $z; // 输出值的字符串形式 (结尾不会自动加换行)
echo 123, 3.14, "Hello 世界"; // 输出多个值 (多个值之间直接连接输出, 中间没有空格)
print 123456; // 调用 print 输出值 (结尾不会自动加换行)
$text = "Hello World";
echo print $text; // 调用 print 输出将返回 1
// 输出结果: 1001233.14Hello 世界123456Hello World1
4.2 格式化输出
输入输出函数在字符串函数中，参考：https://www.php.net/manual/zh/ref.strings.php
格式输出相关函数：
// 输出格式化字符串, 返回输出字符串的长度
printf(string $format, mixed $args = ?, mixed $... = ?): int
// 返回格式化字符串
sprintf(string $format, mixed ...$values): string
// 将格式化后的字符串写入到流, 返回写入的字符串长度
fprintf(resource $handle, string $format, mixed $... = ?): int
// 与 printf() 类似, 参数改为数组的方式传递
vprintf(string $format, array $args): int
// 与 sprintf() 类似, 参数改为数组的方式传递
vsprintf(string $format, array $values): string
// 与 vprintf() 类似, 参数改为数组的方式传递
vfprintf(resource $handle, string $format, array $args): int
代码示例：
<?php
printf("name=%s, age=%d\n", "Hello", 100); // 输出: name=Hello, age=100
vprintf("name=%s, age=%d\n", ["Hello", 100]); // 输出: name=Hello, age=100
4.3 输入函数
行读取相关函数，参考：https://www.php.net/manual/zh/ref.readline.php。
从控制台读入一行文本：
// 等待从控制台(标准输入)读取一行文本 (输入文本后按回车键读取, 读取的行不包括回车符)
readline(string $prompt = ?): string
格式化输入相关函数，参考：fscanf()、sscanf()
// 从指定输入流格式化扫描输入。
// 如果只传两个参数, 返回扫描到的值组成的数组。
// 如果传递了可选参数, 则把扫描到的值保存到可选参数, 并返回已设置值的参数个数。
fscanf(resource $handle, string $format, mixed &$... = ?): mixed
// 与 fscanf() 类似, 扫描源改为从指定字符串中扫描
sscanf(string $str, string $format, mixed &$... = ?): mixed
代码示例：
<?php
$a = sscanf("hello 100", "%s %d");
var_dump($a);
/*
输出:
array(2) {
[0]=>
string(5) "hello"
[1]=>
int(100)
}
*/
$c = sscanf("hello 100", "%s %d", $v1, $v2);
var_dump($c, $v1, $v2);
/*
输出:
int(2)
string(5) "hello"
int(100)
*/
// 从 标准输入 中扫描读取数据
$a = fscanf(STDIN, "%s %d");
var_dump($a);
// 从 标准输入 中读取一行数据
$line = readline();
var_dump($line);
4.4 STDIN、STDOUT、STDERR
PHP 预定义的常量中，有三个连接标准 I/O 流的常量：STDIN(标准输入)、STDOUT(标准输出)、STDERR(标准错误)。
代码示例：
<?php
// 从 标准输入(控制台) 读取 5 个字节的数据
$a = fread(STDIN, 5);
var_dump($a);
// 写入数据到 标准输出
fwrite(STDOUT, "Hello World\n");
// 写入数据到 标准错误
fwrite(STDERR, "an error occurred\n");
// 格式化输出到 标准错误
fprintf(STDERR, "Error: %s\n", "an error occurred");
4.5 输出变量信息
输出变量信息相关函数：
// 以人类易读的格式显示一个变量的信息, 如果 $return=true 则直接返回要输出的信息 (不再输出)。
print_r(mixed $expression, bool $return = false): mixed
// 输出或返回变量的可解析字符串字面表示, 如果 $return=true 则直接返回要输出的信息 (不再输出)。
// 它和 var_dump() 函数类似, 不同的是其返回的字符串表示是合法的 PHP 代码。
var_export(mixed $value, bool $return = false): ?string
// 打印变量的相关信息 (末尾会加上换行符)
var_dump(mixed $value, mixed ...$values): void
// 变量信息输出的详细程度: var_dump() > var_export() > print_r()
参考：https://www.php.net/manual/zh/ref.var.php
代码示例：
<?php
$a = 123;
$b = ["hello", "world" => 456];
print_r($a); echo "\n";
/* 输出:
123
*/
print_r($b); echo "\n";
/* 输出:
Array
(
[0] => hello
[world] => 456
)
*/
var_export($a); echo "\n";
/* 输出:
123
*/
var_export($b); echo "\n";
/* 输出:
array (
0 => 'hello',
'world' => 456,
)
*/
var_dump($a);
/* 输出:
int(123)
*/
var_dump($b);
/* 输出:
array(2) {
[0]=>
string(5) "hello"
["world"]=>
int(456)
}
*/
5. 数学运算
数学函数，参考：https://www.php.net/manual/zh/ref.math.php
5.1 算术运算
运算符 描述 示例
--------------------------------------------------------------------------
+ 加法 2 + 3 == 5;
- 减法 5 - 2 == 3
* 乘法 2 * 3 == 6; 2 * 3.2 == 6.4
/ 除法 3 / 2 == 1.5; 非整除, 整除使用函数 intdiv(3, 2) == 1
% 取模 5 % 3 == 2; 5 % -3 == 2; -5 % 3 == -2; -5 % -3 == -2
--------------------------------------------------------------------------
5.2 赋值运算
运算符 描述 示例
--------------------------------------------------------------------------
= 简单赋值 $c = $a + $b, 将 $a + $b 的结果赋值给 $c
+= 加法赋值 $c += $a 等价于 $c = $c + $a
-= 减法赋值 $c -= $a 等价于 $c = $c - $a
*= 乘法赋值 $c *= $a 等价于 $c = $c * $a
/= 除法赋值 $c /= $a 等价于 $c = $c / $a
%= 取模赋值 $c %= $a 等价于 $c = $c % $a
<<= 左移赋值 $c <<= $a 等价于 $c = $c << $a
>>= 右移赋值 $c >>= $a 等价于 $c = $c >> $a
&= 位与赋值 $c &= $a 等价于 $c = $c & $a
^= 异或赋值 $c ^= $a 等价于 $c = $c ^ $a
|= 位或赋值 $c |= $a 等价于 $c = $c | $a
.= 并置赋值 $c .= $a 等价于 $c = $c . $a
++ 自增赋值 $a++ 表示先返回 $a, 再自增; ++$a 表示先自增, 再返回 $a;
-- 自减赋值 $a-- 表示先返回 $a, 再自减; --$a 表示先自减, 再返回 $a;
--------------------------------------------------------------------------
5.3 比较运算
运算符 描述 示例
-----------------------------------------------------------------------------
== 相等 10 == "10" 结果为 true, 只要两个比较数的字符串形式相等即相等
!= 不相等 == 的否定
<> 不相等 与 != 相同
=== 绝对相等 类型和值均相等才相等, 10 === "10" 结果为 false
!== 不绝对相等 === 的否定
> 大于 3 > 2 结果为 true; "xyz" > "abc" 结果为 true
< 小于 3 < 2 结果为 false
>= 大于等于 3 >= 3 结果为 true
<= 小于等于 8 <= 5 结果为 false
-----------------------------------------------------------------
5.4 逻辑运算
运算符 描述 示例
-----------------------------------------------------------------
&& 逻辑与 a && b, a 和 b 为布尔表达式
|| 逻辑或 a || b
! 逻辑非 !a
and 逻辑与 a and b, a 和 b 为布尔表达式
or 逻辑或 a or b
xor 逻辑异或 a xor b
-----------------------------------------------------------------
&& 和 and，|| 和 or 逻辑判断的效果均相同，但有优先级区别，and、or、xor 与 等号= 的优先级比较：
&&>=>and||>=>or=>xor
<?php
$c = false xor true; // = 优先级高于 xor, 相当于 ($c = false) xor true; 因此 $c 的值为 false
$d = false || true;
var_dump($c); // 输出: bool(false)
var_dump($d); // 输出: bool(true)
5.5 位运算
运算符 描述 示例
---------------------------------------------------------------------------
& 位与 a & b, 整数a 和 整数b 按位与运算
| 位或 a | b, 整数a 和 整数b 按位或运算
^ 异或 a ^ b, 整数a 和 整数b 按位异或运算
~ 取反 ~a, 对 整数a 按位取反
<< 左移 a << 1, 整数a 左移 1 位, 00000111 << 1 结果为 00001110
>> 右移 a >> 1, 整数a 右移 1 位, 00000111 >> 1 结果为 00000011
---------------------------------------------------------------------------
<<左移运算，低位补 0。>>右移运算，正数高位补 0，负数高位补 1。
5.6 其他运算符
并置运算符: .
<?php
// 并置运算符 . 将两边操作数的字符串形式拼接起来返回新的字符串
$a = "hello";
$b = 123;
$c = $a . $b;
var_dump($c); // 输出: string(8) "hello123"
$d = 123 . 456;
var_dump($d); // 输出: string(6) "123456"
$e = "world" . true . 3.14 . false;
var_dump($e); // 输出: string(10) "world13.14"
三元运算符 (条件表达式): ?:
// 条件表达式语法
$var = bool_expression ? true_value : false_value;
组合比较符: <=>
语法格式:
$c = $a <=> $b;
<=> 返回整数 -1、0 或 1:
$a < $b, $c = -1
$a == $b, $c = 0
$a > $b, $c = 1
括号运算符: ()
// 括号用于改变表达式内操作符的优先级
569
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
