PHP on Leanku 的博客

PHPUnit使用指南

Mon, 30 Jun 2025 23:46:01 +0800

PHPUnit 使用指南

一、介绍

PHPUnit 是 PHP 领域最流行的单元测试框架，它受到 JUnit 的启发，为 PHP 开发者提供了编写和运行单元测试的工具和方法。使用 PHPUnit 可以带来以下好处：

验证代码的正确性，确保函数和方法按预期工作
便于代码重构，修改后可以快速验证是否破坏了现有功能
帮助理解代码功能，测试用例本身就是一种文档
支持测试驱动开发 (TDD) 流程

二、安装 PHPUnit

1. 安装 PHPUnit（可以通过 `composer require --dev phpunit/phpunit` 安装）

2. 配置PhpStorm 运行 PHPUnit（Docker环境为例）

2.1. 配置 Docker 远程解释器

打开 PhpStorm，进入 File > Settings > Build, Execution, Deployment > Docker
在右侧选择 Docker for Windows（通常会自动检测）
点击 Apply 确认配置，确保连接成功（底部会显示 “Connection successful”）
进入 File > Settings > Languages & Frameworks > PHP
点击 CLI Interpreter 右侧的 … 按钮，点击左上角 + 号，选择 From Docker, Vagrant, VM, WSL, Remote…
选择 Docker 并找到你的 php 容器
选择容器中的 PHP 可执行文件路径（如 /usr/local/bin/php）
点击 OK 完成配置，PhpStorm 会自动检测 PHP 版本和扩展

2.2 配置 PHPUnit

进入 File > Settings > Languages & Frameworks > PHP > Test Frameworks

PHP8新特性：JIT

Sun, 22 Jun 2025 20:46:01 +0800

PHP8新特性：JIT（Just-In-Time）

一、JIT（Just-In-Time）编译技术概述

1.1 什么是JIT编译

JIT（Just-In-Time）编译是一种动态编译技术，它在程序运行时将字节码或中间代码编译为机器码执行，而不是预先编译（AOT，Ahead-Of-Time）或纯粹解释执行。PHP 8.0首次引入了JIT编译器，这是PHP性能演进史上的重要里程碑。

1.2 PHP执行模式的演进

解释执行模式（PHP 5.x及之前）：
- 每次请求都需要解析、编译和执行
- 无任何形式的持久化缓存
OPCache缓存模式（PHP 5.5+）：
- 缓存预编译的opcode
- 减少重复编译开销
- 但仍需解释执行opcode
JIT编译模式（PHP 8.0+）：
- 将热代码（频繁执行的代码）编译为机器码
- 直接执行机器码，绕过解释器

1.3 JIT带来的性能提升

根据官方基准测试，JIT在某些计算密集型工作负载上可带来：

数学运算：1.5-3倍提升
字符串处理：1.2-2倍提升
框架综合性能：10-30%提升

注意：JIT对I/O密集型应用（如纯数据库CRUD）提升有限

二、PHP JIT工作原理

2.1 PHP脚本执行流程

 1PHP源代码
 2 ↓
 3Zend编译器 (生成opcode)
 4 ↓
 5OPCache (缓存opcode)
 6 ↓
 7Zend VM解释执行
 8 ↓
 9JIT编译器 (追踪热代码)
10 ↓
11生成机器码
12 ↓
13直接执行机器码

2.2 JIT编译流程

代码追踪：
- 监控执行过程中的热代码（频繁执行的代码路径）
- 默认阈值：执行次数超过3次触发JIT编译
编译优化：
- 寄存器分配
- 循环优化
- 死代码消除
- 内联函数调用
机器码生成：
- 针对当前CPU架构生成优化后的机器码
- 支持x86和ARM架构
执行切换：
- 后续执行直接跳转到机器码
- 绕过Zend虚拟机解释器

2.3 JIT与OPCache的关系

协同工作：
- OPCache是JIT的基础
- JIT只编译OPCache中缓存的opcode
内存管理：
- JIT使用OPCache的共享内存存储机器码
- opcache.jit_buffer_size控制JIT内存池大小

三、PHP JIT配置与使用

3.1 启用JIT

在php.ini中配置：

PHP底层原理与性能优化深度解析

Sun, 22 Jun 2025 20:46:01 +0800

PHP底层原理与性能优化深度解析

一、PHP生命周期与SAPI

PHP的生命周期是一个复杂但有序的过程，理解它对于性能优化至关重要。

1.1 PHP生命周期概述

PHP的生命周期可以概括为以下几个阶段：

模块初始化阶段 (MINIT)
- 只在PHP启动时执行一次
- 注册常量、类、资源类型等
- 所有扩展的MINIT方法被调用
请求初始化阶段 (RINIT)
- 每个请求开始时执行
- 初始化脚本运行环境
- 所有扩展的RINIT方法被调用
脚本执行阶段
- 解析、编译、执行PHP脚本
- 生成响应内容
请求关闭阶段 (RSHUTDOWN)
- 每个请求结束时执行
- 清理请求级资源
- 所有扩展的RSHUTDOWN方法被调用
模块关闭阶段 (MSHUTDOWN)
- PHP关闭时执行一次
- 清理持久化资源
- 所有扩展的MSHUTDOWN方法被调用

1.2 SAPI (Server API)

SAPI是PHP与外部环境交互的接口层，常见的SAPI类型包括：

Web服务器集成：
- Apache (mod_php)
- Nginx (PHP-FPM)
- IIS
命令行接口：
- CLI (Command Line Interface)
- CGI
嵌入式PHP：
- 嵌入到其他应用程序中

不同的SAPI实现会影响PHP的生命周期。例如：

在mod_php中，PHP作为Apache模块运行，生命周期与Apache进程绑定
在PHP-FPM中，PHP作为独立的FastCGI进程运行，可以独立管理进程池

二、OPCache原理与优化

2.1 PHP脚本执行流程

传统PHP脚本执行流程：

词法分析 (Lexing) - 将源代码转换为token流
语法分析 (Parsing) - 将token流转换为抽象语法树(AST)
编译 (Compilation) - 将AST转换为opcodes
执行 (Execution) - 执行opcodes

每次请求都需要重复这些步骤，造成大量CPU资源浪费。

PHP 实现 Redis 高并发解决方案

Fri, 28 Mar 2025 22:33:45 +0800

PHP 实现 Redis 高并发解决方案

使用 PHP 实现 Redis 在缓存加速、分布式锁和队列场景中的应用。

首先确保已安装 PHP Redis 扩展

一、缓存加速实现

1. 基本缓存操作

 1<?php
 2$redis = new Redis();
 3$redis->connect('127.0.0.1', 6379);
 4
 5// 设置缓存
 6function setCache($key, $value, $expire = 3600) {
 7 global $redis;
 8 $serialized = serialize($value);
 9 return $redis->setex($key, $expire, $serialized);
10}
11
12// 获取缓存
13function getCache($key) {
14 global $redis;
15 $serialized = $redis->get($key);
16 return $serialized ? unserialize($serialized) : false;
17}
18
19// 删除缓存
20function deleteCache($key) {
21 global $redis;
22 return $redis->del($key);
23}
24
25// 示例：用户数据缓存
26function getUser($userId) {
27 $cacheKey = "user:{$userId}";
28 $user = getCache($cacheKey);
29 
30 if ($user === false) {
31 // 模拟数据库查询
32 $user = [
33 'id' => $userId,
34 'name' => 'User ' . $userId,
35 'email' => "user{$userId}@example.com"
36 ];
37 // 写入缓存，有效期1小时
38 setCache($cacheKey, $user, 3600);
39 }
40 
41 return $user;
42}
43
44// 使用示例
45$user = getUser(123);
46print_r($user);

2. 防止缓存穿透

 1function getProduct($productId) {
 2 global $redis;
 3 $cacheKey = "product:{$productId}";
 4 $product = getCache($cacheKey);
 5 
 6 if ($product === false) {
 7 // 使用互斥锁防止缓存击穿
 8 $lockKey = "lock:product:{$productId}";
 9 $locked = $redis->set($lockKey, 1, ['nx', 'ex' => 10]);
10 
11 if ($locked) {
12 try {
13 // 模拟数据库查询
14 $product = [
15 'id' => $productId,
16 'name' => 'Product ' . $productId,
17 'price' => rand(100, 1000)
18 ];
19 
20 if (empty($product)) {
21 // 缓存空对象防止穿透，有效期5分钟
22 setCache($cacheKey, [], 300);
23 } else {
24 setCache($cacheKey, $product, 3600);
25 }
26 } finally {
27 $redis->del($lockKey);
28 }
29 } else {
30 // 等待其他进程完成缓存设置
31 usleep(500000); // 等待500ms
32 return getProduct($productId); // 重试
33 }
34 }
35 
36 return $product ?: null;
37}

二、分布式锁实现

1. 基本分布式锁

 1class RedisLock {
 2 private $redis;
 3 private $lockKey;
 4 private $identifier;
 5 private $lockTimeout;
 6 
 7 public function __construct($redis, $lockKey, $lockTimeout = 10) {
 8 $this->redis = $redis;
 9 $this->lockKey = $lockKey;
10 $this->lockTimeout = $lockTimeout;
11 $this->identifier = uniqid();
12 }
13 
14 public function acquire($waitTimeout = 5) {
15 $end = microtime(true) + $waitTimeout;
16 
17 while (microtime(true) < $end) {
18 if ($this->redis->set(
19 $this->lockKey, 
20 $this->identifier, 
21 ['nx', 'ex' => $this->lockTimeout]
22 )) {
23 return true;
24 }
25 
26 usleep(10000); // 等待10ms
27 }
28 
29 return false;
30 }
31 
32 public function release() {
33 $script = '
34 if redis.call("get", KEYS[1]) == ARGV[1] then
35 return redis.call("del", KEYS[1])
36 else
37 return 0
38 end
39 ';
40 
41 return $this->redis->eval($script, [$this->lockKey, $this->identifier], 1);
42 }
43 
44 public function __destruct() {
45 $this->release();
46 }
47}
48
49// 使用示例
50$lock = new RedisLock($redis, 'lock:order:123');
51if ($lock->acquire()) {
52 try {
53 // 执行需要加锁的操作
54 echo "Lock acquired, doing critical section...\n";
55 sleep(2);
56 } finally {
57 $lock->release();
58 }
59} else {
60 echo "Failed to acquire lock\n";
61}

2. 可重入锁实现

 1class ReentrantRedisLock extends RedisLock {
 2 private $heldCount = 0;
 3 
 4 public function acquire($waitTimeout = 5) {
 5 // 检查是否已经持有锁
 6 if ($this->heldCount > 0) {
 7 $this->heldCount++;
 8 return true;
 9 }
10 
11 $acquired = parent::acquire($waitTimeout);
12 if ($acquired) {
13 $this->heldCount = 1;
14 }
15 return $acquired;
16 }
17 
18 public function release() {
19 if ($this->heldCount > 1) {
20 $this->heldCount--;
21 return true;
22 }
23 
24 $released = parent::release();
25 if ($released) {
26 $this->heldCount = 0;
27 }
28 return $released;
29 }
30}

三、队列实现

1. 简单队列

 1// 生产者
 2function enqueue($queueName, $data) {
 3 global $redis;
 4 return $redis->lPush($queueName, json_encode($data));
 5}
 6
 7// 消费者
 8function dequeue($queueName, $timeout = 30) {
 9 global $redis;
10 $result = $redis->brPop($queueName, $timeout);
11 return $result ? json_decode($result[1], true) : null;
12}
13
14// 示例
15enqueue('email_queue', [
16 'to' => 'user@example.com',
17 'subject' => 'Welcome',
18 'body' => 'Thank you for registering'
19]);
20
21$task = dequeue('email_queue');
22if ($task) {
23 // 处理任务
24 echo "Sending email to: {$task['to']}\n";
25}

2. 延迟队列

 1function enqueueDelayed($queueName, $data, $delaySeconds) {
 2 global $redis;
 3 $score = time() + $delaySeconds;
 4 return $redis->zAdd($queueName, $score, json_encode($data));
 5}
 6
 7function processDelayedQueue($queueName) {
 8 global $redis;
 9 $now = time();
10 $items = $redis->zRangeByScore($queueName, 0, $now);
11 
12 if (!empty($items)) {
13 // 使用事务移除已处理项
14 $redis->multi();
15 foreach ($items as $item) {
16 $redis->zRem($queueName, $item);
17 }
18 $redis->exec();
19 
20 return array_map(function($item) {
21 return json_decode($item, true);
22 }, $items);
23 }
24 
25 return [];
26}
27
28// 示例
29enqueueDelayed('reminder_queue', ['user_id' => 123, 'message' => 'Pay your bill'], 60);
30
31$tasks = processDelayedQueue('reminder_queue');
32foreach ($tasks as $task) {
33 echo "Sending reminder to user {$task['user_id']}: {$task['message']}\n";
34}

3. Pub/Sub 模式

 1// 发布者
 2function publishMessage($channel, $message) {
 3 global $redis;
 4 return $redis->publish($channel, json_encode($message));
 5}
 6
 7// 订阅者
 8function subscribe($channels, $callback) {
 9 global $redis;
10 $pubsub = $redis->pSubscribe($channels);
11 
12 try {
13 foreach ($pubsub as $message) {
14 if ($message->kind === 'message') {
15 $data = json_decode($message->payload, true);
16 call_user_func($callback, $message->channel, $data);
17 }
18 }
19 } catch (Exception $e) {
20 $redis->pUnsubscribe();
21 throw $e;
22 }
23}
24
25// 示例使用
26// 在一个进程中
27publishMessage('notifications', ['user_id' => 123, 'text' => 'New message']);
28
29// 在另一个进程中
30subscribe(['notifications'], function($channel, $message) {
31 echo "Received on {$channel}: ";
32 print_r($message);
33});

四、综合应用示例 - 秒杀系统

 1class SeckillService {
 2 private $redis;
 3 private $productKey;
 4 
 5 public function __construct($redis, $productId) {
 6 $this->redis = $redis;
 7 $this->productKey = "seckill:product:{$productId}";
 8 }
 9 
10 public function initInventory($inventory) {
11 // 设置商品库存
12 $this->redis->set($this->productKey, $inventory);
13 }
14 
15 public function seckill($userId) {
16 // 使用分布式锁
17 $lock = new RedisLock($this->redis, "lock:{$this->productKey}");
18 
19 if (!$lock->acquire(1)) {
20 return ['success' => false, 'message' => '系统繁忙'];
21 }
22 
23 try {
24 // 检查库存
25 $inventory = $this->redis->get($this->productKey);
26 if ($inventory <= 0) {
27 return ['success' => false, 'message' => '已售罄'];
28 }
29 
30 // 扣减库存
31 $this->redis->decr($this->productKey);
32 
33 // 记录订单 (实际应用中应该入队列异步处理)
34 $orderId = uniqid();
35 $this->redis->hSet("seckill:orders", $orderId, json_encode([
36 'user_id' => $userId,
37 'product_key' => $this->productKey,
38 'created_at' => time()
39 ]));
40 
41 return ['success' => true, 'order_id' => $orderId];
42 } finally {
43 $lock->release();
44 }
45 }
46}
47
48// 使用示例
49$redis = new Redis();
50$redis->connect('127.0.0.1', 6379);
51
52$seckill = new SeckillService($redis, 1001);
53$seckill->initInventory(100); // 初始化100件库存
54
55// 模拟并发请求
56for ($i = 0; $i < 5; $i++) {
57 $result = $seckill->seckill(rand(1000, 9999));
58 print_r($result);
59}

五、最佳实践建议

1. 连接管理：使用连接池或持久连接

1$redis = new Redis();
2$redis->pconnect('127.0.0.1', 6379);

2. 错误处理：添加重试机制

 1function redisRetry($callback, $maxRetries = 3) {
 2 $retries = 0;
 3 while ($retries < $maxRetries) {
 4 try {
 5 return $callback();
 6 } catch (RedisException $e) {
 7 $retries++;
 8 if ($retries >= $maxRetries) {
 9 throw $e;
10 }
11 usleep(100000 * $retries); // 指数退避
12 }
13 }
14}

3. 性能优化：使用管道(pipeline)

1$pipe = $redis->pipeline();
2$pipe->set('key1', 'value1');
3$pipe->set('key2', 'value2');
4$pipe->incr('counter');
5$pipe->expire('key1', 60);
6$results = $pipe->exec();

4. Lua脚本：保证原子性

1$script = '
2 local current = redis.call("GET", KEYS[1])
3 if current == ARGV[1] then
4 return redis.call("INCRBY", KEYS[1], ARGV[2])
5 else
6 return nil
7 end
8';
9$result = $redis->eval($script, ['counter', 'expected_value', 'increment'], 1);

内存溢出

Fri, 28 Mar 2025 22:33:45 +0800

内存溢出

一、什么是内存溢出

内存溢出（Memory Overflow / Out of Memory, OOM）指程序在申请内存时，没有足够的空间供其使用。在 PHP 中，通常表现为：

脚本超出 memory_limit 设置（默认 128M），抛出 Fatal error: Allowed memory size of X bytes exhausted
系统级 OOM：PHP 进程消耗了操作系统分配的所有内存，被内核强制杀死（常见于常驻进程如 Swoole、Workerman）

二、如何排查内存溢出？

1. 查看错误日志

PHP 错误日志中会直接记录内存耗尽的位置和当前内存使用量。
系统日志（/var/log/messages 或 journalctl -xe）可看到是否因 OOM Killer 杀死了进程。

2. 使用内存分析工具

Xdebug 的追踪功能
```
1xdebug.profiler_enable = 1
2xdebug.profiler_output_dir = /tmp
```
生成 cachegrind 文件，用 QCacheGrind 或 WebGrind 分析，查看哪个函数/行消耗了大量内存。

Xdebug 的垃圾回收统计

1xdebug_debug_zstd('your_var'); // 显示变量内存占用（需扩展）

使用 memory_get_usage() / memory_get_peak_usage()

在代码关键位置打印内存，定位峰值点：

1echo memory_get_usage() . " bytes\n";
2// 执行一段代码
3echo memory_get_peak_usage() . " bytes\n";

Valgrind（用于 CLI 或常驻进程）

线程安全

Fri, 28 Mar 2025 22:33:45 +0800

内存溢出

PHP本身（无论是PHP-FPM还是Swoole）并不支持多线程。

线程安全，在PHP的世界里通常指以下两种情况，我们需要分开讨论：

PHP解释器自身的线程安全：指PHP作为C语言编写的程序，当其被嵌入到多线程的Web服务器（如Apache的worker MPM）中时，多个线程能否安全地共用一个PHP解释器实例。
PHP应用代码的并发安全：指我们的业务代码在同时处理多个请求时，如何避免共享数据的冲突。这在Swoole这类常驻内存的进程中尤其重要。

下面分别介绍：

1. PHP解释器的线程安全（Zend线程安全，ZTS）

这是PHP源码编译时的一个选项（–enable-zts）。

问题背景：PHP有很多全局变量（例如存放已加载扩展列表的变量）。在单线程环境下没问题，但在多线程环境下，线程A修改这个全局变量时，线程B可能正在读取，导致崩溃。
解决方案（ZTS）：PHP通过TSRM（线程安全资源管理器） 为每个线程分配了一个独立的“全局变量副本”。线程A修改自己的副本，不会影响线程B。
- 对开发者的影响：
- PHP-FPM（Nginx+PHP-FPM）：使用的是多进程模型，一个进程只处理一个请求。进程间内存天然隔离，不存在线程安全问题，因此通常编译非线程安全（NTS） 版本，性能更高。
- Apache + worker MPM：Apache使用多线程模型，此时PHP必须编译为ZTS版本才能稳定运行。
- Swoole：Swoole本身是多进程模型。每个Worker进程是单线程的，事件循环和协程都在这个主线程中运行。因此，PHP的ZTS在Swoole环境下并非必需，Swoole官网也推荐使用NTS版本的PHP。

小结：对于绝大多数PHP开发者（使用PHP-FPM或Swoole），无需关心PHP底层的ZTS。你基本不会直接编写相关代码，这是扩展开发者和PHP本身需要解决的问题。

2. 应用代码的并发安全：Swoole常驻内存下的挑战

在传统的PHP-FPM中，每个请求结束后，所有变量都被销毁，下一个请求是“干净”的，所以不存在并发安全问题。

但在Swoole中，Worker进程常驻内存，多个协程或请求会并发地操作进程内的同一个全局变量、静态变量或资源（如Redis连接），这就会引发经典的竞态条件（Race Condition）。

典型问题场景：

1// 一个 Worker 进程内的全局计数器
2$globalCounter = 0;
3
4// 协程A 和 协程B 同时执行这段代码
5$globalCounter++; // 这不是原子操作！
6echo $globalCounter;

两个协程同时读取0，分别加1，然后写回。你期望输出2，但实际可能输出1。这就是并发问题。

如何保证Swoole下的并发安全？

Swoole提供了几种机制来解决这个问题：

方案一：使用原子计数器（Atomic）

Swoole提供的Swoole\Atomic是一个基于CPU原子操作的计数器，操作是线程/协程安全的。

1$atomic = new Swoole\Atomic(0);
2
3// 在任意协程中安全地增加
4$atomic->add(); // 无锁，高性能
5echo $atomic->get();

方案二：使用锁（Lock）

对于复杂的共享数据读写（不只是计数），可以使用各种锁。

协程锁（Swoole\Lock 或 Channel）：推荐，只在协程级别阻塞。

1$lock = new Swoole\Lock(Swoole\Lock::SPIN); // 自旋锁
2$lock->lock();
3// ... 操作共享数据，如读写一个数组 ...
4$lock->unlock();

文件锁：适用于跨进程的互斥。

方案三：利用协程的Channel

Channel可以看作一个协程安全的队列。你可以利用它来实现生产者-消费者模式，或者作为互斥令牌（一次只放一个令牌进去，谁拿到令牌谁执行）。

PHP中的设计模式

Fri, 15 Mar 2024 13:46:01 +0800

PHP中的设计模式

介绍

设计模式：提供了一种广泛的可重用的方式来解决我们日常编程中常常遇见的问题。设计模式并不一定就是一个类库或者第三方框架，它们更多的表现为一种思想并且广泛地应用在系统中。它们也表现为一种模式或者模板，可以在多个不同的场景下用于解决问题。设计模式可以用于加速开发，并且将很多大的想法或者设计以一种简单地方式实现。当然，虽然设计模式在开发中很有作用，但是千万要避免在不适当的场景误用它们。

设计模式原则

设计模式六大原则

开放封闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
里氏替换原则：所有引用基类的地方必须能透明地使用其子类的对象.
依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。
单一职责原则：不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。
接口隔离原则：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。
迪米特法则：一个对象应该对其他对象保持最少的了解。

设计模式实现

1. Singleton(单例模式)

单例模式是最常见的模式之一，在Web应用的开发中，常常用于允许在运行时为某个特定的类创建仅有一个可访问的实例。

 1<?php
 2final class Mysql
 3{
 4 
 5 /**
 6 *
 7 * @var self[该属性用来保存实例]
 8 */
 9 private static $instance;
10 
11 /**
12 *
13 * @var mixed
14 */
15 public $mix;
16 
17 /**
18 * Return self instance[创建一个用来实例化对象的方法]
19 *
20 * @return self
21 */
22 public static function getInstance()
23 {
24 if (! (self::$instance instanceof self)) {
25 self::$instance = new self();
26 }
27 return self::$instance;
28 }
29 
30 /**
31 * 构造函数为private,防止创建对象
32 */
33 private function __construct()
34 {}
35 
36 /**
37 * 防止对象被复制
38 */
39 private function __clone()
40 {
41 trigger_error('Clone is not allowed !');
42 }
43}
44 
45// @test
46$firstMysql = Mysql::getInstance();
47$secondMysql = Mysql::getInstance();
48 
49$firstMysql->mix = 'ityangs_one';
50$secondMysql->mix = 'ityangs_two';
51 
52print_r($firstMysql->mix);
53// 输出： ityangs_two
54print_r($secondMysql->mix);

2. Factory(工厂模式)

工厂模式是另一种非常常用的模式，正如其名字所示：确实是对象实例的生产工厂。某些意义上，工厂模式提供了通用的方法有助于我们去获取对象，而不需要关心其具体的内在的实现。

PHP面向对象

Mon, 11 Mar 2024 13:46:01 +0800

PHP面向对象

面向对象程序设计实际上就是对现实世界的对象进行建模操作。面向对象程序设计的特征主要可以概括为封装、继承和多态

特性

封装指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装例如，计算机的主机是由内存条、硬盘、风扇等部件组成，生产厂家把这些部件用一个外壳封装起来组成主机，用户在使用该主机时，无需关心其内部的组成及工作原理
继承指可以创建一个新的类，该类继承了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。例如，已经描述了汽车模型这个类的属性和行为，如果需要描述一个小轿车类，只需让小轿车类继承汽车模型类，然后再描述小轿车类特有的属性和行为，而不必再重复描述一些在汽车模型类中已有的属性和行为
多态程序中的多态是指一种行为对应着多种不同的实现。指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象的统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。例如，在一般类中说明了一种求几何图形面积的行为，这种行为不具有具体含义，因为它并没有确定具体几何图形；在特殊类（如三角形、正方形、梯形）中都继承了一般类的求面积的行为，可以根据具体的几何图形重新定义求面积行为。在 PHP 中，多态可以通过实现接口（interface）和使用抽象类（abstract class）来实现。

类与对象

在PHP中把具有相同属性和行为的对象看成同一类，把属于某个类的实例称为某个类的对象。例如学生小千与小锋是两个不同的对象，两者有共同的属性（如学号、成绩等），也有相同的行为（如选课、显示成绩等），因此两者同属于学生类

类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
对象 − 是类的实例。
成员变量 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可成为对象的属性。
成员函数 − 定义在类的内部，可用于访问对象的数据。
继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
子类 − 一个类继承其他类称为子类，也可称为派生类。
多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
构造函数 − 主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

类定义

类使用 class 关键字后加上类名定义。
类名后的一对大括号({})内可以定义变量和方法。
类的变量使用 var 来声明, 变量也可以初始化值。
函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。

 1<?php
 2class Site {
 3 /* 成员变量 */
 4 var $url;
 5 var $title;
 6 
 7 /* 成员函数 */
 8 function setUrl($par){
 9 $this->url = $par;
10 }
11 
12 function getUrl(){
13 echo $this->url . PHP_EOL;
14 }
15 
16 function setTitle($par){
17 $this->title = $par;
18 }
19 
20 function getTitle(){
21 echo $this->title . PHP_EOL;
22 }
23}
24?>

变量 $this 代表自身的对象。

PHP魔术方法

Sun, 10 Mar 2024 13:46:01 +0800

PHP魔术方法

魔术方法是一种特殊的方法，当对对象执行某些操作时会覆盖 PHP 的默认操作。

PHP中把以两个下划线__开头的方法称为魔术方法(Magic methods)，这些方法在PHP中充当了举足轻重的作用。

__construct()，类的构造函数。
PHP 允许开发者在一个类中定义一个方法作为构造函数。具有构造函数的类会在每次创建新对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作。
__destruct()，类的析构函数。析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。
__call()，在对象中调用一个不可访问方法时调用。
__callStatic()，用静态方式中调用一个不可访问方法时调用
__get()，获得一个类的成员变量时调用。读取不可访问（protected 或 private）或不存在的属性的值时，__get() 会被调用
__set()，设置一个类的成员变量时调用。在给不可访问（protected 或 private）或不存在的属性赋值时，__set() 会被调用。
__isset()，当对不可访问属性调用isset()或empty()时调用。当对不可访问（protected 或 private）或不存在的属性调用 isset() 或 empty() 时，__isset() 会被调用。
__unset()，当对不可访问属性调用unset()时被调用。当对不可访问（protected 或 private）或不存在的属性调用 unset() 时，__unset() 会被调用。
__sleep()，执行serialize()时，先会调用这个函数。 __sleep() 方法常用于提交未提交的数据，或类似的清理操作。
__wakeup()，执行unserialize()时，先会调用这个函数。 __wakeup() 经常用在反序列化操作中，例如重新建立数据库连接，或执行其它初始化操作。
__toString()，类被当成字符串时的回应方法
__invoke()，调用函数的方式调用一个对象时的回应方法
__set_state()，调用var_export()导出类时，此静态方法会被调用。
__clone()，当对象复制完成时调用
__autoload()，尝试加载未定义的类
__debugInfo()，打印所需调试信息

参考文章： PHP: 魔术方法 - Manual

PHP常见题

Tue, 20 Feb 2024 20:46:01 +0800

PHP常见题

1. 什么事面向对象？主要特征是什么？

面向对象是程序的一种设计方式，它利于提高程序的重用性，使程序结构更加清晰。主要特征：封装、继承、多态。

2. SESSION 与 COOKIE的区别是什么，请从协议，产生的原因与作用说明?

A、http无状态协议，不能区分用户是否是从同一个网站上来的，同一个用户请求不同的页面不能看做是同一个用户。

B、SESSION存储在服务器端，COOKIE保存在客户端。Session比较安全，cookie用某些手段可以修改，不安全。

Session依赖于cookie进行传递。禁用cookie后，session不能正常使用。

Session的缺点：保存在服务器端，每次读取都从服务器进行读取，对服务器有资源消耗。Session保存在服务器端的文件或数据库中，默认保存在文件中，文件路径由php配置文件的session.save_path指定。Session文件是公有的。

3. HTTP 状态中302、403、 500代码含义？

一二三四五原则:（即一：消息系列；二：成功系列；三：重定向系列；四：请求错误系列；五：服务器端错误系列。）
302:临时转移成功，请求的内容已转移到新位置
403:禁止访问
500:服务器内部错误 401：代表未授权。

4. 请写出数据类型(int char varchar datetime text)的意思；请问 varchar 和 char有什么区别？

Int 整数char 定长字符 Varchar 变长字符 Datetime 日期时间型Text 文本型 Varchar与char的区别 char是固定长度的字符类型，分配多少空间，就占用多长空间。Varchar是可变长度的字符类型，内容有多大就占用多大的空间，能有效节省空间。由于varchar类型是可变的，所以在数据长度改变的时，服务器要进行额外的操作，所以效率比char类型低。

5. MyISAM和 InnoDB 的基本区别？索引结构如何实现？

A、MyISAM类型不支持事务，表锁，易产生碎片，要经常优化，读写速度较快，适合用于频繁查询的应用；
B、InnoDB类型支持事务，行锁，有崩溃恢复能力，读写速度比MyISAM慢，适合于插入和更新操作比较多的应用，空间占用大，不支持全文索引等。创建索引：alert table tablename add index 索引名 (字段名)

6. isset() 和 empty() 区别

isset判断变量是否存在，可以传入多个变量，若其中一个变量不存在则返回假；empty判断变量是否为空为假，只可传一个变量，如果为空为假则返回真。

7. 请说明 PHP 中传值与传引用的区别。什么时候传值什么时候传引用？

按值传递：函数范围内对值的任何改变在函数外部都会被忽略按引用传递：函数范围内对值的任何改变在函数外部也能反映出这些修改优缺点：按值传递时，php必须复制值。特别是对于大型的字符串和对象来说，这将会是一个代价很大的操作。按引用传递则不需要复制值，对于性能提高很有好处。

8. 在PHP中error_reporting这个函数有什么作用？

设置PHP的报错级别并返回当前级别。

9. 现在编程中经常采取MVC三层结构，请问MVC分别指哪三层，有什么优点？

MVC三层分别指：业务模型、视图、控制器，由控制器层调用模型处理数据，然后将数据映射到视图层进行显示，优点是：①可以实现代码的重用性，避免产生代码冗余；②M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式

10. 在程序的开发中，如何提高程序的运行效率？

A、优化SQL语句，查询语句中尽量不使用select *，用哪个字段查哪个字段；少用子查询可用表连接代替；少用模糊查询；

PHP常用函数整理

Sun, 18 Feb 2024 20:46:01 +0800

PHP常用函数整理

字符串

strlen() 获取字符串长度。（一个汉字长度为3个字符，一个英文字母长度为1个字符）
strpos() 在字符串内查找一个字符或一段指定的文本，返回第一次出现的位置或者false
stripos() 同上，但不区分大小写
strrpos() 同上上，返回最后一次出现的位置或false
strripos() 同上，但不区分大小写
explode() 字符串打散为数组
implode() 数组拼接成字符串
strtoupper() 把字符串转换为大写
strtolower() 把字符串转换为大写
ucfirst() 把单词的首字母转换成大写
lcfirst() 把单词的首字母转换为小写
ucwords() 把字符串中每个单词的首字母转换为大写
str_replace 子字符串替换
str_ireplace str_replace 的忽略大小写版本
strrev 反转字符串
trim 去除字符串首尾处的空白字符（或者其他字符）
rtrim 删除字符串末端的空白字符（或者其他字符）
substr 截取字符串的一部分，返回字符串的子串
substr 截取字符串的一部分（中文，需要安装扩展mbstring），返回字符串的子串

更多请参考官方文档

数组

array() 创建数组
count() 返回数组中元素的数量 sizeof() 同样效果
array_push() 将一个或多个单元压入数组的末尾（入栈）
array_pop() 弹出数组最后一个单元（出栈）
array_unshift() 在数组开头插入一个或多个单元
array_shift() 将数组开头的单元移出数组
shuffle() 打乱数组
reset — 将数组的内部指针指向第一个单元
end — 将数组的内部指针指向最后一个单元
current — 返回数组中的当前值

一些PHP基础的简单整理

Sun, 18 Feb 2024 20:46:01 +0800

一些PHP基础的简单整理

常量

关于常量定义

1<?php
2$a = 1;
3define("AAA".$a,"AAA");
4echo constant("AAA".$a);

define() 在运行时定义一个常量。
constant() 返回一个常量的值。当你不知道常量名，却需要获取常量的值时，constant() 就很有用了。也就是说，常量名储存在一个变量里，或者由函数返回时。

const不能在条件语句中定义常量。 const用于类成员变量的定义，define()不可用于类成员变量的定义，可用于全局变量。
const可在类中使用，define不能。

常量和变量的区别
- 常量前面没有且不能有$符号
- 常量可以不用理会变量的作用域，在任何地方定义和使用
- 常量一旦定义就不能重新定义或取消定义
- 常量的值只能是标量（字符串、整数、浮点数、布尔值），支持数组
获取所有常量
get_defined_constants()
get_defined_constants(true)
get_defined_constants(true)[‘user’]
魔术常量：它的值随着它在代码中的位置改变而变化
- LINE 文件中的当前行号
- FILE 文件的完整路径和文件名，包含根目录
- DIR 文件所在目录
- FUNCTION 该函数被定义时的名字，区分大小写
- CLASS 该类被定义时的名字，区分大小写
- NAMESPANCE 命名空间
- METHOD 命名空间类名方法名
- TRAIT 当前使用的trait的名字

包含文件

include和require的区别 include和require除了错误处理的方式不同，其他方面都是相同的。
require生成一个致命错误（E_COMPILE_ERROR），在错误发生后脚本停止运行
include生成一个警告（E_WARNING）,在错误发生后脚本继续运行

面向对象(OO)

概念
- 面向对象是一种编程思想和方法，它将程序中的数据和操作数据的方法封装在一起，形成“对象”，并通过对象之间的交互和消息传递来完成程序的功能。
- 面向对象编程（OOP）强调数据的封装、继承、多态和动态绑定等特性，使得程序具有更好的可扩展性、可维护性和可重用性。
OOP特性
- 封装：指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装
- 继承：指可以创建一个新的类该类继承（extends）了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的复用。
- 多态：指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。在PHP中多态可通过实现接口（interface）和使用抽象类（abstract class）来实现。
类的访问控制
- public（公有）：公有的类成员可以在任何地方被调用。
- protected（受保护）：受保护的类成员可以被其自身以及其子类和父类访问。
- private（私有）：私有的类成员只能被其定义所在的类访问
构造方法 __construct
- 构造方法是一种特殊的方法，在创建一个新对象时，它会被自动调用
- 他可以用来 初始化 对象的属性或执行其他必要的操作
- 没有返回值
析构函数 __destruct
- 析构函数是一种特殊的方法，它在对象被销毁时自动调用
- 它可以用来执行一些清理操作，如释放资源或关闭连接
- 当对象不再被引用或脚本执行结束时，析构函数会被自动调用
final 关键字

PHP的 FPM 和 CLI

Sat, 17 Feb 2024 20:46:01 +0800

PHP的 FPM 和 CLI

PHP-FPM

PHP-FPM 即 PHP FastCGI 进程管理器。

要了解 PHP-FPM ，首先要看看 CGI 与 FastCGI 的关系。

CGI 的英文全名是 Common Gateway Interface，即通用网关接口，是 Web 服务器调用外部程序时所使用的一种服务端应用的规范。

早期的 Web 通信只是按照客户端请求将保存在 Web 服务器硬盘中的数据转发过去而已，这种情况下客户端每次获取的信息也是同样的内容（即静态请求，比如图片、样式文件、HTML文档），而随着 Web 的发展，Web 所能呈现的内容更加丰富，与用户的交互日益频繁，比如博客、论坛、电商网站、社交网络等。

这个时候仅仅通过静态资源已经无法满足 Web 通信的需求，所以引入 CGI 以便客户端请求能够触发 Web 服务器运行另一个外部程序，客户端所输入的数据也会传给这个外部程序，该程序运行结束后会将生成的 HTML 和其他数据通过 Web 服务器再返回给客户端（即动态请求，比如基于 PHP、Python、Java 实现的应用）。利用 CGI 可以针对用户请求动态返回给客户端各种各样动态变化的信息。

FastCGI 顾名思义，是 CGI 的升级版本，为了提升 CGI 的性能而生，CGI 针对每个 HTTP 请求都会 fork 一个新进程来进行处理（解析配置文件、初始化执行环境、处理请求），然后把这个进程处理完的结果通过 Web 服务器转发给用户，刚刚 fork 的新进程也随之退出，如果下次用户再请求动态资源，那么 Web 服务器又再次 fork 一个新进程，如此周而复始循环往复。
而 FastCGI 则会先 fork 一个 master 进程，解析配置文件，初始化执行环境，然后再 fork 多个 worker 进程（与 Nginx 有点像），当 HTTP 请求过来时，master 进程将其会传递给一个 worker 进程，然后立即可以接受下一个请求，这样就避免了重复的初始化操作，效率自然也就提高了。而且当 worker 进程不够用时，master 进程还可以根据配置预先启动几个 worker 进程等着；当空闲 worker 进程太多时，也会关掉一些，这样不仅提高了性能，还节约了系统资源。
这样一来，PHP-FPM 就好理解了，FastCGI 只是一个协议规范，需要每个语言具体去实现，PHP-FPM 就是 PHP 版本的 FastCGI 协议实现，有了它，就是实现 PHP 脚本与 Web 服务器（通常是 Nginx）之间的通信，同时它也是一个 PHP SAPI，从而构建起 PHP 解释器与 Web 服务器之间的桥梁。

PHP-FPM 负责管理一个进程池来处理来自 Web 服务器的 HTTP 动态请求，在 PHP-FPM 中，master 进程负责与 Web 服务器进行通信，接收 HTTP 请求，再将请求转发给 worker 进程进行处理，worker 进程主要负责动态执行 PHP 代码，处理完成后，将处理结果返回给 Web 服务器，再由 Web 服务器将结果发送给客户端。这就是 PHP-FPM 的基本工作原理。

PHP 8 新特性之枚举

Sun, 11 Jun 2023 13:46:01 +0800

PHP 8 新特性之枚举

枚举概览

枚举，或称 “Enum”，能够让开发者自定义类型为一系列可能的离散值中的一个。在定义领域模型中很有用，它能够“隔离无效状态”（making invalid states unrepresentable）。

枚举以各种不同功能的形式出现在诸多语言中。在 PHP 中，枚举是一种特殊类型的对象。Enum 本身是一个类（Class），它的各种条目（case）是这个类的单例对象，意味着也是个有效对象 —— 包括类型的检测，能用对象的地方，也可以用它。

最常见的枚举例子是内置的 boolean 类型，该枚举类型有两个有效值 true 和 false。 Enum 使开发者能够任意定义出用户自己的、足够健壮的枚举。

Enum 类似 class，它和 class、interface、trait 共享同样的命名空间。也能用同样的方式自动加载。一个 Enum 定义了一种新的类型，它有固定、数量有限、可能的合法值。示例 #1 用注解实现接口的可选方法

1<?php
2
3// 通过传入参数：待搜索的注解类名，可返回指定的注解类， 而不需要再到反射类中迭代循环获取所有注解。

示例

 1<?php
 2
 3<?php
 4// 声明新的枚举类型 Suit，仅有四个有效的值： Suit::Hearts、Suit::Diamonds、 Suit::Clubs、Suit::Spades。
 5enum Suit
 6{
 7 case Hearts;
 8 case Diamonds;
 9 case Clubs;
10 case Spades;
11}
12
13// 变量可以赋值为以上有效值里的其中一个。 函数可以检测枚举类型，这种情况下只能传入类型的值。
14function pick_a_card(Suit $suit)
15{
16 /* ... */
17}
18
19$val = Suit::Diamonds;
20
21// OK
22pick_a_card($val);
23
24// OK
25pick_a_card(Suit::Clubs);
26?>

所有的case都有一个只读的属性 name，它大小写敏感，是case自身的名称

PHP 8 新特性之注解

Sun, 11 Jun 2023 13:46:01 +0800

PHP 8 新特性之注解功能

注解概览

注解功能提供了代码中的声明部分都可以添加结构化、机器可读的元数据的能力，注解的目标可以是类、方法、函数、参数、属性、类常量。通过反射 API 可在运行时获取注解所定义的元数据。因此注解可以成为直接嵌入代码的配置式语言。

通过注解的使用，在应用中实现功能、使用功能可以相互解耦。某种程度上讲，它可以和接口（interface）与其实现（implementation）相比较。但接口与实现是代码相关的，注解则与声明额外信息和配置相关。接口可以通过类来实现，而注解也可以声明到方法、函数、参数、属性、类常量中。因此它们比接口更灵活。

注解使用的一个简单例子：将接口（interface）的可选方法改用注解实现。我们假设接口 ActionHandler 代表了应用的一个操作：部分 action handler 的实现需要 setup，部分不需要。我们可以使用注解，而不用要求所有类必须实现 ActionHandler 接口并实现 setUp() 方法。因此带来一个好处——可以多次使用注解。

示例 #1 用注解实现接口的可选方法

 1<?php
 2interface ActionHandler
 3{
 4 public function execute();
 5}
 6
 7#[Attribute]
 8class SetUp {}
 9
10class CopyFile implements ActionHandler
11{
12 public string $fileName;
13 public string $targetDirectory;
14
15 #[SetUp]
16 public function fileExists()
17 {
18 if (!file_exists($this->fileName)) {
19 throw new RuntimeException("File does not exist");
20 }
21 }
22
23 #[SetUp]
24 public function targetDirectoryExists()
25 {
26 if (!file_exists($this->targetDirectory)) {
27 mkdir($this->targetDirectory);
28 } elseif (!is_dir($this->targetDirectory)) {
29 throw new RuntimeException("Target directory $this->targetDirectory is not a directory");
30 }
31 }
32
33 public function execute()
34 {
35 copy($this->fileName, $this->targetDirectory . '/' . basename($this->fileName));
36 }
37}
38
39function executeAction(ActionHandler $actionHandler)
40{
41 $reflection = new ReflectionObject($actionHandler);
42
43 foreach ($reflection->getMethods() as $method) {
44 $attributes = $method->getAttributes(SetUp::class);
45
46 if (count($attributes) > 0) {
47 $methodName = $method->getName();
48
49 $actionHandler->$methodName();
50 }
51 }
52
53 $actionHandler->execute();
54}
55
56$copyAction = new CopyFile();
57$copyAction->fileName = "/tmp/foo.jpg";
58$copyAction->targetDirectory = "/home/user";
59
60executeAction($copyAction);

注解语法

首先，注解声明总是以 #[ 开头，以 ] 结尾来包围。

PHP 8 新特性

Thu, 11 May 2023 13:46:01 +0800

PHP 8 新特性

命名参数（8.0）

新增命名参数的功能:

在函数或方法调用时，可通过参数名来指定参数的值，而不仅仅依赖参数的位置

从 PHP 8.0.0 开始，函数参数列表可以包含一个尾部的逗号，这个逗号将被忽略。这在参数列表较长或包含较长的变量名的情况下特别有用，这样可以方便地垂直列出参数。

 1<?php
 2function takes_many_args(
 3 $first_arg,
 4 $second_arg,
 5 $again = 'a default string', // 在 8.0.0 之前，这个尾部的逗号是不允许的。
 6){
 7 // ...
 8}
 9z
10takes_many_args(1, 2); //按照参数顺序传参
11takes_many_args(first_arg:1, second_arg:2); //指定参数，不分顺序
12
13// 类也可以使用命名参数，假设Demo类构造函数有$first_arg，$second_arg,两个参数，有takes_many_args方法
14$demo = new Demo(first_arg:1, second_arg:2); 
15$demo->takes_many_args(first_arg:1, second_arg:2);
16
17// 不能用位置的参数和命名的参数一起
18// 可选参数必须在必选参数后面 例如上面的$again
19?>

注解（Attributes）（8.0）

新增注解的功能。此篇单独介绍

构造器属性提升（Constructor Property Promotion）（8.0）

新增构造器属性提升功能在构造函数中声明类的属性）。

构造器的参数也可以相应提升为类的属性。构造器的参数赋值给类属性的行为很普遍，否则无法操作。而构造器提升的功能则为这种场景提供了便利。

 1<?php
 2class Point {
 3 protected int $x;
 4 protected int $y;
 5
 6 public function __construct(int $x, int $y = 0) {
 7 $this->x = $x;
 8 $this->y = $y;
 9 }
10}
11
12// 两个参数都传入
13$p1 = new Point(4, 5);
14// 仅传入必填的参数。 $y 会默认取值 0。
15$p2 = new Point(4);
16// 使用命名参数（PHP 8.0 起）:
17$p3 = new Point(y: 5, x: 4);
18
19// 上面的例子可以用以下方式重写：
20class Point {
21 public function __construct(protected int $x, protected int $y = 0) {
22 }
23}

联合类型（8.0）

新增联合类型。

PHP8新特性之match表达式

Tue, 14 Mar 2023 20:46:01 +0800

PHP8 alpha2发布了，最近引入了一个新的关键字：match, 这个关键字的作用跟switch有点类似。

虽然我一般对语法糖无感，但这个我觉得还是有点意思，match这个词也挺好看，那么它是干啥的呢？

在以前我们可能会经常使用switch做值转换类的工作，类似:

 1 switch ($input) {
 2     case "true":
 3         $result = 1;
 4     break;
 5     case "false":
 6         $result = 0;
 7     break;
 8     case "null":
 9         $result = NULL;
10     break;
11 }

(当然，有的同学会说，谁会这么写，用个数组转换不行么？拜托，这是举例啊，数组也只能数字键和整数啊，万一key是需要其他表达式呢，万一你要多个key对应一个值呢，对吧？)

那么如果使用match关键字呢，可以变成类似:

1$result = match($input) {
2         "true" => 1,
3         "false" => 0,
4         "null" => NULL,
5};

相比switch， match会直接返回值，可以直接赋值给$result了。

并且，类似switch的多个case一个block一样，match的多个条件也可以写在一起，比如:

1 $result = match($input) {
2     "true", "on" => 1,
3     "false", "off" => 0,
4     "null", "empty", "NaN" => NULL,
5};

需要注意的和switch不太一样的是，以前我们用switch可能会经常遇到这种诡异的问题:

1 $input = "2 person";
2 switch ($input) {
3     case 2:
4         echo "bad";
5     break;
6}

你会发现，bad竟然被输出了，这是因为switch使用了宽松比较(==)。match就不会有这个问题了, 它使用的是严格比较(===)，就是值和类型都要完全相等。

还有就是，当input并不能被match中的所有条件满足的时候，match会抛出一个UnhandledMatchError exception:

1 $input = "false";
2 $result = match($input) {
3         "true" => 1,
4 };

会得到:

Fatal error: Uncaught UnhandledMatchError: Unhandled match value of type string

这样就不用担心万一match条件没写全导致了不可预知的错误。

另外还是要说明，match是关键字，也就是从PHP8开始它不能出现在namespace或者类名中，如果你的项目中有用match作为类名的:

常用算法的PHP实现

Sun, 12 Mar 2023 22:46:01 +0800

常用算法的PHP实现

1. 快速排序 (Quick Sort)

 1<?php
 2function quickSort($arr) {
 3 if (count($arr) <= 1) {
 4 return $arr;
 5 }
 6 
 7 $pivot = $arr[0];
 8 $left = $right = [];
 9 
10 for ($i = 1; $i < count($arr); $i++) {
11 if ($arr[$i] < $pivot) {
12 $left[] = $arr[$i];
13 } else {
14 $right[] = $arr[$i];
15 }
16 }
17 
18 return array_merge(quickSort($left), [$pivot], quickSort($right));
19}
20
21// 测试
22$numbers = [64, 34, 25, 12, 22, 11, 90];
23echo "原始数组: " . implode(', ', $numbers) . "\n";
24echo "快速排序: " . implode(', ', quickSort($numbers)) . "\n";
25?>

2. 二分查找 (Binary Search)

 1<?php
 2function binarySearch($arr, $target) {
 3 $left = 0;
 4 $right = count($arr) - 1;
 5 
 6 while ($left <= $right) {
 7 $mid = floor(($left + $right) / 2);
 8 
 9 if ($arr[$mid] == $target) {
10 return $mid; // 找到目标，返回索引
11 }
12 
13 if ($arr[$mid] < $target) {
14 $left = $mid + 1;
15 } else {
16 $right = $mid - 1;
17 }
18 }
19 
20 return -1; // 未找到
21}
22
23// 测试（数组必须已排序）
24$sortedArray = [2, 5, 8, 12, 16, 23, 38, 45, 67];
25$target = 23;
26$result = binarySearch($sortedArray, $target);
27
28echo "在数组 [" . implode(', ', $sortedArray) . "] 中查找 $target\n";
29echo "结果索引: " . ($result !== -1 ? $result : "未找到") . "\n";
30?>

3. 斐波那契数列 (Fibonacci)

 1<?php
 2// 递归版本（简单但效率低）
 3function fibonacciRecursive($n) {
 4 if ($n <= 1) {
 5 return $n;
 6 }
 7 return fibonacciRecursive($n - 1) + fibonacciRecursive($n - 2);
 8}
 9
10// 动态规划版本（高效）
11function fibonacciDP($n) {
12 if ($n <= 1) {
13 return $n;
14 }
15 
16 $dp = [0, 1];
17 for ($i = 2; $i <= $n; $i++) {
18 $dp[$i] = $dp[$i - 1] + $dp[$i - 2];
19 }
20 
21 return $dp[$n];
22}
23
24// 测试
25$n = 10;
26echo "斐波那契数列前{$n}项:\n";
27for ($i = 0; $i < $n; $i++) {
28 echo fibonacciDP($i) . " ";
29}
30echo "\n";
31?>

4. 广度优先搜索 (BFS)

 1<?php
 2function bfs($graph, $start) {
 3 $visited = [];
 4 $queue = new SplQueue();
 5 
 6 $visited[$start] = true;
 7 $queue->enqueue($start);
 8 $result = [];
 9 
10 while (!$queue->isEmpty()) {
11 $vertex = $queue->dequeue();
12 $result[] = $vertex;
13 
14 foreach ($graph[$vertex] as $neighbor) {
15 if (!isset($visited[$neighbor])) {
16 $visited[$neighbor] = true;
17 $queue->enqueue($neighbor);
18 }
19 }
20 }
21 
22 return $result;
23}
24
25// 测试
26$graph = [
27 'A' => ['B', 'C'],
28 'B' => ['A', 'D', 'E'],
29 'C' => ['A', 'F'],
30 'D' => ['B'],
31 'E' => ['B', 'F'],
32 'F' => ['C', 'E']
33];
34
35echo "BFS遍历结果: " . implode(' -> ', bfs($graph, 'A')) . "\n";
36?>

5. 冒泡排序 (Bubble Sort)

 1<?php
 2function bubbleSort($arr) {
 3 $n = count($arr);
 4 
 5 for ($i = 0; $i < $n - 1; $i++) {
 6 $swapped = false;
 7 
 8 for ($j = 0; $j < $n - $i - 1; $j++) {
 9 if ($arr[$j] > $arr[$j + 1]) {
10 // 交换元素
11 $temp = $arr[$j];
12 $arr[$j] = $arr[$j + 1];
13 $arr[$j + 1] = $temp;
14 $swapped = true;
15 }
16 }
17 
18 // 如果没有交换，说明已经排序完成
19 if (!$swapped) {
20 break;
21 }
22 }
23 
24 return $arr;
25}
26
27// 测试
28$numbers = [64, 34, 25, 12, 22, 11, 90];
29echo "冒泡排序: " . implode(', ', bubbleSort($numbers)) . "\n";
30?>

6. 查找最大子数组和 (Kadane算法)

 1<?php
 2function maxSubArraySum($arr) {
 3 $maxSoFar = $arr[0];
 4 $maxEndingHere = $arr[0];
 5 
 6 for ($i = 1; $i < count($arr); $i++) {
 7 $maxEndingHere = max($arr[$i], $maxEndingHere + $arr[$i]);
 8 $maxSoFar = max($maxSoFar, $maxEndingHere);
 9 }
10 
11 return $maxSoFar;
12}
13
14// 测试
15$array = [-2, 1, -3, 4, -1, 2, 1, -5, 4];
16echo "数组: " . implode(', ', $array) . "\n";
17echo "最大子数组和: " . maxSubArraySum($array) . "\n"; // 输出: 6
18?>

7. 判断素数

 1<?php
 2function isPrime($n) {
 3 if ($n <= 1) return false;
 4 if ($n <= 3) return true;
 5 if ($n % 2 == 0 || $n % 3 == 0) return false;
 6 
 7 for ($i = 5; $i * $i <= $n; $i += 6) {
 8 if ($n % $i == 0 || $n % ($i + 2) == 0) {
 9 return false;
10 }
11 }
12 
13 return true;
14}
15
16// 测试
17$numbers = [2, 3, 4, 17, 25, 29];
18foreach ($numbers as $num) {
19 echo "$num 是" . (isPrime($num) ? "素数" : "非素数") . "\n";
20}
21?>

php-msf-docker

Sat, 11 Mar 2023 11:46:01 +0800

php-msf-docker

基于centos:centos7.9.2009镜像制作的php开发环境镜像

主要包含：

PHP-8.1.14
redis-5.3.7
swoole-src-5.0.2
nginx-1.21.5
supervisor
sshd

GitHub地址 : https://hub.docker.com/r/leanku/php-msf-docker

DockerHub地址 : https://hub.docker.com/r/leanku/php-msf-docker

包含扩展

1bcmath,Core,ctype,curl,date,dom,exif,fileinfo,filter,ftp,gd,gettext,hash,iconv,intl,json,libxml,mbstring,mysqli,mysqlnd,openssl,pcntl,pcre,PDO,pdo_mysql,pdo_pgsql,pdo_sqlite,pgsql,Phar,posix,redis,Reflection,session,shmop,SimpleXML,soap,sockets,sodium,SPL,sqlite3,standard,sysvsem,tokenizer,xml,xmlreader,xmlwriter,xsl,zip,zlib,swoole

运行示例

docker run --privileged --restart=always -it -d \
--hostname=php-msf --name=php-msf-docker \
-p 22:22 -p 80:80 -p 3306:3306 -p 8000:8000 -p 9501:9501 \
-v /c/docker/www:/php-msf/data/www \
leanku/php-msf-docker

SSH

默认用户：super 密码：123456

1ssh super@127.0.0.1

PHP位运算使用

Tue, 28 Feb 2023 22:33:45 +0800

PHP 位运算介绍

位运算符允许对整型数中指定的位进行求值和操作。以下是官网的一个介绍。

例子	名称	结果
$a & $b	And（按位与）	将把 $a 和 $b 中都为 1 的位设为 1。
$a \| $b	Or（按位或）	将把 $a 和 $b 中任何一个为 1 的位设为 1。
$a ^ $b	Xor（按位异或）	将把 $a 和 $b 中一个为 1 另一个为 0 的位设为 1。
~ $a	Not（按位取反）	将 $a 中为 0 的位设为 1，反之亦然。
$a « $b	Shift left（左移）	将 $a 中的位向左移动 $b 次（每一次移动都表示 “乘以 2”）。
$a » $b	Shift right（右移）	将 $a 中的位向右移动 $b 次（每一次移动都表示 “除以 2”）。
详情请点击这里了解。

平常开发需要用位运算吗？

位运算符都是针对整数的二进制数字形式而进行的。
我们都知道计算机中运算使用的是二进制，在我的电脑,整数有4个字节(byte),而1个字节有8位(bit)，一个整数有32位二进制来表示。

PHP标准输入与输出

Wed, 11 Jan 2023 00:00:00 +0000

PHP标准输入与输出

一、PHP STDIN、STDOUT、STDERR简介:

STDIN、STDOUT、STDERR命令输入输出流，用于向控制台(linux shell终端、windows cmd终端)输入、输出内容，它们默认是已经打开的，可以直接对他们进行读写操作，它们只能在CLI(command-line interface，命令行界面)模式中使用，在Http模式时，它们是未定义的。

而他们的打开副本php://stdin、php://stdout、php://stderr 也无法输出内容到http浏览器，经测试：写入php://stderr的内容将会输入到默认站点的错误日志中，其它两种无任何效果。

STDIN/STDOUT/STDERR简介：原始流流打开副本描述STDINphp://stdin标准输入(standard input)，只读，用于从控制台输入内容；

STDOUTphp://stdout标准输出(standard output)，只写，用于向控制台输出正常信息；

STDERRphp://stderr错误输出(standard error)，只写，用于向控制台输出错误信息；

官方推荐使用常量 STDIN、 STDOUT 和 STDERR 来代替它们手动打开的副本封装器php://stdin、 php://stdout 和 php://stderr。

二、PHP STDIN用法：

PHP语言中"STDIN"用于从控制台读取内容，遇到此常量或者通过fopen()函数打开php://stdin脚本将会等待用户输入内容，直到用户按下回车键提交。

新建文件demo.php

 1<?php
 2
 3echo "请输入内容:";
 4$input = fgets(STDIN);
 5echo sprintf("输入的内容为: %s\n", $input);
 6
 7$handle = fopen('php://stdin', 'r');
 8echo "请输入: ";
 9$stdin = fread($handle, 10); //最多读取10个字符
10echo sprintf("输入为: %s\n", $stdin);
11fclose($handle);
12
13//php demo.php 运行代码，键盘输入123，输出结果如下
14
15//请输入内容:123
16//输入的内容为: 123
17
18//请输入: 456
19//输入为: 456

三、PHP STDOUT用法：

PHP语言中STDOUT用于向控制台输出标准信息；向此常量、或者向fopen()函数打开的php://stdout写入的内容将直接输出到控制台的标准输出；标准输出的内容可以用过">“或者"1>“重定向到指定地方，比如文件。

 1<?php
 2
 3fwrite(STDOUT, "STDOUT写入的正常输出；\n");
 4
 5$stdout = fopen("php://stdout", "w");
 6
 7fwrite($stdout, "php://stdout写入的正常输出；\n");
 8
 9fclose($stdout);
10
11// php demo.php >stdout.txt
12//stdout.txt文件类容如下
13//STDOUT写入的正常输出；
14//php://stdout写入的正常输出；

四、PHP STDERR用法：

PHP语言中"STDERR"用于向控制台输出错误信息；向常量、或者向fopen()函数打开的"php://stderr"写入的内容将直接输出到控制台的错误输出；错误输出的内容可以用过"2>“重定向到指定地方，比如文件；也可以使用"2>&1"将错误输出定向到标准输出，与标准输出合并。

# Carbon（nesbot/carbon）-- PHP 日期时间利器化

Tue, 15 Nov 2022 00:00:00 +0000

Carbon（nesbot/carbon）– PHP 日期时间利器化

一、Carbon介绍

Carbon 是 PHP 中最流行的日期时间处理库，基于 PHP 原生的 DateTime 类封装，提供链式操作、易读 API、时区支持等强大功能。

特点：

链式调用，语义化强
支持日期时间加减、比较、格式化
支持中文等多语言友好显示
可与 Laravel、Hyperf 等框架无缝集成

官方文档：https://carbon.nesbot.com/docs/

安装：composer require nesbot/carbon

二、基本使用

2.1 获取当前时间

1$now = Carbon::now(); // 当前时间，默认系统时区
2echo $now; // 2023-09-28 15:30:12
3
4// 指定时区：
5$nowShanghai = Carbon::now('Asia/Shanghai');

2.2 日期创建

1$dt1 = Carbon::create(2023, 9, 28, 15, 30, 0); // 年, 月, 日, 时, 分, 秒
2$dt2 = Carbon::parse('2023-12-31 23:59:59');
3$dt3 = Carbon::today(); // 当天 0:00:00
4$dt4 = Carbon::tomorrow(); // 明天 0:00:00
5$dt5 = Carbon::yesterday(); // 昨天 0:00:00

2.3 日期格式化

1$now = Carbon::now();
2echo $now->toDateString(); // 2023-09-28
3echo $now->toTimeString(); // 15:30:12
4echo $now->toDateTimeString();// 2023-09-28 15:30:12
5echo $now->format('Y-m-d H:i'); // 自定义格式

2.4 日期加减操作

1$dt = Carbon::now();
2
3echo $dt->addDays(3); // 当前时间 +3天
4echo $dt->subHours(5); // 当前时间 -5小时
5echo $dt->addMonthsNoOverflow(1); // 避免月份溢出

2.5 日期比较

1$dt1 = Carbon::parse('2023-09-28');
2$dt2 = Carbon::parse('2023-10-01');
3
4if ($dt1->lt($dt2)) {
5 echo "dt1 小于 dt2";
6}
7
8echo $dt1->diffInDays($dt2); // 返回天数差
9echo $dt1->diffForHumans($dt2); // 语义化描述: "3 days before"

2.6 时区转换

1$dt = Carbon::now('UTC');
2$dtShanghai = $dt->copy()->setTimezone('Asia/Shanghai');
3echo $dtShanghai;

2.7 本地化输出

1Carbon::setLocale('zh'); // 设置中文
2
3$dt1 = Carbon::now();
4$dt2 = Carbon::parse('2025-10-01');
5
6echo $dt1->diffForHumans($dt2); // 输出: 3 天前 / 3 天后

2.8 链式操作

1$dt = Carbon::now()->addDays(5)->subHours(3)->format('Y-m-d H:i:s');
2echo $dt;

三、Carbon 高级使用技巧合集

3.1 时间区间判断

判断某个时间是否在区间内

1use Carbon\Carbon;
2
3$start = Carbon::parse('2023-09-01');
4$end = Carbon::parse('2023-09-30');
5$check = Carbon::parse('2023-09-15');
6
7if ($check->between($start, $end)) {
8 echo "时间在区间内";
9}

between($start, $end, $equal = true)

composer

Tue, 15 Nov 2022 00:00:00 +0000

composer

Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。

一、Composer 基础概念

Composer 是 PHP 的依赖管理工具，它通过定义项目所需的依赖包及版本，自动安装和管理这些依赖，确保项目在不同环境下都能稳定运行。其核心概念主要包括以下几个方面：

1.1 包（Package）

包是 Composer 管理的基本单元，它可以是一个 PHP 类库、框架组件，或是某个功能模块。比如用于 HTTP 请求处理的 Guzzle，以及知名的 PHP 框架 Laravel、Symfony 等，都可以看作是 Composer 包。这些包被发布在 Packagist 等包仓库中，方便开发者获取使用。

1.2 composer.json 与 composer.lock

composer.json是项目的依赖配置文件，开发者在其中定义项目所需的依赖包及其版本约束。例如，若要在项目中使用 PHPUnit 进行单元测试，可在composer.json添加 “phpunit/phpunit”: “^9.5” ，表示使用 PHPUnit 9.5 及以上版本，但低于 10.0 版本。

composer.lock则是锁定依赖包具体版本的文件。当执行composer install或composer update时，Composer 会将实际安装的依赖包版本记录在composer.lock中。下次在其他环境安装依赖时，该文件能确保安装的依赖包版本与之前完全一致，避免因版本差异导致项目出现兼容性问题。

1.3 包仓库（Repository）

包仓库是存储 Composer 包的地方，默认情况下，Composer 使用 Packagist 作为官方包仓库，它汇聚了海量的 PHP 开源包。除了 Packagist，开发者还可以搭建私有包仓库，用于管理内部开发的私有包，或者使用其他公共仓库，拓展包的来源。 packagist仓库地址

二、安装composer

#下载安装脚本 － composer-setup.php － 到当前目录。
php -r "copy('https://install.phpcomposer.com/installer', 'composer-setup.php');"

#执行安装过程。
php composer-setup.php

#删除安装脚本。
php -r "unlink('composer-setup.php');"

#全局安装
sudo mv composer.phar /usr/local/bin/composer

#启用本镜像服务
composer config -g repo.packagist composer https://packagist.phpcomposer.com

三、 Composer常用命令与操作

3.1 初始化项目

在新建 PHP 项目时，首先需要初始化 Composer。在项目根目录下打开命令行，执行composer init命令，此时会进入交互式配置界面，系统会依次询问项目名称、描述、作者、许可证等信息。完成信息填写后，会在项目根目录生成composer.json文件。如果不想进行交互式配置，也可以使用composer init -n命令，采用默认配置快速生成composer.json文件。

Composer 自动加载原理

Tue, 15 Nov 2022 00:00:00 +0000

Composer 自动加载原理

Composer 的自动加载本质是动态加载类文件，它实现了“按需加载”的机制，避免了手动 require 每个类文件。

一、Composer 自动加载的核心

PHP 提供了 spl_autoload_register() 函数：

1spl_autoload_register(function ($class) {
2 require 'src/' . str_replace('\\', '/', $class) . '.php';
3});

当你第一次使用一个类时，PHP 会调用这个函数。
$class 是你使用的类全名（包括命名空间）。
函数里通过规则找到对应文件并 require。

Composer 自动加载，就是在这个基础上做了规范化管理。

二、Composer 生成的自动加载文件

安装依赖后，Composer 会生成：

1vendor/autoload.php
2vendor/composer/autoload_*.php

vendor/autoload.php：入口文件，只需 require 一次。
vendor/composer/autoload_psr4.php：记录 PSR-4 命名空间 → 文件路径映射。
vendor/composer/autoload_classmap.php：记录类名 → 文件路径，用于 classmap 加速加载。
vendor/composer/autoload_files.php：记录需要立即加载的文件（如全局函数库）。

vendor/autoload.php 的核心逻辑：

1require __DIR__ . '/composer/autoload_real.php';
2return ComposerAutoloaderInit::getLoader();

ComposerAutoloaderInit::getLoader() 会：

初始化一个 ClassLoader 实例。
根据配置注册 PSR-4、PSR-0、classmap、files 自动加载函数到 PHP。
调用 spl_autoload_register() 注册这些函数。

三、PSR-4 自动加载机制

PSR-4 是 Composer 默认的推荐机制。假设 composer.json 配置：

Guzzle

Tue, 15 Nov 2022 00:00:00 +0000

Guzzle HTTP 客户端全解析及 PHP 使用与优化

一、介绍

Guzzle 是 PHP 世界中最流行的 HTTP 客户端库之一，用于发送 HTTP/HTTPS 请求并处理响应。

它支持：

同步和异步请求
HTTP/2
中间件机制（类似 Laravel / Hyperf 的管道）
并发请求
请求重试、超时、连接池

Guzzle 常被用于调用第三方 API、微服务接口或爬取网页数据。

官方文档：https://docs.guzzlephp.org

二、安装

1composer require guzzlehttp/guzzle

三、基本使用

3.1 同步 GET 请求

 1use GuzzleHttp\Client;
 2
 3$client = new Client([
 4 'base_uri' => 'https://api.example.com',
 5 'timeout' => 5.0, // 超时时间
 6]);
 7
 8$response = $client->get('/users/1');
 9
10echo $response->getStatusCode(); // 200
11echo $response->getBody(); // JSON 或 HTML

3.2 POST 请求与 JSON 数据

1$response = $client->post('/users', [
2 'json' => [
3 'name' => 'John',
4 'email' => 'john@example.com',
5 ],
6]);
7
8$data = json_decode($response->getBody(), true);
9print_r($data);

3.3 添加请求头

1$response = $client->get('/users', [
2 'headers' => [
3 'Authorization' => 'Bearer ' . $token,
4 'Accept' => 'application/json',
5 ],
6]);

四、异步请求与并发

Guzzle 支持异步请求，通过 Promises 机制提高并发性能。

PHP on Leanku 的博客

PHPUnit使用指南

PHPUnit 使用指南

一、介绍

二、安装 PHPUnit

1. 安装 PHPUnit（可以通过 composer require --dev phpunit/phpunit 安装）

2. 配置PhpStorm 运行 PHPUnit（Docker环境为例）

2.1. 配置 Docker 远程解释器

2.2 配置 PHPUnit

PHP8新特性：JIT

PHP8新特性：JIT（Just-In-Time）

一、JIT（Just-In-Time）编译技术概述

1.1 什么是JIT编译

1.2 PHP执行模式的演进

1.3 JIT带来的性能提升

二、PHP JIT工作原理

2.1 PHP脚本执行流程

2.2 JIT编译流程

2.3 JIT与OPCache的关系

三、PHP JIT配置与使用

3.1 启用JIT

PHP底层原理与性能优化深度解析

PHP底层原理与性能优化深度解析

一、PHP生命周期与SAPI

1.1 PHP生命周期概述

1.2 SAPI (Server API)

二、OPCache原理与优化

2.1 PHP脚本执行流程

PHP 实现 Redis 高并发解决方案

PHP 实现 Redis 高并发解决方案

一、缓存加速实现

1. 基本缓存操作

2. 防止缓存穿透

二、 分布式锁实现

1. 基本分布式锁

2. 可重入锁实现

三、队列实现

1. 简单队列

2. 延迟队列

3. Pub/Sub 模式

四、综合应用示例 - 秒杀系统

五、最佳实践建议

1. 连接管理：使用连接池或持久连接

2. 错误处理：添加重试机制

3. 性能优化：使用管道(pipeline)

4. Lua脚本：保证原子性

内存溢出

内存溢出

一、什么是内存溢出

二、如何排查内存溢出？

1. 查看错误日志

2. 使用内存分析工具

线程安全

内存溢出

1. PHP解释器的线程安全（Zend线程安全，ZTS）

2. 应用代码的并发安全：Swoole常驻内存下的挑战

典型问题场景：

如何保证Swoole下的并发安全？

方案一：使用原子计数器（Atomic）

方案二：使用锁（Lock）

方案三：利用协程的Channel

PHP中的设计模式

PHP中的设计模式

介绍

分类

按照目的分，目前常见的设计模式主要有23种，根据使用目标的不同可以分为以下三大类：

结构设计模式（Structural Patterns）(7种)：用于继承和接口时的设计模式。结构设计模式用于新类的函数方法设计，减少不必要的类定义，减少代码的冗余。

行为模式（Behavioral Patterns）(11种)：用于方法实现以及对应算法的设计模式，同时也是最复杂的设计模式。行为设计模式不仅仅用于定义类的函数行为，同时也用于不同类之间的协议、通信。

按照范围分为：类的设计模式，以及对象设计模式

设计模式原则

设计模式实现

1. Singleton(单例模式)

2. Factory(工厂模式)

PHP面向对象

PHP面向对象

特性

类与对象

类定义

PHP魔术方法

PHP魔术方法

1. 安装 PHPUnit（可以通过 `composer require --dev phpunit/phpunit` 安装）

二、分布式锁实现