00-PHP基础知识-1PHP基础知识完全补充手册目录 PHP基础语法变量与数据类型运算符与符号命名规范 PSR

PHP基础知识完全补充手册

文档类型: PHP基础知识全面补充
更新时间: 2025-10-28
适用人群: PHP开发者、面试准备

1. PHP基础语法

1.1 PHP标记

// 标准PHP标记（推荐）
<?php
echo "Hello World";
?>

// 短标记（不推荐，需要配置）
<?
echo "Hello World";
?>

// echo标记（不推荐）
<?= "Hello World" ?>

// 纯PHP文件建议省略结束标记
<?php
// 代码...
// 不要写 ?>

最佳实践：

✅ 使用 <?php 开始标记
✅ 纯PHP文件省略结束标记 ?>（避免意外输出）
❌ 不使用短标记 <?

1.2 注释

<?php
// 单行注释

# Shell风格单行注释（不推荐）

/*
 * 多行注释
 * 用于函数、类的说明
 */

/**
 * 文档注释（PHPDoc）
 * @param string $name 用户名
 * @return bool
 */
function login($name) {
    return true;
}

1.3 语句分隔符

<?php
// 每条语句用分号结束
$name = "John";
$age = 30;

// 多条语句可以写在一行
$x = 1; $y = 2; $z = 3;

// 代码块不需要分号
if ($age > 18) {
    echo "成年人";
}

2. 变量与数据类型

2.1 变量基础

<?php
// 变量声明（弱类型，不需要声明）
$name = "John";        // 字符串
$age = 30;             // 整数
$price = 99.99;        // 浮点数
$isActive = true;      // 布尔值
$items = [1, 2, 3];    // 数组
$user = null;          // NULL

// 变量命名规则
$userName = "valid";          // ✅ 驼峰命名
$user_name = "valid";         // ✅ 下划线命名
$_privateName = "valid";      // ✅ 下划线开头
$name123 = "valid";           // ✅ 数字
// $123name = "invalid";      // ❌ 数字开头
// $user-name = "invalid";    // ❌ 连字符

// 变量变量
$varName = "username";
$$varName = "John";    // $username = "John"
echo $username;        // 输出: John

// 引用赋值
$a = 10;
$b = &$a;    // $b引用$a
$b = 20;     // $a也变成20
echo $a;     // 输出: 20

2.2 数据类型

标量类型

<?php
// 1. 布尔型 (boolean/bool)
$isTrue = true;
$isFalse = false;

// 转换为false的值
var_dump((bool)0);         // false
var_dump((bool)0.0);       // false
var_dump((bool)"");        // false
var_dump((bool)"0");       // false
var_dump((bool)null);      // false
var_dump((bool)[]);        // false

// 2. 整型 (integer/int)
$decimal = 123;            // 十进制
$octal = 0123;             // 八进制（前导0）
$hex = 0x1A;               // 十六进制（0x前缀）
$binary = 0b1111;          // 二进制（0b前缀）

// 整数范围
echo PHP_INT_MAX;          // 最大整数
echo PHP_INT_MIN;          // 最小整数
echo PHP_INT_SIZE;         // 字节数（4或8）

// 3. 浮点型 (float/double)
$float1 = 1.234;
$float2 = 1.2e3;           // 科学计数法: 1200
$float3 = 7E-10;           // 0.0000000007

// 浮点数比较（不能直接用==）
$a = 0.1 + 0.2;
$b = 0.3;
var_dump($a == $b);        // false（精度问题）
var_dump(abs($a - $b) < 0.00001);  // ✅ 正确的比较方式

// 4. 字符串 (string)
$str1 = 'single quote';    // 单引号：不解析变量
$str2 = "double quote";    // 双引号：解析变量
$str3 = <<<EOT
heredoc语法
可以多行
可以解析变量: $str1
EOT;

$str4 = <<<'EOT'
nowdoc语法
可以多行
不解析变量: $str1
EOT;

// 字符串操作
$name = "John";
echo "Hello, $name";              // Hello, John
echo 'Hello, $name';              // Hello, $name
echo "Hello, {$name}";            // Hello, John（推荐）
echo "Array: {$arr[0]}";          // 数组访问

// 字符串连接
$full = $first . " " . $last;     // 点号连接
$full = "$first $last";           // 双引号内插值

复合类型

<?php
// 1. 数组 (array)
// 索引数组
$fruits = ["apple", "banana", "orange"];
$fruits = array("apple", "banana", "orange");  // 旧语法

// 关联数组
$person = [
    "name" => "John",
    "age" => 30,
    "email" => "john@example.com"
];

// 多维数组
$users = [
    ["id" => 1, "name" => "John"],
    ["id" => 2, "name" => "Jane"],
];

// 数组操作
echo $fruits[0];                  // apple
echo $person["name"];             // John
$fruits[] = "grape";              // 追加元素
count($fruits);                   // 数组长度
array_push($fruits, "melon");     // 追加元素
array_pop($fruits);               // 删除最后元素

// 2. 对象 (object)
class Person {
    public $name = "John";
}
$obj = new Person();
echo $obj->name;

// stdClass（标准类）
$obj = new stdClass();
$obj->name = "John";
$obj->age = 30;

// 数组转对象
$arr = ["name" => "John", "age" => 30];
$obj = (object)$arr;
echo $obj->name;                  // John

// 3. 可调用类型 (callable)
// 函数名
$callback = 'strlen';
echo $callback("hello");          // 5

// 匿名函数
$callback = function($x) {
    return $x * 2;
};
echo $callback(10);               // 20

// 对象方法
$callback = [$obj, 'method'];
$callback();

// 静态方法
$callback = ['Class', 'staticMethod'];
$callback = 'Class::staticMethod';

特殊类型

<?php
// 1. NULL
$var = null;
var_dump(is_null($var));          // true
var_dump(isset($var));            // false

// 产生NULL的情况
$a = null;                        // 直接赋值
unset($b);                        // 销毁变量
$c;                               // 未定义

// 2. Resource（资源类型）
$file = fopen("test.txt", "r");   // 文件资源
$db = mysqli_connect(...);        // 数据库连接资源
$curl = curl_init();              // CURL资源

// 检查资源
var_dump(is_resource($file));     // true

2.3 类型转换

<?php
// 自动类型转换
$result = "10" + 5;               // 15（字符串转整数）
$result = "10.5" + 5;             // 15.5（字符串转浮点）
$result = "10 apples" + 5;        // 15（提取数字）

// 强制类型转换
$str = "123";
$int = (int)$str;                 // 整型
$float = (float)$str;             // 浮点型
$bool = (bool)$str;               // 布尔型
$array = (array)$str;             // 数组
$object = (object)$str;           // 对象

// 类型转换函数
$int = intval("123");
$float = floatval("123.45");
$str = strval(123);

// 类型检测
var_dump(is_int($var));           // 整数
var_dump(is_float($var));         // 浮点数
var_dump(is_string($var));        // 字符串
var_dump(is_bool($var));          // 布尔
var_dump(is_array($var));         // 数组
var_dump(is_object($var));        // 对象
var_dump(is_null($var));          // NULL
var_dump(is_numeric($var));       // 数字或数字字符串
var_dump(is_callable($var));      // 可调用

// 获取类型
echo gettype($var);               // 返回类型名称

2.4 类型声明（PHP 7+）

<?php
// 标量类型声明
function add(int $a, int $b): int {
    return $a + $b;
}

// 可空类型（PHP 7.1+）
function getName(?string $name): ?string {
    return $name;
}

// 联合类型（PHP 8.0+）
function process(int|float $number): int|float {
    return $number * 2;
}

// 混合类型（PHP 8.0+）
function handle(mixed $data): mixed {
    return $data;
}

// 返回类型声明
function getUser(): array {
    return ["id" => 1, "name" => "John"];
}

// void返回类型
function log(string $message): void {
    echo $message;
    // 不能有return值
}

// never返回类型（PHP 8.1+）
function terminate(): never {
    exit();  // 永不返回
}

2.5 常量

<?php
// 定义常量（不能修改）
define('SITE_NAME', 'My Website');
const DB_HOST = 'localhost';      // 类内部或全局（PHP 5.3+）

// 使用常量
echo SITE_NAME;
echo DB_HOST;

// 魔术常量
echo __LINE__;                    // 当前行号
echo __FILE__;                    // 当前文件路径
echo __DIR__;                     // 当前目录
echo __FUNCTION__;                // 当前函数名
echo __CLASS__;                   // 当前类名
echo __METHOD__;                  // 当前方法名
echo __NAMESPACE__;               // 当前命名空间

// 预定义常量
echo PHP_VERSION;                 // PHP版本
echo PHP_OS;                      // 操作系统
echo PHP_EOL;                     // 换行符
echo PHP_INT_MAX;                 // 最大整数
echo PHP_FLOAT_MAX;               // 最大浮点数

3. 运算符与符号

3.1 算术运算符

<?php
$a = 10;
$b = 3;

echo $a + $b;    // 13  加法
echo $a - $b;    // 7   减法
echo $a * $b;    // 30  乘法
echo $a / $b;    // 3.333... 除法
echo $a % $b;    // 1   取模（余数）
echo $a ** $b;   // 1000 幂运算（PHP 5.6+）

// 递增递减
$i = 1;
echo $i++;       // 1（后递增）
echo ++$i;       // 3（前递增）
echo $i--;       // 3（后递减）
echo --$i;       // 1（前递减）

// 取反
echo -$a;        // -10

3.2 赋值运算符

<?php
$a = 10;         // 基本赋值

// 复合赋值
$a += 5;         // $a = $a + 5;   (15)
$a -= 5;         // $a = $a - 5;   (10)
$a *= 2;         // $a = $a * 2;   (20)
$a /= 4;         // $a = $a / 4;   (5)
$a %= 3;         // $a = $a % 3;   (2)
$a .= "text";    // $a = $a . "text" (字符串连接)
$a ??= 10;       // $a = $a ?? 10 (空合并，PHP 7.4+)

// 引用赋值
$b = &$a;        // $b引用$a
$b = 20;         // $a也变成20

3.3 比较运算符

<?php
$a = 10;
$b = "10";

// 相等比较
var_dump($a == $b);     // true（值相等）
var_dump($a === $b);    // false（值和类型都相等）
var_dump($a != $b);     // false（值不等）
var_dump($a !== $b);    // true（值或类型不等）
var_dump($a <> $b);     // false（不等于，同!=）

// 大小比较
var_dump($a > 5);       // true
var_dump($a < 20);      // true
var_dump($a >= 10);     // true
var_dump($a <= 10);     // true

// 太空船运算符（PHP 7+）
echo 1 <=> 2;           // -1（小于）
echo 2 <=> 2;           // 0（等于）
echo 3 <=> 2;           // 1（大于）

// 三元运算符
$result = ($a > 5) ? "大于5" : "小于等于5";

// 空合并运算符（PHP 7+）
$username = $_GET['user'] ?? 'guest';           // 不存在或NULL时使用默认值
$username = $_GET['user'] ?? $_POST['user'] ?? 'guest';  // 链式

// 空合并赋值（PHP 7.4+）
$array['key'] ??= 'default';                    // 等同于 $array['key'] = $array['key'] ?? 'default'

3.4 逻辑运算符

<?php
$a = true;
$b = false;

// 逻辑与
var_dump($a && $b);     // false（短路求值）
var_dump($a and $b);    // false（优先级低）

// 逻辑或
var_dump($a || $b);     // true（短路求值）
var_dump($a or $b);     // true（优先级低）

// 逻辑非
var_dump(!$a);          // false
var_dump(!$b);          // true

// 逻辑异或
var_dump($a xor $b);    // true（一真一假为true）

// 短路求值
$result = true || expensive_function();   // 不会执行expensive_function
$result = false && expensive_function();  // 不会执行expensive_function

3.5 位运算符

<?php
$a = 5;      // 0101
$b = 3;      // 0011

echo $a & $b;    // 1  (0001) 按位与
echo $a | $b;    // 7  (0111) 按位或
echo $a ^ $b;    // 6  (0110) 按位异或
echo ~$a;        // -6 (1010) 按位取反
echo $a << 2;    // 20 (10100) 左移
echo $a >> 1;    // 2  (0010) 右移

// 实际应用：权限控制
define('READ', 1);      // 0001
define('WRITE', 2);     // 0010
define('EXECUTE', 4);   // 0100

$permission = READ | WRITE;              // 0011（读+写）
var_dump($permission & READ);            // true（有读权限）
var_dump($permission & EXECUTE);         // false（无执行权限）

3.6 字符串运算符

<?php
// 连接运算符
$str1 = "Hello";
$str2 = "World";
echo $str1 . " " . $str2;        // Hello World

// 连接赋值
$str = "Hello";
$str .= " World";                // Hello World

3.7 数组运算符

<?php
$a = ["a" => "apple", "b" => "banana"];
$b = ["b" => "berry", "c" => "cherry"];

// 合并（后面的不覆盖前面）
$result = $a + $b;
// ["a" => "apple", "b" => "banana", "c" => "cherry"]

// 相等（键值对相同）
var_dump($a == $b);              // false

// 全等（键值对相同且顺序相同）
var_dump($a === $b);             // false

// 不等
var_dump($a != $b);              // true
var_dump($a <> $b);              // true
var_dump($a !== $b);             // true

3.8 类型运算符

<?php
class User {}
class Admin extends User {}

$user = new User();
$admin = new Admin();

// instanceof
var_dump($user instanceof User);         // true
var_dump($admin instanceof User);        // true（继承）
var_dump($admin instanceof Admin);       // true
var_dump($user instanceof Admin);        // false

3.9 错误控制运算符

<?php
// @ 抑制错误
$file = @file_get_contents("not_exist.txt");    // 不显示警告

// 不推荐使用，应该用try-catch
try {
    $file = file_get_contents("not_exist.txt");
} catch (Exception $e) {
    // 处理错误
}

3.10 执行运算符

<?php
// 反引号执行Shell命令
$output = `ls -la`;
echo $output;

// 等同于
$output = shell_exec('ls -la');

4. 命名规范

4.1 变量命名

<?php
// 驼峰命名（推荐用于变量）
$userName = "John";
$userId = 123;
$isActive = true;

// 下划线命名（也常用）
$user_name = "John";
$user_id = 123;
$is_active = true;

// 避免的命名
$n = "John";                    // ❌ 过于简短
$thisIsAReallyLongVariableName; // ❌ 过长
$user-name;                     // ❌ 连字符
$123user;                       // ❌ 数字开头
$class;                         // ❌ 保留字

4.2 函数命名

<?php
// 驼峰命名（推荐）
function getUserName() {
    return "John";
}

function isUserActive() {        // 布尔函数用is/has开头
    return true;
}

function hasPermission() {
    return true;
}

// 下划线命名（也可以）
function get_user_name() {
    return "John";
}

// 动词开头（表示动作）
function createUser() {}         // 创建
function updateUser() {}         // 更新
function deleteUser() {}         // 删除
function findUser() {}           // 查找
function validateEmail() {}      // 验证
function calculateTotal() {}     // 计算

4.3 类命名

<?php
// 帕斯卡命名（大驼峰，必须）
class User {}
class UserController {}
class DatabaseConnection {}
class HttpRequest {}

// 接口：Interface后缀（可选）
interface UserInterface {}
interface RepositoryInterface {}

// 抽象类：Abstract前缀（可选）
abstract class AbstractController {}
abstract class BaseModel {}

// Trait：Trait后缀（可选）
trait TimestampTrait {}
trait ValidateTrait {}

// 异常类：Exception后缀
class UserNotFoundException extends Exception {}
class ValidationException extends Exception {}

4.4 常量命名

<?php
// 全大写+下划线
define('MAX_SIZE', 100);
define('DB_HOST', 'localhost');
define('API_KEY', 'xxx');

class Config {
    const DATABASE_HOST = 'localhost';
    const DATABASE_PORT = 3306;
    const MAX_RETRY_COUNT = 3;
}

// 枚举常量（PHP 8.1+）
enum Status {
    case PENDING;
    case APPROVED;
    case REJECTED;
}

4.5 命名空间

<?php
// 帕斯卡命名，反斜杠分隔
namespace App\Controller\Admin;
namespace App\Service\User;
namespace App\Repository;

// 对应目录结构
// App/
//   Controller/
//     Admin/
//       UserController.php
//   Service/
//     User/
//       UserService.php

5. PSR规范

5.1 PSR规范概览

PSR (PHP Standard Recommendation)
PHP标准推荐，由PHP-FIG制定

主要规范：
PSR-1  : 基本编码标准
PSR-2  : 编码风格指南（已被PSR-12取代）
PSR-3  : 日志接口
PSR-4  : 自动加载
PSR-6  : 缓存接口
PSR-7  : HTTP消息接口
PSR-11 : 容器接口
PSR-12 : 扩展的编码风格指南
PSR-15 : HTTP处理器
PSR-16 : 简单缓存
PSR-17 : HTTP工厂
PSR-18 : HTTP客户端

5.2 PSR-1 基本编码标准

<?php
// 1. 文件必须使用 <?php 或 <?= 标签
<?php
// 代码...

// 2. 文件必须使用UTF-8无BOM编码

// 3. 文件应该只声明或只有副作用，不应两者都有
// ✅ 正确：只声明
<?php
class User {}
function getUser() {}

// ✅ 正确：只有副作用
<?php
require 'config.php';
echo "Hello";

// ❌ 错误：既声明又有副作用
<?php
class User {}
echo "Hello";  // 副作用

// 4. 命名空间和类必须遵循PSR-4自动加载
namespace App\Controller;

class UserController {}

// 5. 类名必须使用帕斯卡命名
class UserService {}

// 6. 类常量必须全大写+下划线
class Config {
    const DATABASE_HOST = 'localhost';
}

// 7. 方法名必须使用驼峰命名
public function getUserName() {}

5.3 PSR-12 编码风格指南

<?php
declare(strict_types=1);     // 严格类型（可选）

namespace App\Controller;    // 命名空间声明

use App\Service\UserService; // use导入
use App\Model\User;
use function array_map;      // 函数导入
use const PHP_EOL;           // 常量导入

/**
 * 用户控制器
 * 
 * @author John Doe
 */
class UserController        // 类名：帕斯卡命名
{
    private UserService $userService;    // 属性：驼峰命名
    
    /**
     * 构造函数
     * 
     * @param UserService $userService
     */
    public function __construct(UserService $userService)    // 方法：驼峰命名
    {                                                        // 大括号：独立一行
        $this->userService = $userService;
    }
    
    /**
     * 获取用户列表
     * 
     * @param int $page 页码
     * @param int $pageSize 每页数量
     * @return array
     */
    public function getUsers(int $page, int $pageSize): array
    {
        // if语句：大括号独立一行
        if ($page < 1) {
            $page = 1;
        }
        
        // for循环
        for ($i = 0; $i < 10; $i++) {
            echo $i;
        }
        
        // foreach循环
        foreach ($users as $key => $value) {
            echo $key . '=>' . $value;
        }
        
        // switch语句
        switch ($status) {
            case 'active':
                // 处理
                break;
            case 'inactive':
                // 处理
                break;
            default:
                // 默认处理
                break;
        }
        
        return $this->userService->getUsers($page, $pageSize);
    }
    
    /**
     * 复杂方法签名换行
     */
    public function createUser(
        string $name,
        string $email,
        int $age,
        array $options = []
    ): User {
        // 方法体
    }
    
    /**
     * 匿名函数
     */
    public function processUsers(): void
    {
        $users = $this->getUsers(1, 10);
        
        // 匿名函数
        array_map(function ($user) {
            return $user['name'];
        }, $users);
        
        // 箭头函数（PHP 7.4+）
        array_map(fn($user) => $user['name'], $users);
    }
}

// 关键点：
// 1. 缩进：4个空格，不用Tab
// 2. 每行代码不超过120字符
// 3. 方法间空一行
// 4. 操作符前后有空格：$a = $b + $c
// 5. 逗号后有空格：function test($a, $b, $c)
// 6. 数组：短语法 [] 代替 array()

5.4 PSR-4 自动加载

<?php
// composer.json配置
{
    "autoload": {
        "psr-4": {
            "App\\": "src/",
            "App\\Controller\\": "src/Controller/",
            "App\\Service\\": "src/Service/"
        }
    }
}

// 目录结构
// src/
//   Controller/
//     UserController.php  →  App\Controller\UserController
//   Service/
//     UserService.php     →  App\Service\UserService
//   Model/
//     User.php            →  App\Model\User

// 文件：src/Controller/UserController.php
<?php
namespace App\Controller;

class UserController {
    // ...
}

// 使用
use App\Controller\UserController;

$controller = new UserController();

5.5 PSR-3 日志接口

<?php
namespace Psr\Log;

/**
 * 日志接口
 */
interface LoggerInterface
{
    public function emergency($message, array $context = []);
    public function alert($message, array $context = []);
    public function critical($message, array $context = []);
    public function error($message, array $context = []);
    public function warning($message, array $context = []);
    public function notice($message, array $context = []);
    public function info($message, array $context = []);
    public function debug($message, array $context = []);
    public function log($level, $message, array $context = []);
}

// 使用示例
class Logger implements LoggerInterface
{
    public function error($message, array $context = [])
    {
        $msg = $this->interpolate($message, $context);
        error_log($msg);
    }
    
    private function interpolate($message, array $context)
    {
        $replace = [];
        foreach ($context as $key => $val) {
            $replace['{' . $key . '}'] = $val;
        }
        return strtr($message, $replace);
    }
}

// 调用
$logger->error('User {username} not found', ['username' => 'john']);

5.6 PSR-11 容器接口

<?php
namespace Psr\Container;

/**
 * 容器接口
 */
interface ContainerInterface
{
    /**
     * 获取容器中的条目
     */
    public function get(string $id);
    
    /**
     * 检查容器是否有此条目
     */
    public function has(string $id): bool;
}

// 使用示例
class Container implements ContainerInterface
{
    private $bindings = [];
    
    public function bind(string $id, $concrete)
    {
        $this->bindings[$id] = $concrete;
    }
    
    public function get(string $id)
    {
        if (!$this->has($id)) {
            throw new NotFoundException();
        }
        
        $concrete = $this->bindings[$id];
        
        if ($concrete instanceof \Closure) {
            return $concrete($this);
        }
        
        return $concrete;
    }
    
    public function has(string $id): bool
    {
        return isset($this->bindings[$id]);
    }
}

6. PHP版本特性

6.1 PHP 5.3（2009）

<?php
// 1. 命名空间
namespace App\Controller;

class UserController {}

// 2. 匿名函数
$callback = function($name) {
    return "Hello, $name";
};

// 3. 闭包
$message = "Hello";
$callback = function($name) use ($message) {
    return "$message, $name";
};

// 4. 后期静态绑定
class A {
    public static function who() {
        echo __CLASS__;
    }
    
    public static function test() {
        static::who();  // 后期静态绑定
    }
}

class B extends A {
    public static function who() {
        echo __CLASS__;
    }
}

B::test();  // 输出: B

// 5. Nowdoc语法
$str = <<<'EOT'
不解析变量的多行字符串
EOT;

6.2 PHP 5.4（2012）

<?php
// 1. 短数组语法
$array = [1, 2, 3];
$assoc = ['name' => 'John', 'age' => 30];

// 2. Trait
trait Logger {
    public function log($message) {
        echo $message;
    }
}

class User {
    use Logger;
}

// 3. 数组解引用
echo [1, 2, 3][0];  // 1

// 4. 实例化时访问成员
(new User())->method();

6.3 PHP 5.5（2013）

<?php
// 1. 生成器
function gen() {
    yield 1;
    yield 2;
    yield 3;
}

foreach (gen() as $value) {
    echo $value;
}

// 2. finally语句
try {
    // code
} catch (Exception $e) {
    // handle
} finally {
    // 总是执行
}

// 3. ::class魔术常量
use App\User;
echo User::class;  // App\User

6.4 PHP 5.6（2014）

<?php
// 1. 可变参数
function sum(...$numbers) {
    return array_sum($numbers);
}

echo sum(1, 2, 3, 4);  // 10

// 2. 参数解包
$numbers = [1, 2, 3];
echo sum(...$numbers);  // 6

// 3. 常量表达式
const ONE = 1;
const TWO = ONE * 2;

// 4. 幂运算符
echo 2 ** 3;  // 8

6.5 PHP 7.0（2015）⭐ 重大升级

<?php
// 1. 标量类型声明
function add(int $a, int $b): int {
    return $a + $b;
}

// 2. 返回值类型声明
function getName(): string {
    return "John";
}

// 3. NULL合并运算符
$username = $_GET['user'] ?? 'guest';

// 4. 太空船运算符
echo 1 <=> 2;  // -1
echo 2 <=> 2;  // 0
echo 3 <=> 2;  // 1

// 5. 匿名类
$obj = new class {
    public function test() {
        echo "test";
    }
};

// 6. Group use声明
use App\{User, Product, Order};

// 7. 性能提升（2倍）
// 内存占用减少

// 8. 错误处理
try {
    // code
} catch (TypeError $e) {
    // 类型错误
} catch (ParseError $e) {
    // 解析错误
}

6.6 PHP 7.1（2016）

<?php
// 1. 可空类型
function test(?string $name): ?string {
    return $name;
}

// 2. Void返回类型
function log(string $message): void {
    echo $message;
}

// 3. 类常量可见性
class User {
    public const PUBLIC_CONST = 'public';
    protected const PROTECTED_CONST = 'protected';
    private const PRIVATE_CONST = 'private';
}

// 4. 多异常捕获
try {
    // code
} catch (RuntimeException | LogicException $e) {
    // 处理
}

// 5. list()支持键名
$array = ['name' => 'John', 'age' => 30];
['name' => $name, 'age' => $age] = $array;

// 6. 负数索引
$array = [1, 2, 3];
echo $array[-1];  // 3

6.7 PHP 7.2（2017）

<?php
// 1. 参数类型扩展
function test(object $obj): object {
    return $obj;
}

// 2. 抽象方法重写
abstract class A {
    abstract public function test(string $s);
}

class B extends A {
    public function test(string $s, int $i = 0) {
        // 可以添加可选参数
    }
}

6.8 PHP 7.3（2018）

<?php
// 1. 更灵活的Heredoc/Nowdoc
$str = <<<END
    多行字符串
    可以缩进
    END;

// 2. 尾部逗号
$array = [
    'a',
    'b',
    'c',  // 允许尾部逗号
];

function test(
    $a,
    $b,
    $c,  // 允许尾部逗号
) {}

// 3. list()引用赋值
$array = [1, 2];
[&$a, $b] = $array;
$a = 10;  // $array[0] = 10

6.9 PHP 7.4（2019）⭐ 重要更新

<?php
// 1. 属性类型声明
class User {
    public int $id;
    public string $name;
    private ?string $email = null;
}

// 2. 箭头函数
$numbers = [1, 2, 3];
$squared = array_map(fn($n) => $n * $n, $numbers);

// 3. NULL合并赋值
$array['key'] ??= 'default';

// 4. 数组解包（支持字符串键）
$arr1 = ['a' => 1];
$arr2 = ['b' => 2];
$result = [...$arr1, ...$arr2];

// 5. 数字分隔符
$number = 1_000_000;  // 更易读

// 6. Weak引用
$obj = new stdClass();
$weakref = WeakReference::create($obj);

6.10 PHP 8.0（2020）⭐⭐ 重大升级

<?php
// 1. 命名参数
function test(string $name, int $age) {}
test(age: 30, name: 'John');  // 可以乱序

// 2. 注解（Attributes）
#[Route('/api/users')]
class UserController {}

// 3. 构造器属性提升
class User {
    public function __construct(
        public string $name,
        public int $age,
    ) {}
}

// 4. 联合类型
function test(int|float $number): int|float {
    return $number;
}

// 5. Match表达式
$result = match($status) {
    'pending' => 'Waiting',
    'approved' => 'Approved',
    'rejected' => 'Rejected',
    default => 'Unknown',
};

// 6. Nullsafe运算符
$country = $user?->getAddress()?->getCountry();

// 7. Throw表达式
$value = $array['key'] ?? throw new Exception('Key not found');

// 8. 混合类型
function test(mixed $data): mixed {
    return $data;
}

// 9. JIT编译器（性能提升）

6.11 PHP 8.1（2021）⭐

<?php
// 1. 枚举
enum Status {
    case Pending;
    case Approved;
    case Rejected;
}

// 带值的枚举
enum Status: string {
    case Pending = 'pending';
    case Approved = 'approved';
    case Rejected = 'rejected';
}

// 2. 只读属性
class User {
    public readonly string $name;
    
    public function __construct(string $name) {
        $this->name = $name;  // 只能赋值一次
    }
}

// 3. First-class可调用语法
$callback = strlen(...);
echo $callback('hello');  // 5

// 4. 新的初始化器
class User {
    public function __construct(
        public string $name = new DefaultName(),
    ) {}
}

// 5. Never返回类型
function terminate(): never {
    exit();
}

// 6. Final常量
class User {
    final public const STATUS = 'active';
}

// 7. 交集类型
function test(Countable&Traversable $data) {}

6.12 PHP 8.2（2022）

<?php
// 1. 只读类
readonly class User {
    public string $name;
    public int $age;
}

// 2. Disjunctive Normal Form (DNF)类型
function test((A&B)|null $data) {}

// 3. True/False/Null独立类型
function test(true $value) {}
function test(false $value) {}
function test(null $value) {}

// 4. 随机扩展
$random = new Random\Randomizer();
$number = $random->getInt(1, 100);

6.13 PHP 8.3（2023）

<?php
// 1. 类型化类常量
class User {
    const string STATUS = 'active';
    const int MAX_AGE = 100;
}

// 2. #[Override]注解
class Child extends Parent {
    #[Override]
    public function test() {}
}

// 3. 深度克隆
$cloned = clone $object with { property: 'new value' };

// 4. JSON验证
json_validate('{"name": "John"}');  // true

6.14 版本对比总结

版本	发布年份	重要特性	性能提升
PHP 5.3	2009	命名空间、匿名函数	-
PHP 5.4	2012	短数组、Trait	-
PHP 5.6	2014	可变参数、常量表达式	-
PHP 7.0	2015	类型声明、性能2倍提升	2倍
PHP 7.1	2016	可空类型、Void类型	10%
PHP 7.4	2019	属性类型、箭头函数	10%
PHP 8.0	2020	注解、JIT、命名参数	10-30%
PHP 8.1	2021	枚举、只读属性	5%
PHP 8.2	2022	只读类、DNF类型	3%
PHP 8.3	2023	类型化常量	2%

7. 常用函数

7.1 字符串函数

<?php
// 长度和查找
strlen("hello");                    // 5
strpos("hello world", "world");     // 6
strrpos("hello hello", "hello");    // 6（最后出现位置）
str_contains("hello", "ell");       // true（PHP 8+）
str_starts_with("hello", "he");     // true（PHP 8+）
str_ends_with("hello", "lo");       // true（PHP 8+）

// 截取和替换
substr("hello", 1, 3);              // "ell"
str_replace("world", "PHP", "hello world");  // "hello PHP"
str_ireplace("WORLD", "PHP", "hello world"); // 不区分大小写

// 大小写转换
strtoupper("hello");                // "HELLO"
strtolower("HELLO");                // "hello"
ucfirst("hello");                   // "Hello"
ucwords("hello world");             // "Hello World"

// 去空格
trim("  hello  ");                  // "hello"
ltrim("  hello");                   // "hello"
rtrim("hello  ");                   // "hello"

// 分割和连接
explode(",", "a,b,c");              // ["a", "b", "c"]
implode(",", ["a", "b", "c"]);      // "a,b,c"
join(",", ["a", "b", "c"]);         // "a,b,c"（同implode）

// 填充和重复
str_pad("5", 3, "0", STR_PAD_LEFT); // "005"
str_repeat("*", 5);                 // "*****"

// 编码转换
htmlspecialchars("<script>");       // "&lt;script&gt;"
htmlspecialchars_decode("&lt;");    // "<"
urlencode("hello world");           // "hello+world"
urldecode("hello+world");           // "hello world"

7.2 数组函数

<?php
// 添加删除
array_push($arr, "value");          // 末尾添加
array_pop($arr);                    // 删除末尾
array_unshift($arr, "value");       // 开头添加
array_shift($arr);                  // 删除开头

// 合并和拆分
array_merge($arr1, $arr2);          // 合并数组
array_slice($arr, 1, 2);            // 切片
array_chunk([1,2,3,4], 2);          // [[1,2], [3,4]]

// 搜索和判断
in_array("value", $arr);            // 是否存在
array_search("value", $arr);        // 搜索键名
array_key_exists("key", $arr);      // 键是否存在
isset($arr['key']);                 // 键是否存在且不为NULL

// 遍历操作
array_map('strtoupper', $arr);      // 映射
array_filter($arr, fn($v) => $v > 5); // 过滤
array_reduce($arr, fn($c, $v) => $c + $v, 0); // 归约

// 排序
sort($arr);                         // 升序（重新索引）
rsort($arr);                        // 降序
asort($arr);                        // 升序（保持索引）
arsort($arr);                       // 降序（保持索引）
ksort($arr);                        // 按键排序
usort($arr, fn($a, $b) => $a <=> $b); // 自定义排序

// 统计
count($arr);                        // 元素个数
array_sum($arr);                    // 求和
array_product($arr);                // 求积
array_unique($arr);                 // 去重
array_values($arr);                 // 重新索引
array_keys($arr);                   // 获取所有键

7.3 文件函数

<?php
// 读取文件
file_get_contents("file.txt");      // 读取整个文件
file("file.txt");                   // 读取到数组（按行）
readfile("file.txt");               // 输出文件内容

// 写入文件
file_put_contents("file.txt", "content");  // 写入（覆盖）
file_put_contents("file.txt", "content", FILE_APPEND); // 追加

// 文件操作
file_exists("file.txt");            // 文件是否存在
is_file("file.txt");                // 是否是文件
is_dir("dirname");                  // 是否是目录
filesize("file.txt");               // 文件大小
filemtime("file.txt");              // 修改时间
rename("old.txt", "new.txt");       // 重命名
copy("src.txt", "dst.txt");         // 复制
unlink("file.txt");                 // 删除文件

// 目录操作
mkdir("dirname");                   // 创建目录
rmdir("dirname");                   // 删除目录
scandir("dirname");                 // 列出目录内容

7.4 日期时间函数

<?php
// 当前时间
time();                             // 时间戳
date("Y-m-d H:i:s");               // 格式化日期
date("Y-m-d H:i:s", time());       // 指定时间戳

// 日期转换
strtotime("2023-01-01");           // 字符串转时间戳
strtotime("+1 day");               // 明天
strtotime("next Monday");          // 下周一

// DateTime类（推荐）
$date = new DateTime();
$date->format("Y-m-d");            // 格式化
$date->modify("+1 day");           // 修改日期
$date->add(new DateInterval("P1D")); // 加1天
$date->sub(new DateInterval("P1M")); // 减1月

// 时区
date_default_timezone_set("Asia/Shanghai");
$date->setTimezone(new DateTimeZone("UTC"));

8. 面试高频题

Q1: PHP变量的作用域有哪些？

局部变量: 函数内部定义，只在函数内有效
全局变量: 函数外定义，需要用global关键字引入
静态变量: 用static声明，函数执行完不销毁
超全局变量: $_GET、$_POST等，任何地方都可访问

$global = "global";

function test() {
    global $global;        // 引入全局变量
    static $count = 0;     // 静态变量
    $local = "local";      // 局部变量
    
    $count++;
    echo $global;
    echo $_GET['name'];    // 超全局变量
}

Q2: `==` 和 `===` 的区别？

==: 比较值是否相等（会进行类型转换）
===: 比较值和类型是否都相等（不转换类型）

var_dump(1 == "1");      // true（值相等）
var_dump(1 === "1");     // false（类型不同）
var_dump(0 == false);    // true
var_dump(0 === false);   // false
var_dump(null == false); // true
var_dump(null === false);// false

推荐: 尽量使用===，避免类型转换带来的隐患

Q3: include和require的区别？

特性	include	require
找不到文件	警告，继续执行	致命错误，停止执行
重复引入	每次都引入	每次都引入
once版本	include_once	require_once

include 'file.php';      // 找不到文件继续执行
require 'file.php';      // 找不到文件停止执行

include_once 'file.php'; // 只引入一次
require_once 'file.php'; // 只引入一次

推荐: 引入重要文件用require_once

Q4: 什么是魔术方法？

A: 以__开头的特殊方法，在特定情况下自动调用

class User {
    public function __construct() {}      // 构造函数
    public function __destruct() {}       // 析构函数
    public function __get($name) {}       // 获取私有属性
    public function __set($name, $value) {} // 设置私有属性
    public function __call($name, $args) {} // 调用不存在的方法
    public function __toString() {}       // 对象转字符串
    public function __invoke() {}         // 对象当函数调用
    public function __clone() {}          // 克隆对象
    public function __sleep() {}          // 序列化前
    public function __wakeup() {}         // 反序列化后
}

Q5: 说说PHP 7和PHP 8的主要新特性？

PHP 7主要特性:

性能提升2倍
标量类型声明：int、string、bool、float
返回值类型声明
NULL合并运算符：??
太空船运算符：<=>
匿名类

PHP 8主要特性:

JIT编译器（性能再提升）
命名参数
注解（Attributes）
构造器属性提升
联合类型
Match表达式
Nullsafe运算符：?->
枚举（PHP 8.1）

总结

核心要点

变量: 弱类型、8种数据类型、类型声明
运算符: 算术、比较、逻辑、位、??、<=>
命名规范: 驼峰、帕斯卡、下划线
PSR规范: PSR-1、PSR-4、PSR-12
版本特性: PHP 7性能2倍、PHP 8 JIT+新语法

学习建议

掌握基础语法和数据类型
理解PSR规范，写出规范的代码
了解版本特性，使用新语法
多练习常用函数
关注新版本特性

推荐资源:

PHP官方文档: www.php.net/
PSR规范: www.php-fig.org/psr/
PHP版本更新: www.php.net/releases/

00-PHP基础知识-1

PHP基础知识完全补充手册

目录

1. PHP基础语法

1.1 PHP标记

1.2 注释

1.3 语句分隔符

2. 变量与数据类型

2.1 变量基础

2.2 数据类型

标量类型

复合类型

特殊类型

2.3 类型转换

2.4 类型声明（PHP 7+）

2.5 常量

3. 运算符与符号

3.1 算术运算符

3.2 赋值运算符

3.3 比较运算符

3.4 逻辑运算符

3.5 位运算符

3.6 字符串运算符

3.7 数组运算符

3.8 类型运算符

3.9 错误控制运算符

3.10 执行运算符

4. 命名规范

4.1 变量命名

4.2 函数命名

4.3 类命名

4.4 常量命名

4.5 命名空间

5. PSR规范

5.1 PSR规范概览

5.2 PSR-1 基本编码标准

5.3 PSR-12 编码风格指南

5.4 PSR-4 自动加载

5.5 PSR-3 日志接口

5.6 PSR-11 容器接口

6. PHP版本特性

6.1 PHP 5.3（2009）

6.2 PHP 5.4（2012）

6.3 PHP 5.5（2013）

6.4 PHP 5.6（2014）

6.5 PHP 7.0（2015）⭐ 重大升级

6.6 PHP 7.1（2016）

6.7 PHP 7.2（2017）

6.8 PHP 7.3（2018）

6.9 PHP 7.4（2019）⭐ 重要更新

6.10 PHP 8.0（2020）⭐⭐ 重大升级

6.11 PHP 8.1（2021）⭐

6.12 PHP 8.2（2022）

6.13 PHP 8.3（2023）

6.14 版本对比总结

7. 常用函数

7.1 字符串函数

7.2 数组函数

7.3 文件函数

7.4 日期时间函数

8. 面试高频题

Q1: PHP变量的作用域有哪些？

Q2: == 和 === 的区别？

Q3: include和require的区别？

Q4: 什么是魔术方法？

Q5: 说说PHP 7和PHP 8的主要新特性？

总结

核心要点

学习建议

Q2: `==` 和 `===` 的区别？