当今最强大的PHP技巧，让你成为编程巨匠

当今最强大的PHP技巧，让你成为编程巨匠

PHP 简单介绍

1、语言介绍

标题	描述
Web开发	PHP在Web开发领域非常强大。它具有丰富的内置函数和库，使得开发Web应用程序变得高效和简单。PHP可以轻松处理表单处理、数据验证和数据库操作等任务，并与各种数据库系统（如MySQL）无缝集成。
快速开发	HP的语法简单易学，开发速度相对较快。它提供了丰富的框架和工具，如Laravel、Symfony和CodeIgniter等，可以加快应用程序的开发过程。
社区支持	PHP拥有庞大的开发者社区，提供丰富的文档、教程和资源。这使得开发者能够轻松获取支持和解决问题，共享经验和知识。
特色	它拥有良好的扩展性和可维护性，可以通过面向对象编程和模块化设计来构建可扩展的应用程序。开源的，可以免费使用和分发。这使得它成为许多开发者和组织的首选语言之一。
缺点	PHP是解释执行的语言，每次请求都需要解析和执行代码。尽管PHP在性能方面有所改进，但在处理大量并发请求或高负载情况下可能表现不佳。

2、运行模式

名称	介绍
CLI模式	CLI模式是在命令行终端中直接运行PHP脚本的模式。它适用于编写命令行脚本、系统管理任务和工具开发等场景。
Web服务器模式	PHP最常见的用途是在Web服务器上运行，处理来自Web浏览器的HTTP请求。在这种模式下，PHP脚本通过Web服务器（如Apache、Nginx）与浏览器进行交互，生成并返回动态的Web页面。
CGI模式	CGI模式是一种通过Web服务器将HTTP请求传递给PHP解释器的方式。在这种模式下，PHP解释器作为独立的进程执行，并将结果返回给Web服务器，再由Web服务器传递给浏览器。
FastCGI模式	FastCGI是一种改进的CGI模式，通过保持PHP解释器进程的持久性来提高性能。在FastCGI模式下，PHP解释器作为一个独立的后台进程运行，并通过与Web服务器之间的通信管道处理HTTP请求。
模块模式	在某些Web服务器（如Apache）中，PHP可以作为一个模块（例如mod_php）嵌入到Web服务器中。在这种模式下，PHP解释器与Web服务器共享同一个进程空间，提供更快的性能和更好的集成。

详细模式使用方法可以参考官方文档:PHP: PHP 手册 - Manual

3、运行环境搭建及IDE推荐

3.1 PHP&Mysql 版本推荐：8.0 +

3.2 运行服务器环境选: Apache 或者 Nginx

• 如果您需要一个成熟稳定、功能丰富且具有广泛扩展性的Web服务器，以及良好的.htaccess支持，那么Apache可能是更合适的选择。
• 如果您关注高性能、低内存消耗和高度可扩展性，并且对简洁易懂的配置语法有需求，那么Nginx可能是更适合的选择。

3.3 集成环境选择

名称	适配系统	官网
Wamp	Windows	www.wampserver.com
Mamp	Macos	www.mamp.info
Lamp	Linux	具体需要根据Linux系统查找
Xampp	Win/Macos	www.apachefriends.org

PHP基础知识

1、标记风格

推荐使用

这 是一种短标记风格，用于在PHP中嵌入代码块。它是一种较早期的标记风格，但在一些PHP配置中可能被禁用或不推荐使用。

2、分号、空白、换行符

在PHP中分号“ ；”用作语句的结束符号。每个语句应该以分号结尾，以表示语句的结束。

空白和换行符（包括空格、制表符和换行符）通常被解释器忽略，因此它们在大多数情况下对代码的执行没有直接影响。

提示: 通过在适当的位置使用空白和换行符，可以使代码更易于阅读和理解，并且有助于代码的组织和格式化。

3、注释

//............ 单行注释

#.............. 单行注释

/*..................*/ 多行注释

4、内容输出

1. echo语句：echo是PHP中最常用的输出方法之一，用于将内容输出到浏览器或命令行。

   `echo "Hello Php！";`
   

2. print语句：print是另一种常见的输出方法，与echo类似，用于将内容输出到浏览器或命令行。

   print "Hello Php！";
   

3. print_r函数：print_r函数用于打印复杂数据类型（如数组、对象）的可读性较好的表示形式。

   $demoArr = ['apple','banana','orange];
   print_r($demoArr);
   

4. var_dump函数：var_dump函数用于打印变量的详细信息，包括数据类型和值。

   $name = "John_lee";
   var_dump($name);
   

5. printf函数：printf函数用于格式化输出字符串，可以根据指定的格式打印变量的值。

   $number = 42;
   printf("The answer is %d", $number);
   

   5.1 常用的占位符:

   占位符	说明
   %d	带符号的十进制数
   %u	不带符号的十进制数
   %o	不带符号的八进制数
   %x	不带符号的十六进制数（小写字母）
   %X	不带符号的十六进制数（大写字母）
   %f	浮点数（本地设置）
   %F	浮点数（不本地设置）
   %e	科学计数法（小写e）
   %E	科学计数法（大写E）
   %s	字符串
   %c	ASCII码值相应的字符
   %b	二进制数
   %a	十六进制数（小写字母）
   %A	十六进制数（大写字母）

6. sprintf函数：sprintf函数与printf函数类似，但它返回格式化后的字符串 (用变量保存），而不是直接将其打印出来。

$number = 42;
$formattedString = sprintf("The answer is %d", $number);
echo $formattedString;

5、变量与常量

5.1 变量命名规则

在PHP中，变量名必须以美元符号“$”开头，后面跟着变量名。变量名可以包含字母、数字和下划线，但必须以字母或下划线开头。此外，PHP是区分大小写的，因此‘$name和$Name`是两个不同的变量。

5.2 变量声明

PHP是一种动态弱类型语言，这意味着您无需显式声明变量的类型。变量的类型是根据其值自动确定的。例如：

$name = "John"; // 字符串类型
$age = 25; // 整数类型
$isStudent = true; // 布尔类型

5.3 变量赋值

要为变量赋值，只需使用赋值操作符（=）将值分配给变量。例如：

$name = "John";
$age = 25;

5.4 变量输出

要在PHP中输出变量的值，可以使用echo语句或print函数。例如：

$name = "John";
echo $name; // 输出：John

5.5 变量类型

字符串（String）

字符串是由一串字符组成的数据类型。可以使用单引号或双引号来定义字符串。例如：

$name = "John";
$message = 'Hello, World!';

整数（Integer）

整数是不带小数点的数字。例如：

$age = 25;

浮点数（Float）

浮点数是带有小数点的数字。例如：

$pi = 3.14;

布尔（Boolean）

布尔类型表示真或假的值。可以是true或false。例如：

$isStudent = true;

数组（Array）

数组是一种用于存储多个值的数据结构。可以使用array()函数或简化的[]语法来创建数组。例如：

$fruits = array("apple", "banana", "orange");
// 或者
$fruits = ["apple", "banana", "orange"];

对象（Object）

对象是类的实例。对象具有属性和方法。例如：

class Person {
    public $name;
    public function sayHello() {
        echo "Hello, my name is " . $this->name;
    }
}

$person = new Person();
$person->name = "John";
$person->sayHello(); // 输出：Hello, my name is John

空（Null）

null表示变量没有值。例如：

$foo = null;

5.6 变量作用域

变量的作用域指的是变量在程序中有效的区域。在PHP中，有以下几种作用域：

5.6.1 局部作用域

局部作用域是指在函数或代码块内部声明的变量。这些变量只在其声明的函数或代码块内部可见。例如：

function myFunction() {
    $name = "John"; // 局部变量
    echo $name;
}

myFunction(); // 输出：John
echo $name; // 错误：变量$name在该作用域外部不可见

5.6.2全局作用域

全局作用域是指在函数外部声明的变量。这些变量在整个程序中都可见。例如：

$name = "John"; // 全局变量

function myFunction() {
    global $name; // 使用global关键声明全局变量
    echo $name;
}

myFunction(); // 输出：John
echo $name; // 输出：John

5.6.3 静态作用域

静态作用域用于在函数调用之间保持变量的持久性。静态变量在函数内部声明，但在函数调用之间保持其值。例如：

function myFunction() {
    static $count = 0; // 静态变量
    $count++;
    echo $count;
}

myFunction(); // 输出：1
myFunction(); // 输出：2
myFunction(); // 输出：3

5.7 变量技巧

5.7.1 变量的引用传递

默认情况下，PHP中的变量是通过值传递的，这意味着在函数内部对变量的更改不会影响函数外部的变量。但是，您可以使用引用传递来让函数修改外部变量。例如：

function increment(&$num) {
    $num++;
}

$count = 0;
increment($count);
echo $count; // 输出：1

在函数参数前加上&符号将参数声明为引用。

5.7.2 变量的动态变量名

在PHP中，您可以使用变量的值作为另一个变量的名称。这被称为动态变量名。例如：

$fruit = "apple";
$apple = "A delicious fruit";
echo $$fruit; // 输出：A delicious fruit

$$fruit将使用$fruit的值作为变量名称，即$apple。

5.8 超全局变量

PHP提供了一些特殊的全局变量，称为超全局变量。这些变量在脚本的任何地方都可用，并且不需要使用global关键字来访问。一些常见的超全局变量包括$_GET、$_POST、$_SERVER等。例如：

echo $_GET['name']; // 输出URL参数中的name值
echo $_POST['email']; // 输出表单提交中的email值
echo $_SERVER['REMOTE_ADDR']; // 输出客户端IP地址

超全局变量	说明
$_GET	地址栏 GET 提交
$_POST	表单 POST 提交
$_FILES	文件上传变量
$_SESSION	会话变量
$_COOKIE	cookie 值变量
$_GLOBALS	全局变量
$_REQUEST	包含$_GET,$_POST,$_COOKIE
$_SERVER	服务器环境变量

5.9 常量命名和规则

常量命名规则

在PHP中，常量名通常使用大写字母，并且建议使用下划线来分隔单词。

• 常量前面没有定义变量符号 ”$“
• 常量只能用 define() 函数定义，而不能通过赋值语句
• 常量一旦定义就不能被重新定义或者取消定义
• 常量的值用来定义 整型，浮点，字符串，布尔值，数组
• 常量可以不用理会变量范围的可以在任何位置访问

例如：

define("PI", 3.14);
define("MAX_SIZE", 100);

//---------------------------------------

define("FRUITS", ["apple", "banana", "orange"]);
echo FRUITS[0]; // 输出：apple
echo FRUITS[1]; // 输出：banana
echo FRUITS[2]; // 输出：orange

5.9.1 常量声明

在PHP中，可以使用define()函数来定义常量。define()函数接受两个参数。例如：

define("PI", 3.14);

自PHP 7.3起，常量默认是大小写敏感的，并且不再支持通过第三个参数来声明大小写不敏感的常量。

5.9.2常量使用

定义常量后，可以在整个脚本中使用它们，无论是在函数内部还是在函数外部。要访问常量的值，只需使用常量名称即可。例如：

define("PI", 3.14);
echo PI; // 输出：3.14

5.9.3预定义常量

PHP还提供了一些预定义的常量，它们在整个脚本中都可用。一些常见的预定义常量包括：

• __FILE__: 当前脚本的文件名（包含完整路径）
• __LINE__: 当前脚本中的行号
• __DIR__: 当前脚本所在的目录
• __FUNCTION__: 当前函数的名称
• __CLASS__: 当前类的名称
• __METHOD__: 当前方法的名称

例如：

echo __FILE__; // 输出当前脚本的文件名
echo __LINE__; // 输出当前脚本中的行号

5.10常量用例

5.10.1 存储配置信息

常量非常适合存储配置信息，例如数据库连接信息、API密钥等。通过将这些敏感信息存储为常量，可以确保它们在整个脚本中不会被更改。

define("DB_HOST", "localhost");
define("DB_USERNAME", "myuser");
define("DB_PASSWORD", "mypassword");

5.10.2 枚举值

常量可以用于定义枚举值，即一组相关的命名常量。您可以使用这些常量来表示不同的颜色。例如，假设您想定义一些颜色常量：

define("COLOR_RED", "red");
define("COLOR_GREEN", "green");
define("COLOR_BLUE", "blue");

5.10.3 数学常量

PHP提供了一些内置的数学常量，方便在数学运算中使用，具体可以查阅PHP手册。例如：

echo M_PI; // 输出圆周率π的值
echo M_E; // 输出自然对数的底数e的值

5.10.4条件编译

常量还可以用于条件编译。根据不同的条件，您可以定义不同的常量值。然后，您可以根据这些常量的值来执行不同的代码块。例如：

define("DEBUG_MODE", true);

if (DEBUG_MODE) {
    // 执行调试模式下的代码
} else {
    // 执行非调试模式下的代码
}

6、运算符

6.1 算术运算符

运算符	说明
$a+$b	加法$a 和$b 的和
$a-$b	减法 $a 和$b 的差
$a*$b	乘法 $a 和$b 的积
$a/$b	除法 $a 除以$b 的商
$a%$b	取模 $a 除以$b 后的余
++$a	前加 $a 的值先加一，然后进行操作
$a++	后加 $a 的值先进行操作，后加一
--$a	前减 $a 的值先减一，然后进行操作
$a--	后减 $a 的值先进行操作，后减一

$a = 5;
$b = 3;
$result = $a + $b; // $result 的值为 8

$a = 5;
$b = 3;
$result = $a - $b; // $result 的值为 2

$a = 5;
$b = 3;
$result = $a * $b; // $result 的值为 15

$a = 10;
$b = 2;
$result = $a / $b; // $result 的值为 5

$a = 10;
$b = 3;
$result = $a % $b; // $result 的值为 1

$a = 2;
$b = 3;
$result = $a ** $b; // $result 的值为 8

$a = 5;
echo ++$a; // 输出：6
echo $a;   // 输出：6

$a = 5;
echo $a++; // 输出：5
echo $a;   // 输出：6

$a = 5;
echo $a--; // 输出：5
echo $a;   // 输出：4

$a = 5;
echo --$a; // 输出：4
echo $a;   // 输出：4

6.2 赋值运算符

运算符	说明
=	右边值赋值给左边变量
+=	左边值加上右边值赋值给左边变量
-=	左边值减掉右边值赋值给左边变量
*=	左边值乘以右边值赋值给左边变量
/=	左边值除以右边值赋值给左边变量
.=	左边字符串连接到右边变量后面
%=	左边值对右边值取余数后赋值给左边变量

6.3 字符串运算符

运算符	说明
.	它返回其左右参数连接后的字符串
.=	左边字符串连接到右边变量后面

6.4 比较运算符

运算符	说明
$a==$b	等于 TRUE，如果$a等于$b
$a===$b	全等于 TRUE，如果$a等于$b，并且类型也相同
$a!=$b	不等 TRUE，如果$a不等于$b
$a<>$b	不等 TRUE，如果$a不等于$b
$a!==$b	非全等 TRUE，如果$a不等于$b，或者类型不同
$a<$b	小于 TRUE，如果$a严格小于$b
$a>$b	大于 TRUE，如果$a严格$b
$a<=$b	小于等于 TRUE，如果 $a小于或者等于$b
$a>=$b	大于等于 TRUE，如果 $a大于或者等于$b

6.5 逻辑运算符

运算符	说明
$a and $b	逻辑与 TRUE，如果 $a 与 $b 都为 TRUE
$a or $b	逻辑或 TRUE，如果 $a 或 $b 任一为 TRUE
!$a	逻辑非 TRUE，如果 $a 不为 TRUE
$a && $b	逻辑与 TRUE，如果 $a 与 $b 都为 TRUE
`$a

6.6 三元表达式

变量 = 条件 ? 值1 : 值2;

当表达式的条件 true 时, 变量 = 值 1 否则 变量 = 值 2

变量?? "默认值";

??操作符是空合并运算符，它用于简化对变量是否为null的判断，并在变量为null时提供一个默认值。 注意是：null

$s1 = null;
echo $s1?? "888"; //结果：888

$s2 = 0;
echo $s2?? 888; // 结果为：0

$s3 = flase;
echo $s3?? 888; // 结果为：不显示

$s4 = true;
echo $s4?? 888; // 结果为：1

7、流程控制

7.1 if/elseif/else

用于执行条件分支的控制结构。它们可以根据条件的真假执行不同的代码块

if (条件1) {
    // 当条件1为真时执行的代码块
} elseif (条件2) {
    // 当条件1为假而条件2为真时执行的代码块
} else {
    // 当所有条件都为假时执行的代码块
}

$age = 25;
if ($age < 18) {
    echo "未成年人";
} elseif ($age >= 18 && $age < 65) {
    echo "成年人";
} else {
    echo "老年人";
}

7.2 switch

用于执行多个条件分支的控制结构。根据表达式的值选择不同的代码块进行执行

switch (表达式) {
    case 值1:
        // 当表达式的值等于值1时执行的代码块
        break;
    case 值2:
        // 当表达式的值等于值2时执行的代码块
        break;
    // 可以有多个case块
    default:
        // 当表达式的值与所有case的值都不匹配时执行的代码块
        break;
}


$day = "Monday";

switch ($day) {
    case "Monday":
        echo "星期一";
        break;
    case "Tuesday":
        echo "星期二";
        break;
    case "Wednesday":
        echo "星期三";
        break;
    case "Thursday":
        echo "星期四";
        break;
    case "Friday":
        echo "星期五";
        break;
    default:
        echo "周末";
        break;
}

注意:如果在 switch 语句的 case 块中没有使用 break 语句，程序将会继续执行后续的 case 块，而不会跳出 switch 语句。

$day = "Monday";
switch ($day) {
    case "Monday":
        echo "Today is Monday.";
    case "Tuesday":
        echo "Tomorrow is Tuesday.";
    case "Wednesday":
        echo "The day after tomorrow is Wednesday.";
    default:
        echo "Other days.";
}

/** 
结果为：  Today is Monday.
        Tomorrow is Tuesday.
        The day after tomorrow is Wednesday.
        Other days.
*/

7.3 while

是一种常用的循环控制结构，用于在满足条件的情况下重复执行一段代码块。

while (条件) {
    // 循环体中的代码
}


$count = 1;
while ($count <= 5) {
    echo $count . " ";
    $count++;
}

7.4 do while

是一种循环控制结构，类似于 while 循环，但它会先执行一次循环体中的代码，然后再检查条件是否为真，如果条件为真，则继续执行循环。

do {
    // 循环体中的代码
} while (条件);

$count = 1;
do {
    echo $count . " ";
    $count++;
} while ($count <= 5);

7.5 for

是一种常用的循环控制结构，用于在指定的条件下重复执行一段代码块，并控制循环变量的增量。

for (初始表达式; 条件表达式; 增量表达式) {
    // 循环体中的代码
}

for ($i = 1; $i <= 5; $i++) {
    echo $i . " ";
}

注意: 循环的时候必须设置停止循环的条件,不然呵呵~ 死机了吧！

7.6 break和continue

• break 语句用于立即终止当前循环（例如 for、while、do while 循环），并跳出循环体，继续执行循环后的代码。它可以用于提前结束循环，无论是否满足循环条件。当程序执行到 break 语句时，循环会立即结束，不再执行循环体内剩余的代码。

• continue 语句用于跳过当前循环的剩余代码，立即进入下一次循环迭代。当程序执行到 continue 语句时，循环会跳过当前迭代的剩余代码，直接进入下一次迭代。它可以用于跳过某些特定条件下的迭代操作。

for ($i = 1; $i <= 10; $i++) {
    if ($i == 5) {
        break;
    }
    echo $i . " ";
}



for ($i = 1; $i <= 5; $i++) {
    if ($i == 3) {
        continue;
    }
    echo $i . " ";
}

8、日期时间

8.1 时区

1. PHP.ini 配置 date.timezone = PRC` (不推荐)

2. 脚本中修改 （推荐使用）

   date_default_timezone_get() //取得当前使用时区
   date_default_timezone_set() //设定当前使用时区
   

8.2 DateTime

PHP提供了一个内置的DateTime类和一些相关的函数，用于处理日期和时间的创建、格式化、计算等操作。

//获取当前日期和时间：
$timeNow = new DateTime(); // 当前日期和时间
$dateNow = $timeNow->format('Y-m-d'); // 当前日期
$timeNow = $timeNow->format('H:i:s'); // 当前时间

//格式化日期和时间：
$dateTime = new DateTime('2021-12-01 14:30:00');
$formattedDateTime = $dateTime->format('Y-m-d H:i:s'); // 格式化为字符串

//解析日期和时间：
$dateString = '2021-12-01 14:30:00';
$dateTime = DateTime::createFromFormat('Y-m-d H:i:s', $dateString); // 解析字符串为日期对象

//计算日期和时间：
$dateTime = new DateTime('2021-12-01');
$dateTime->modify('+1 day'); // 添加一天
$newDate = $dateTime->format('Y-m-d'); // 修改后的日期

//比较日期和时间
$dateTime1 = new DateTime('2021-12-01');
$dateTime2 = new DateTime('2022-01-01');

if ($dateTime1 < $dateTime2) {
    // 日期1早于日期2
}

//格式化输出相对时间：
$dateTime = new DateTime('2021-12-01');
$now = new DateTime();
$diff = $dateTime->diff($now); // 计算日期差
$relativeTime = $diff->format('%y years, %m months, %d days'); // 格式化为相对时间

9、文件引入

include、require、include_once和require_once是用于在脚本中包含其他文件的语句。它们的功能类似，但在文件包含的方式和错误处理方面有一些不同。

include`：用于包含指定文件，并在包含过程中产生一个警告（非致命错误），如果包含的文件不存在或发生其他错误，脚本会继续执行。

include 'file.php';

require：用于包含指定文件，并在包含过程中产生一个致命错误，如果包含的文件不存在或发生其他错误，脚本会停止执行。

require 'file.php';

include_once：与include类似，但是如果同一个文件已经被包含过，include_once会检查并确保文件不会被重复包含。这避免了重复定义函数、类或变量等问题。

include_once 'file.php';

require_once：与require类似，但是如果同一个文件已经被包含过，require_once会检查并确保文件不会被重复包含。这避免了重复定义函数、类或变量等问题。

require_once 'file.php';

使用include和require语句时，可以包含任何PHP文件，包括库文件、模块文件等。被包含的文件可以是相对于当前脚本文件的路径或绝对路径。

需要注意以下几点：

• include和require语句在包含文件时，会创建一个新的局部作用域，包含的文件中定义的函数、类和变量在包含语句后可用。
• 如果包含的文件中有语法错误或其他错误，include会产生一个警告并继续执行，require会产生一个致命错误并停止执行。
• include_once和require_once语句在包含文件时，会检查文件是否已经被包含过，避免重复包含相同文件。
• 推荐在包含文件时使用require或require_once，因为如果被包含文件是必需的（例如核心库文件），则应该确保它们存在，以避免脚本出现严重错误。

PHP数组知识

1、数组介绍

在PHP中，数组是一种用于存储多个值的数据结构。它是一种有序的、可变长度的容器，可以在其中存储不同类型的数据，包括整数、字符串、对象、甚至其他数组。

在 PHP 中有两种数组：索引数组和关联数组。

• 索引（indexed）数组的索引值是整数，以 0 开始。当通过位置来标识东西时用索引数组。
• 关联（associative）数组以字符串做为索引值，关联数组更像操作表。索引值为列名，用于访问列的数据

在 PHP 中数组分：一维数组和多维数组。

$arr = [1,2,3,4,5]; //索引数组 （一维数组）

$arr[0]; // 读取 结果：1

$arrg = ['name' => '张飞','age' => 18, 'ap'=> 89, 'mp' => 100]; //关联数组 （一维数组）

$arrg['name'];// 读取 结果：'张飞'

//索引数组 （多维数组）
$arrs = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]; 

$arrs[1][2]; // 读取 结果：6


//关联数组 （多维数组）
$arrgs = [
    [  'name' => '张飞','age' => 18, 'ap'=> 89, 'mp' => 100],
    [  'name' => '刘备','age' => 28, 'ap'=> 69, 'mp' => 100],
    [  'name' => '关羽','age' => 38, 'ap'=> 99, 'mp' => 100],
  ];

$arrgs[1]['name'];  // 读取 结果：'刘备'

2、遍历数组

2.1 使用指针读取数组的值 current() ,next(), prev(), reset()，end()，key()，each()

1. reset(): 将数组的内部指针重置到数组的第一个元素，并返回该元素的值。
2. next(): 将数组的内部指针移动到下一个元素，并返回该元素的值。
3. prev(): 将数组的内部指针移动到上一个元素，并返回该元素的值。
4. end(): 将数组的内部指针移动到最后一个元素，并返回该元素的值。
5. key(): 返回数组的当前指针位置的键。
6. current(): 返回数组的当前指针位置的值。
7. each(): 返回当前指针位置的键值对，并将指针移动到下一个元素。

$arr = [1,2,3,4,5,6];

echo current($arr);  //结果为： 1
echo next($arr); // 结果为: 2
echo next($arr); // 结果为: 3
echo next($arr); // 结果为: 4
echo next($arr); // 结果为: 5
echo next($arr); // 结果为: 6
echo prev($arr); // 结果为: 5
echo prev($arr); // 结果为: 4
echo prev($arr); // 结果为: 3
echo prev($arr); // 结果为: 2
echo prev($arr); // 结果为: 1
echo prev($arr); // 结果为: false
reset($arr); //重置指针为第一位置
echo current($arr);
.....
    
 $arrgs = [
    [  'name' => '张飞','age' => 18, 'ap'=> 89, 'mp' => 100],
    [  'name' => '刘备','age' => 28, 'ap'=> 69, 'mp' => 100],
    [  'name' => '关羽','age' => 38, 'ap'=> 99, 'mp' => 100],
];

while($arrg = current($arrgs)){
    
    echo "武将:".$arrg['name'].'武力值:'.$arrg['ap'];
    echo "
";
    next($arrgs);
}


//武将:张飞武力值:89
//武将:刘备武力值:69
//武将:关羽武力值:99
    
    
    

使用指针读取数组数据的一个主要优点是它提供了一种灵活而高效的方式来遍历和访问数组的元素。下面是指针读取数组数据的一些优点：

1. 直接访问元素：通过使用指针，可以直接访问数组中的特定元素，而无需使用索引或键。这使得代码更简洁和易读。
2. 灵活的遍历：指针使得遍历数组变得更加灵活。可以自由地在数组中移动指针，访问下一个或上一个元素，或者重置指针到数组的开头。这使得可以根据需要自定义迭代逻辑。
3. 节省内存：使用指针读取数组数据通常比创建额外的数组副本更节省内存。当处理大型数组时，避免复制整个数组可以减少内存占用。
4. 高效的数据处理：指针读取数组数据通常比使用循环和索引访问更高效。这是因为指针直接访问内存中的元素，而不需要额外的索引计算或循环迭代。
5. 支持多维数组：指针读取数组数据对于处理多维数组非常有用。通过移动多个指针，可以轻松地访问多维数组中的元素。

需要注意的是，使用指针读取数组数据也需要小心操作，确保在移动指针时不会超出数组的范围。此外，指针读取数组数据通常适用于线性遍历。

如果需要随机访问数组元素，使用索引或键可能更为适合。

2.2 foreach(), for(), list()

$arrgs = [
    [  'name' => '张飞','age' => 18, 'ap'=> 89, 'mp' => 100],
    [  'name' => '刘备','age' => 28, 'ap'=> 69, 'mp' => 100],
    [  'name' => '关羽','age' => 38, 'ap'=> 99, 'mp' => 100],
];

foreach($arrgs as $key=>$value){

    echo "key".$key.'--------'.$value['name'].'-'.$value['ap'].'
';
}


for($i=0;$i<count($arrgs);$i++){
    echo "key".$i.'--------'.$arrgs[$i]['name'].'-'.$arrgs[$i]['ap'].'
';
}

$arr = ['张飞','刘备','关羽'];

list($name1,$name2,$name) = $arr;  // list(,,$name) = $arr;
// list(,,$name) = $arr;
// echo $name； 结果: 关羽
echo $name1; // 张飞 注意接收变量的数量需要跟数组元素个数

3、数组常用函数

3.1 数组添加删除元素

array_unshift 在数组开头插入一个或多个元素

array_push 将一个或多个元素压入数组的末尾

array_shift 将数组开头的元素移出数组

array_pop 弹出数组最后一个元素

以上操作都时传址操作！！

$arr = [1,2,3,4,5];

array_unshift($arr,100);
print_r($arr);
echo "
";

array_push($arr,99);
print_r($arr);
echo "
";

array_pop($arr);
print_r($arr);
echo "
";

array_shift($arr);
print_r($arr);
echo "
";

/*结果
Array ( [0] => 100 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 )
Array ( [0] => 100 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 [6] => 99 )
Array ( [0] => 100 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 )
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )
*/

3.2 计算数组元素个数

count

$num = [1,2,3];
echo count($num); // 结果为:3

3.3 判断元素是否存在数组种

in_array

$image = ['jpg','gif','bmp'];
echo in_array('jpg',$image); //结果为:1 ,即为 true

3.4 判断数组里是否有指定的键名或索引

array_key_exists

$image = ['jpg','gif','bmp'];
$name = ['name'=>'张三','age'=>88,'sex'=>'男'];
$res = array_key_exists(3, $image);
$resName = array_key_exists('name',$name);

echo  $res;  //结果为:null
echo '
';
echo $resName;  //结果为:1

3.5 函数返回包含数组中所有键名的一个新数组

array_keys

$name = ['name'=>'张三','age'=>88,'sex'=>'男'];
$resName = array_keys($name);
print_r($resName);

//Array ( [0] => name [1] => age [2] => sex )

3.6 用回调函数过滤数组中的元素

array_filter

$name =[
    ['name'=>'张三','age'=>12,'sex'=>'男'],
    ['name'=>'张三','age'=>18,'sex'=>'男'],
    ['name'=>'张三','age'=>35,'sex'=>'男'],
    ['name'=>'张三','age'=>45,'sex'=>'男']
] ;

$res = array_filter($name,function ($item){
  return $item['age'] < 40;
});

print_r($res);

/*
Array
(
    [0] => Array
        (
            [name] => 张三
            [age] => 12
            [sex] => 男
        )

    [1] => Array
        (
            [name] => 张三
            [age] => 18
            [sex] => 男
        )

    [2] => Array
        (
            [name] => 张三
            [age] => 35
            [sex] => 男
        )

)
*/

3.7 为数组的每个元素应用回调函数,结果生成新数组

array_map

$name =[
    ['name'=>'张三','age'=>12,'sex'=>'男'],
    ['name'=>'李四','age'=>18,'sex'=>'男'],
] ;

$resNewName = array_map(function($item){
    $newArray = [];
    $newArray['name'] = $item['name'];
    $newArray['age'] = $item['age'] + 10 ;
    $newArray['sex'] = $item['sex'];
    return  $newArray;

}, $name);

print_r($resNewName);
print_r($name);

/*
新数组增加了10岁
Array
(
    [0] => Array
        (
            [name] => 张三
            [age] => 22
            [sex] => 男
        )

    [1] => Array
        (
            [name] => 李四
            [age] => 28
            [sex] => 男
        )

)



原数组不变
Array
(
    [0] => Array
        (
            [name] => 张三
            [age] => 12
            [sex] => 男
        )

    [1] => Array
        (
            [name] => 李四
            [age] => 18
            [sex] => 男
        )

)

*/

3.8 获取数组中所有的值

array_value

$name =[
    ['name'=>'张三','age'=>12,'sex'=>'男'],
    ['name'=>'李四','age'=>18,'sex'=>'男'],
    ['name'=>'王五','age'=>35,'sex'=>'男'],
    ['name'=>'老六','age'=>45,'sex'=>'男']
] ;

foreach ($name as $n){
    print_r(array_values($n));
}

/*
Array
(
    [0] => 张三
    [1] => 12
    [2] => 男
)
Array
(
    [0] => 李四
    [1] => 18
    [2] => 男
)
Array
(
    [0] => 王五
    [1] => 35
    [2] => 男
)
Array
(
    [0] => 老六
    [1] => 45
    [2] => 男
)

*/

3.9 合并一个或多个数组

array_merge

$database = [
    'host'=>'localhost','port'=>3306,'user'=>'user','password'=>''];

print_r(
    array_merge($database, ['user'=>'root','password'=>'admin888'])
);


/*

Array
(
    [host] => localhost
    [port] => 3306
    [user] => root
    [password] => admin888
)
     假如数组key相同，会被覆盖值！！
*/  

3.10 是 PHP 中的一个内置函数，用于将数组的所有键名（key）转换为指定的大小写格式。它返回一个新的数组，其中包含转换后的键名。

可选参数，指定转换后的大小写格式。可以取两个值之一：

• CASE_LOWER（默认值）：将键名转换为小写形式。
• CASE_UPPER：将键名转换为大写形式。

array_change_key_case

$data = array(
    'FirstName' => 'John',
    'LastName' => 'Doe',
    'Age' => 30
);

$result = array_change_key_case($data, CASE_LOWER);

print_r($result);

如果需要比数组的值转大小写则需要手动实现

function changeValueCase($array, $case) {
    foreach ($array as &$value) {
        if (is_array($value)) {
            $value = changeValueCase($value, $case);
        } else {
            $value = ($case === CASE_LOWER) ? strtolower($value) : strtoupper($value);
        }
    }
    unset($value);
    return $array;
}

$data = array(
    'Name' => 'John',
    'Age' => 30,
    'Email' => '[email protected]'
);

$result = changeValueCase($data, CASE_LOWER);

print_r($result);

/*

Array
(
    [Name] => john
    [Age] => 30
    [Email] => [email protected]
)

*/

3.11 对数组中的每个成员递归地应用用户函数，本函数会递归到更深层的数组中去。

array_walk_recursive

参数说明：

• &$array：要遍历的数组，需要传递一个引用。
• $callback：回调函数，用于处理数组中的每个元素。它可以是一个匿名函数、一个函数名或一个类方法。
• $userdata：可选参数，用户自定义数据，可以在回调函数中使用。

array_walk_recursive(array &$array, callable $callback, mixed $userdata = null): bool
    
    
    function double(&$value)
{
    $value *= 2;
}

$data = array(
    'numbers' => array(1, 2, 3),
    'names' => array('John', 'Jane', 'Jim'),
    'nested' => array(
    'colors' => array('red', 'green', 'blue'),
    'ages' => array(10, 20, 30)
    )
);

array_walk_recursive($data, 'double');

print_r($data);
    
/*
Array
(
    [numbers] => Array
        (
            [0] => 2
            [1] => 4
            [2] => 6
        )

    [names] => Array
        (
            [0] => John
            [1] => Jane
            [2] => Jim
        )

    [nested] => Array
        (
            [colors] => Array
                (
                    [0] => red
                    [1] => green
                    [2] => blue
                )

            [ages] => Array
                (
                    [0] => 20
                    [1] => 40
                    [2] => 60
                )

        )

)



*/

3.12 用于生成一个可用于表示变量的合法 PHP 代码的字符串。它将变量的值转换为字符串，并包含了该值的 PHP 表示形式。

var_export

$data = array(
    'name' => 'John',
    'age' => 30,
    'colors' => array('red', 'green', 'blue')
);

$result = var_export($data, true);

echo $result;

/*
array (
  'name' => 'John',
  'age' => 30,
  'colors' => 
  array (
    0 => 'red',
    1 => 'green',
    2 => 'blue',
  ),
)


*/

3.13 用于将变量序列化为字符串。序列化是将变量的值转换为可存储或传输的格式的过程。序列化后的字符串可以存储到文件中，也可以通过网络传输，并在需要时重新反序列化为原始的 PHP 变量形式。

**serialize ** unserialize

$data = array(
    'name' => 'John',
    'age' => 30,
    'colors' => array('red', 'green', 'blue')
);

$resStr = serialize($data);

echo $resStr;

/*
a:3:{s:4:"name";s:4:"John";s:3:"age";i:30;s:6:"colors";a:3:{i:0;s:3:"red";i:1;s:5:"green";i:2;s:4:"blue";}}
*/

$newStr = unserialize($resStr);

/*
Array
(
    [name] => John
    [age] => 30
    [colors] => Array
        (
            [0] => red
            [1] => green
            [2] => blue
        )
)
*/

php 函数知识

1、函数是介绍

在PHP中，函数是一段可重复使用的代码块，用于执行特定的任务。函数封装了一系列的代码，可以接收参数、执行特定的操作，并返回一个值（可选）。函数的主要目的是提高代码的可维护性和可重用性。

函数可以通过函数名进行调用，并可以传递参数给函数。函数可以执行各种操作，例如计算、数据处理、输出、数据库操作等。通过将一系列操作封装在函数中，可以使代码更加模块化和可读性更高。

在文件头部定义declare(strict_types=1) 为严格模式，这样会对函数参数类型进行严格约束。

declare(strict_types=1);

function  函数名称（类型 参数1，类型 参数2 …）:返回值类型 {
	//逻辑代码
	return 返回值； //如需函数有返回值时使用，否则函数返回值为null
}

它是函数在程序代码中的识别名称，函数名可以是以字母或下划线开头后跟零个或多个字母、下划线和数字的任何字符串。函数名不区分大小写。

function myFunc(){}

MYFUNC();
myfeunc();
MyFunC()；
    
vardump(function_exists('myFunc'));  //判断函数是否存在

2、参数传递

按值传递参数

在PHP中，函数默认按值传递参数。这意味着函数在接收参数时会创建它们的副本，并在函数内部使用这些副本进行操作，而不会直接修改原始参数的值。

按址传递参数(用“&”符号实现)

在PHP中，函数默认是按值传递参数的，但你可以使用引用（&）来实现按引用传递参数，也称为按地址传递参数。

按引用传递参数允许函数直接访问和修改原始变量的值，而不是创建副本。这意味着在函数内部对参数的修改将影响到原始变量。

$number = 5;
function increment(int $num):void {
    $num = $num + 1;
    echo "函数内Number: " . $num . "\n";
}


echo "原Number: " . $number . "\n";
increment($number);
echo "传参后Number: " . $number . "\n";

//原Number: 5 函数内Number: 6 传参后Number: 5



$number = 5;
function increment(int &$num):void {
    $num = $num + 1;
    echo "函数内Number: " . $num . "\n";
}

echo "原Number: " . $number . "\n";
increment($number);
echo "传参后Number: " . $number . "\n";


//原Number: 5 函数内Number: 6 传参后Number: 6

点语法

当传递的参数数量确定时，可以使用…与变量名。函数的所有参数会成为变量的数组元素。

参数默认值

php 支持函数的默认方式调用。如果在调用函数时没有指定参数的值，在函数中会使用参数的默认值。 默认参数必须列在所有没有默认值参数的后面。

function sum(...$args)
{
    return array_sum($args);
}
echo sum(1, 2, 3);



function say(string $name="张飞"):void{

    echo $name;
    
}

say("马云"); //马云
say();// 张飞

返回值类型

• int：整数类型

• float：浮点数类型

• bool：布尔类型

• string：字符串类型

• null：表示无返回值或返回空值

• array：数组类型

• object：对象类型

• callable：可调用类型，包括函数、方法和闭包

• iterable：可遍历类型，包括数组和实现了Traversable接口的对象

• 类名：指定返回值类型为特定的类或其子类

• 接口名：指定返回值类型为特定的接口或其实现类

• 通过使用typedef关键字创建的自定义类型

• void：表示函数没有返回值。

• mixed：表示函数可以返回任意类型的值。

3、变量范围

局部变量

在函数之中声明的变量就是局部变量，并且该变量只有在函数范围之中才能加以使用。如果其它程序局部需要调用使用该变量值时，必须透过「return」指令，来将其传回至主程序区块以作后续处理。

局部变量的作用域仅限于其声明的作用域内部。一旦超出作用域范围，局部变量将不再可用，并且在内存中被释放。这使得局部变量在控制程序的状态和封装数据时非常有用。

function myFunction():void {
    $name = 'John'; // 声明一个局部变量
    echo $name;
}

myFunction(); // 输出：John
echo $name; // 错误，无法访问函数内的局部变量

全局变量

在函数范围之外声明的变量为全局变量，在函数无法直接使用全局变量，函数要使用全局变量，必须要利用 global 引入或 $GLOBALS 超全局数组引入。

注意的是，全局变量的使用应该谨慎，因为它们可以在程序的任何地方被修改，而不受局部作用域的限制。在大型程序中滥用全局变量可能导致代码的可读性和维护性下降。为了避免全局变量的滥用，可以使用面向对象编程的原则，封装数据并通过方法访问和操作数据。

$name = 'John'; // 声明一个全局变量

function myFunction() {
    global $name; // 使用 global 关键字引用全局变量
    echo $name;
}

myFunction(); // 输出：John

静态变量

PHP 支持声明函数变量为静态的(static)。一个静态变量在所有对该函数的调用之间共享，并且仅在脚本的执行期间函数第一次被调用时被初始化。要声明函数变量为静态的用关键字 static。通常，静态变量的第一次使用时赋予一个初始值。

注意的是，静态变量的生命周期会持续到程序执行结束，除非显式重置或重新赋值。此外，静态变量可以在类之间共享信息，可以用于记录全局状态或跟踪某些计数器等。然而，滥用静态变量可能会导致代码的可读性和维护性下降，因此应该谨慎使用。

function myFunction() {
    static $count = 0;  // 声明一个静态变量
    $count++;
    echo $count;
}

myFunction(); // 输出：1
myFunction(); // 输出：2
myFunction(); // 输出：3

变量函数

在PHP中，变量函数是一种特殊的功能，允许将函数名存储在变量中并使用该变量调用函数。这种灵活性使得可以根据运行时的条件动态地选择要调用的函数。

function greet() {
    echo "Hello, World!";
}
$funcName = "greet"; // 将函数名存储在变量中
$funcName(); // 使用变量函数调用函数，输出：Hello, World!


//例子二

function add($a, $b) {
    return $a + $b;
}

function subtract($a, $b) {
    return $a - $b;
}

function multiply($a, $b) {
    return $a * $b;
}

function divide($a, $b) {
    if ($b != 0) {
        return $a / $b;
    } else {
        return "分母不能为零！";
    }
}

$operator = "multiply"; // 根据需要设置运算符

$a = 10;
$b = 5;

switch ($operator) {
    case "add":
        $result = add($a, $b);
        break;
    case "subtract":
        $result = subtract($a, $b);
        break;
    case "multiply":
        $result = multiply($a, $b);
        break;
    case "divide":
        $result = divide($a, $b);
        break;
    default:
        $result = "无效运算";
        break;
}

echo "结果是: " . $result;

递归函数

递归函数是一种在函数内部调用自身的函数。通过递归，函数可以重复执行相同的操作，直到满足特定的条件为止。在编程中，递归函数通常用于解决可以被分解为相同问题的子问题的情况。注意:使用时必须设置跳出递归的条件，不然就呵呵….

function factorial($n) {
    if ($n === 0 || $n === 1) {
        return 1;
    } else {
        return $n * factorial($n - 1);
    }
}

$result = factorial(5); // 计算 5 的阶乘
echo $result; // 输出：120

PHP命名空间的使用及注意要点

PHP 命名空间是一种组织和管理 PHP 代码的方式。它提供了一种避免命名冲突的机制，特别是当多个开发者或多个代码库在同一个应用程序中使用相同的类名、函数名或常量名时。简单理解就好像操作系统目录文件的概念，同一目录里不能存在两个相同的文件。这个原理就应用到PHP程序设计领域就是命名空间的概念。

基本使用

默认情况下常量、类和函数名都放在全局空间下。命名空间通过 namespace 来声明。

注意：

1. namespace 必须定义在文件头部，并在declare(strict_types=1) 语句下面。

2. 实际上，当你在 PHP 代码中没有显式指定命名空间时，会使用默认的全局命名空间，也称为全局作用域。全局作用域中的类、函数和常量可以在任何地方被访问和使用，不需要使用命名空间限定符。

3. 如果命名空间中的函数或常量未定义，将会使用全局命名空间。

declare(strict_types=1) //严格模式
namespace Person;

class Person {
    // 类的定义
}

function myFunction() {
    // 函数的定义
}

const MY_NAME = '张飞';

//使用方法
use MyNamespace\Person;
use function Person\myFunction;
use const Person\MY_NAME;

$obj = new Person();  // 使用完全限定的类名
myFunction();          // 使用完全限定的函数名
echo MY_NAME;      // 使用完全限定的常量名

引用的方式

使用 use 关键字：通过 use 关键字来导入特定的类、函数或常量，以便在当前文件中直接使用。

use MyNamespace\MyClass;
use function MyNamespace\myFunction;
use const MyNamespace\MY_CONSTANT;

$obj = new MyClass();  // 使用导入的类
myFunction();          // 使用导入的函数
echo MY_CONSTANT;      // 使用导入的常量

使用完全限定的名称：如果没有使用 use 关键字导入命名空间，也可以通过完全限定的名称来访问命名空间中的类、函数和常量。

$obj = new MyNamespace\MyClass();  // 使用完全限定的类名
MyNamespace\myFunction();          // 使用完全限定的函数名
echo MyNamespace\MY_CONSTANT;      // 使用完全限定的常量名

使用别名（Alias）：可以通过 use 关键字为命名空间或类创建别名，以便在代码中使用更简短的名称。

use MyNamespace\MyClass as MyClassAlias;
use MyNamespace\myFunction as functionAlias;
use MyNamespace\MY_CONSTANT as CONSTANT_ALIAS;

$obj = new MyClassAlias();  // 使用别名类名
functionAlias();            // 使用别名函数名
echo CONSTANT_ALIAS;        // 使用别名常量名

注意：

多个引入，可以使用多行 use 或用逗号分隔多个类（空间）形式处理多个导入的情况，并使用逗号分隔。

自动加载

在 PHP 中，可以通过使用 spl_autoload_register() 函数来注册自定义的自动加载函数。该函数接受一个回调函数作为参数，当 PHP 遇到未定义的类时，会调用该回调函数来加载类文件。自动加载能够根据类的命名约定自动找到并加载所需的类文件，提高了代码的可维护性和可扩展性。

spl_autoload_register(function ($className) {
    // 转换命名空间分隔符为目录分隔符
    $filePath = str_replace('\\', '/', $className) . '.php';

    if (file_exists($filePath)) {
        require_once($filePath);
    }
});

注意：

自动加载函数的实现可以根据你的项目结构和命名约定进行调整。

例如，你可以将类文件存放在特定目录下，或者使用其他命名约定来匹配类名和文件路径。

推荐使用composer管理项目和自动加载

composer的安装搭建可以自行研究，这不难~

使用方法：

1、进入项目的根目录，并初始化

composer init

2、修改配置文件

个性 composer.json 配置文件，其中 autoload配置项是自动加载设置。

• files 是自动加载文件列表，适合于加载函数
• psr-4 自动加载命名空间与目录对应关系

修改配置文件后执行 composer install 生成 vendor，如果修改过配置文件需要执行 composer update。

3、配置

在项目中使用以下代码即可完成自动加载。

include 'vendor/autoload.php';

PHP文件与目录

disk_total_space 返回目标磁盘总空间

disk_free_space返回目标磁盘剩余空间

$diskSpaceRes = disk_total_space(__DIR__ ) / pow(1024, 3);
$diskFreeRes =  number_format( disk_free_space(__DIR__)/pow(1024,3), 3);
echo sprintf( "%.3f"."
", $diskSpaceRes);
echo $diskFreeRes;

filesize 返回目标文件大小（单位：字节）

$file = number_format(filesize('./test.mp4') / pow(1024, 1), 2) ."KB";
echo $file; // 712.05KB

常用简单函数

函数名	用途
is_writable	判断给定的文件名是否可写
is_readable	判断给定文件名是否可读
file_exists	检查文件或目录是否存在
is_file	判断给定文件名是否为一个正常的文件
is_dir	判断给定文件名是否是一个目录。
filemtime	回文件中的数据块上次被写入的时间(时间戳)
basename	返回路径中的文件名部分
dirname	返回路径中的目录部分
mkdir	支持递归的目录创建，参数分别是：目录、权限位、递归创建
rmdir	删除指定的目录，该目录必须是空的，而且要有相应的权限。
rename	重命名一个文件或目录，也可以进行文件移动。
copy	复制文件

fopen 用于打开文件或 URL 的函数。它用于创建一个文件指针，使您能够对文件进行读取、写入和其他操作。

mode	说明
‘r’	只读方式打开，将文件指针指向文件头。
‘r+’	读写方式打开，将文件指针指向文件头。
‘w’	写入方式打开，将文件指针指向文件头并将文件大小截为零。如果文件不存在则尝试创建之。
‘w+’	读写方式打开，将文件指针指向文件头并将文件大小截为零。如果文件不存在则尝试创建之。
‘a’	写入方式打开，将文件指针指向文件末尾。如果文件不存在则尝试创建之。
‘a+’	读写方式打开，将文件指针指向文件末尾。如果文件不存在则尝试创建之。
‘x’	创建并以写入方式打开，将文件指针指向文件头。如果文件已存在，则 fopen() 调用失败并返回 FALSE，并生成一条 E_WARNING 级别的错误信息。如果文件不存在则尝试创建之。
‘x+’	创建并以读写方式打开，其他的行为和 ‘x’ 一样。

// 打开一个只读模式的文件
$handle = fopen('file.txt', 'r');

// 打开一个只写模式的文件，并将内容写入其中
$handle = fopen('file.txt', 'w');
fwrite($handle, 'Hello, World!');
fclose($handle);

// 打开一个追加模式的文件，并将内容追加到末尾
$handle = fopen('file.txt', 'a');
fwrite($handle, 'More content.');
fclose($handle);

注意：fopen() 打开文件后切记关闭文件指针！ fclose();

fread 所读取的字符串， 或者在失败时返回 FALSE。

function fread($stream, int $length): string|false {}  

fseek 可以在打开的文件中移动文件指针的位置，以便在不同位置进行读取和写入操作。

0 表示成功，返回 -1 表示失败

• $handle：打开的文件指针资源。

• $offset：要移动的字节数。

•   $whence
  

  （可选）：指定偏移量的基准位置。可使用以下常量之一：

  • SEEK_SET：从文件开头开始计算偏移量。
  • SEEK_CUR：从当前位置开始计算偏移量。
  • SEEK_END：从文件末尾开始计算偏移量。

$file = fopen('file.txt', 'r');
// 将文件指针移动到文件的第 10 个字节处
fseek($file, 10, SEEK_SET);
// 从当前位置向后移动 5 个字节
fseek($file, 5, SEEK_CUR);
// 从文件末尾向前移动 20 个字节
fseek($file, -20, SEEK_END);
fclose($file);


//例子：
$data = "./test.txt";
$f = fopen($data,'r');
fseek($f,200, 0);
$content = "";
while (!feof($f)){
    $content .= fread($f , 1024);
}
fclose($f);
echo $content;

**fwrite 写入文件，返回写入的字符数，出现错误时则返回 **FALSE

fclose 关闭一个已打开的文件指针

feof 测试文件指针是否到了文件结束的位置

$handle = fopen('./text.txt','w+');
fwrite($handle,'Hello php');
fseek($handle, 0);
echo fread($handle, 999);
fclose($handle);

fgetc 读取一个字符

fgets 读取一行内容

fgetss 从文件指针中读取一行并过滤掉 HTML 标记。参数分别表示：资源对象、读取数量、允许标签。

fgetcsv 从文件指针中读入一行并解析 CSV 字段。

readfile 读取文件全部内容 （大文件慎用）

$data = './test.txt';
$handle = fopen($data,'r+');
while ($s = fgetc($handle)){
    echo $s;
}
while ($s = fgets($handle)){
    echo $s;
}
fclose($handle);


$handle = fopen('index.html','rb');
while(!feof($handle)){
    echo fgetss($handle,20,'