PHP基础语法
温馨提示：本文最后更新于2024年7月26日 20:27，若内容或图片失效，请在下方留言或联系博主。
php可以写在html中，但不能写到css，js中
每段代码以分号结尾，不然会报错
基础语法
注释
// 单行注释
# 单行注释
/*
多行注释
*/显示php信息
<?php phpinfo() ?>输出方法 echo 与 print
相同点
- 都是一个语言结构，有无括号均可使用，echo或echo()，print或print()
不同点
- echo 能输出一个或多个字符串，英文逗号隔开
- print只能输出一个字符串，且始终返回 1
- echo 比 print 稍快，并且开销低性能更好
<?php echo "<h1>Hello world</h1>"?>
<?php echo "hello world</br>"?>
<?php echo "测试1","测试2","测试3","<br/>" ?>
<?php print "hello world<br/>" ?>
<?php echo print "输出"?>
数据类型
- 字符串，整数，浮点数，布尔，数组，对象，NULL，资源类型
- 用 ver_dump() 可以输出数据类型和值，一般在开发调试时使用
- gettype函数也可以获取变量类型
-
$x=6; $y="Hello"; echo var_dump($x); echo '<br/>'; echo var_dump($y); echo '<br/>'; echo gettype($y)
整数
- 整数有三种格式 十进制，十六进制（前缀 0x）,或八进制（前缀是0）
$x=1; // 十进制
$y=0xa1; // 十六进制
$z=045; //八进制
$t=-136; //十进制负数
echo $x;
echo "<br/>";
echo $y;
echo "<br/>";
echo $z;
echo "<br/>";
echo $t;![[img_2024-04-14_12-34-00.png]]
浮点数
$x=15.4;
$y=3.465E5;//表示3.65*10^5
$z=0.87E-3;//表示0.87*10^-5
var_dump($x);
echo "<br/>";
var_dump($y);
echo "<br/>";
var_dump($z);![[img_2024-04-14_12-41-46.png]]
布尔
$x=true;
$y=false;
var_dump($x);
echo '<br/>';
var_dump($y);![[img_2024-04-14_12-43-40.png]]
数组
- 定义可以使用小括号，也可以使用中括号
$x=array("x1","x2","x3");
$y=["yx","y2","y3"];
echo "<pre>";
var_dump($x);
var_dump($y);
echo "<pre/>";![[img_2024-04-14_12-47-38.png]]
对象
NULL
resource
变量
变量命名规则
- 变量以 $ 符号开头，，其后是变量名称
- 变量名必须以字母或下划线开头
- 变量名不能有数字开头，只能包含数字字母下划线，不能有空格等特殊符号
- 变量名大小写敏感（ $x 与 $X不是同一个变量）
- php变量是弱类型，不用声明具体类型
- 用户定义的所有函数，类，关键字（if else echo等）都对大小写不敏感
<?php
$x=6;
$y=7;
$z=$x*$y+1;
echo $z
?>案例
* {
margin: 0px;
padding: 0px;
}
.main
{
width: 1600px;
height: 1200px;
background-color: #3c3c3c;
}
.nav {
width: 100%;
height: 60px;
}
nav li {
list-style: none;
float: left;
}
.nav a {
display: block;
width: 180px;
height: 60px;
text-align: center;
line-height: 60px;
text-decoration: none;
color: #fff;
}
.nav a:hover{
background-color: #505050;
}
section::before,
section::after {
content: '';
display: table;
}
section h1 {
margin-top: 100px;
text-align: center;
color: #fff;
}
article li {
list-style: none;
line-height: 40px;
}
article {
width: 550px;
margin: 0px auto;
margin-top: 40px;
/* border: 1px solid #fff; */
}
article a{
border-bottom: 1px solid #fff;
text-decoration: none;
color: #fff;
} <body>
<div class="main">
<div class="nav">
<nav>
<ul>
<li><a href="#">首页</a></li>
<li><a href="#">关于我</a></li>
<li><a href="#">博客</a></li>
<li><a href="#">联系物品</a></li>
</ul>
</nav>
</div>
<section class="">
<h1>
<?php echo $title ?>
</h1>
<article>
<ul>
<li><a href="#">1. <?php echo $l1_dt ?> · <?php echo $l1_nm ?></a></li>
<li><a href="#">2. <?php echo $l2_dt ?> · <?php echo $l2_nm ?></a></li>
<li><a href="#">3. <?php echo $l3_dt ?> · <?php echo $l3_nm ?></a></li>
</ul>
</article>
</section>
</div>![[img_2024-04-14_14-11-23.png]]
EOF (heredoc) 界定符使用
- 以 <<<EOF 标记开始，以EOF标记结束
- 结束标记必须独占一行，不能有缩进与空格
- 结束标记末尾必须要有分号
- EOF可以用任意字符代替，开始标记以结束标记相同即可，比如，EOT, COD, EOF 来表示，但是不局限于这几个，可以是任意字符且不在正文中出现即可
- 位于开始与结束标记之间的变量可以被正常解析，但是函数则不可以，在heredoc中，变量不需要连接符 , . 等来拼接
- 当内容需要内嵌引号（单引号或双引号）时，不需要加转义符，本身就会对引号转义
$title="welcome";
$h="hello";
$x = <<<BOE
$h world "!"
<h1> $title </h1>
BOE;
echo $x;![[img_2024-04-14_14-25-59.png]]
条件语句
if(20>"20")
{
echo '大于';
}
elseif (20<"20")
{
echo '小于';
}
else{
echo '等于';
}分支语句
switch($x)
{
case 1:
echo '等于1';
break;
case 2:
echo '等于2';
break;
default:
echo '不等于';
}for循环
for($i=0;$i<10;$i++)
{
$p= <<<EOF
<li>$i</li>
EOF;
echo $p;
}while循环
$i=1;
while($i<100)
{
if ($i % 2 == 0) {
echo "偶数: $i <br/>";
} else {
echo "奇数: $i <br/>";
}
if($i>10)
{
echo "大于: ".($i-1)." <br/>";
break;
}
echo "\n";
$i+=1;
}do...while循环
$i=0;
do{
echo $i."<br/>";
$i+=1;
}
while($i<10)数组
值数组
$a1=array("元素1","元素2","元素3","元素4");
$a2=["元素1","元素2","元素3","元素4"];
var_dump($a1);
print '<br/>';
print_r($a2);
print '<br/>';
print $a1[1];
print '<br/>';
var_dump($a2[1]);
print '<br/>';
var_dump($a1[4]);关联数组
$a1=["k1"=>1,"k2"=>2,"key1","key2"];
var_dump($a1);
print '<br/>';
var_dump($a1["k1"]);
print '<br/>';
var_dump($a1[1]);获取数组长度
$a1=["k1"=>1,"k2"=>2,"key1","key2"];
print count($a1);遍历数组
![[img_2024-04-14_19-12-17.png]]
$a1=["k1","k2","k3","k4","KP"=>"Kvalue"];
for($i=0;$i<count($a1);$i++)
{
echo $a1[$i]."<br/>";
}
foreach($a1 as $x)
{
echo $x."<br/>";
}
foreach($a1 as $key => $value)
{
echo 'key:'.$key.'value:'.$value."<br/>";
}多维数组
![[img_2024-04-14_19-21-39.png]]
$a1=[
"前端"=>["HTML+CSS","vue2","vu3","elementUI","Node.js"],
"后端"=>["php","C#","java"],
"数据库"=>["mysql","sqlserver","oracel"]];
foreach($a1 as $key=>$value)
{
echo $key.'---';
print '<br/>';
foreach($value as $k=>$v)
{
echo '  '.$k.'---'.$v;
print '<br/>';
}
print '<br/>';
}函数
- 函数是一段可重复使用的代码块，可以将一系列复杂的操作封装起来，使代码模块化，可维护和可复用，节省开发时间和代码量
内置函数
内置函数，前面用到的 print, print_r, count 都是内置函数
1. 数组
/* 数组 */
// 取数组中的某一列
array_column($arr, 'key'); //参数1：数组；参数2：某列的键名
// 判断数组中是否存在某值（返回 true|false）
in_array('a', $arr);
// 取数组中所有键值的数组（不保留键名）
array_values($arr);
// 对数组中的键值进行过滤（过滤掉所有等值为false的键值，如0、空等）
array_filter($arr);
// 对数组中的键值进行去重
array_unique($arr);
// 对数组顺序进行翻转
array_reverse($arr);
// 合并数组（两个或多个）
array_merge($arr1, $arr2, ……);
// 取数组的差集（即在数组1中，而不再其他数组中的值）
array_diff($arr1, $arr2, ……);
// 截取数组中的部分值
// 如$arr = [1,2,3,4,5], 下面的函数将取到下标[0,3)的值，即[1,2,3]。
array_slice($arr, 0, 3); //参数1：数组；参数2：起始下标；参数3：截取长度
// 将一个数组分割成多个（常用于向数据库中插入大量数据时）
array_chunk($arr, 200);
// 对数组中的每个键值都应用回调函数
array_map('cube', $arr); //参数1：回调函数名；参数2：数组2. 排序
/* 排序 */
// 对数组进行升序排序（为数组赋予新的键名）
sort($arr);
// 对一维数组按照键值进行升序排序
asort($arr);
// 对一维数组按照键值进行降序排序
arsort($arr);
// 对一位数组按照键名进行升序排序
ksort($arr);
// 对一位数组按照键名进行降序排序
krsort($arr);
// 对多维数组进行排序
array_multisort($arr); //默认按键值升序排序
array_multisort($arr, SORT_DESC, 'key'); //指定列排序 - 参数1：数组；参数2：升序/降序；参数3：某列的键名3. 字符串
/* 字符串 */
// 将字符串转为小写
strtolower($str);
// 将字符串转为大写
strtoupper($str);
// 截取字符串 [0,3)
substr($str, 0,3); //参数1：字符串；参数2：起始下标；参数3：截取长度
// 字符串和数组的转换：如：'1,2,3' <=> [1,2,3]
// 将字符串按符号分割成数组
explode(',', $str); //参数1：符号；参数2：字符串
// 将数组用某符号合成字符串
implode(',', $arr); //参数1：符号；参数2：数组4. 时间日期
/* 时间日期 */
// 获取当前时间戳（1天的时间戳为86400）精确到秒
time();
//获取时间戳 13位 毫秒级
microtime(true);
// 获取当前日期和时间
date('Y-m-d H:i:s');
// 将时间戳格式化为日期
date('Y-m-d', time());
// 将日期转为时间戳
strtotime(date('Y-m-d 00:00:00'));
//获取明天此刻时间
echo date('Y-m-d H:i:s',strtotime("Next Day"));
//字符串转时间
echo date('Y-m-d H:i:s',strtotime("2024-4-16 22:01"));
//计算时间 加一天
echo date('Y-m-d H:i:s',strtotime('Next Day',time()));
echo date('Y-m-d H:i:s',strtotime('+1 Day',time()));
//创建时间戳 2024-05-05 12:02:03
echo mktime(12,2,3,5,5,2024)5. 打印输出
/* 打印 */
// 通用打印
echo 'Hello World!', 'Hello World!';
// 通用打印（与echo区别：echo可以输出多个参数，print只能一个）
print 'Hello World!';
// 格式化打印
print_r('Hello World!');
// 打印结构
var_dump('Hello World!');6. 获取服务器信息
function get_server_info()
{
// 定义输出常量
define('YES', 'Yes');
define('NO', '<span style="color:red">No</span>');
// 服务器系统
$data['php_os'] = PHP_OS;
// 服务器访问地址
$data['http_host'] = $_SERVER['HTTP_HOST'];
// 服务器名称
$data['server_name'] = $_SERVER['SERVER_NAME'];
// 服务器端口
$data['server_port'] = $_SERVER['SERVER_PORT'];
// 获取服务器的协议版本
$data["SERVER_PROTOCOL"] = $_SERVER['SERVER_PROTOCOL'];
// 服务器地址
$data['server_addr'] = isset($_SERVER['LOCAL_ADDR']) ? $_SERVER['LOCAL_ADDR'] : $_SERVER['SERVER_ADDR'];
// 服务器软件
$data['server_software'] = $_SERVER['SERVER_SOFTWARE'];
// 站点目录
$data['document_root'] = isset($_SERVER['DOCUMENT_ROOT']) ? $_SERVER['DOCUMENT_ROOT'] : DOC_PATH;
// PHP版本
$data['php_version'] = PHP_VERSION;
// 数据库驱动
//$data['db_driver'] = Config::get('database.type');
// php配置文件
$data['php_ini'] = @php_ini_loaded_file();
// 最大上传
$data['upload_max_filesize'] = ini_get('upload_max_filesize');
// 最大提交
$data['post_max_size'] = ini_get('post_max_size');
// 最大提交文件数
$data['max_file_uploads'] = ini_get('max_file_uploads');
// 内存限制
$data['memory_limit'] = ini_get('memory_limit');
// 检测gd扩展
$data['gd'] = extension_loaded('gd') ? YES : NO;
// 检测imap扩展
$data['imap'] = extension_loaded('imap') ? YES : NO;
// 检测socket扩展
$data['sockets'] = extension_loaded('sockets') ? YES : NO;
// 检测curl扩展
$data['curl'] = extension_loaded('curl') ? YES : NO;
// 会话保存路径
$data['session_save_path'] = session_save_path() ?: $_SERVER['TMP'];
// 检测standard库是否存在
$data['standard'] = extension_loaded('standard') ? YES : NO;
// 检测多线程支持
$data['pthreads'] = extension_loaded('pthreads') ? YES : NO;
// 检测XCache支持
$data['xcache'] = extension_loaded('XCache') ? YES : NO;
// 检测APC支持
$data['apc'] = extension_loaded('APC') ? YES : NO;
// 检测eAccelerator支持
$data['eaccelerator'] = extension_loaded('eAccelerator') ? YES : NO;
// 检测wincache支持
$data['wincache'] = extension_loaded('wincache') ? YES : NO;
// 检测ZendOPcache支持
$data['zendopcache'] = extension_loaded('Zend OPcache') ? YES : NO;
// 检测memcache支持
$data['memcache'] = extension_loaded('memcache') ? YES : NO;
// 检测memcached支持
$data['memcached'] = extension_loaded('memcached') ? YES : NO;
// 已经安装模块
$loaded_extensions = get_loaded_extensions();
$extensions = '';
foreach ($loaded_extensions as $key => $value) {
$extensions .= $value . ', ';
}
$data['extensions'] = $extensions;
return $data;
}7. 其他
/* 其他 */
$json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';
// 计算数组长度
count($arr);
// 计算字符串长度
count($str);
// md5加密字符串
md5($str);
// md5加密文件
md5_file($filename);
// 对变量进行json编码
json_encode($str);
// 对json格式的字符串进行解码
json_decode($json);函数的创建与调用
php函数命名规则
- 函数名称应提示他的功能
- 函数名称以字母或下划线开头
// 无参数
function Test_1()
{
echo 'Hello world'.'<br/>';
}
// 多参数
function Test_2($a,$b)
{
echo $a.' '.$b.'<br/>';
}
//严格模式，指定参数类型
declare(strict_types=1);
function Test_3(int $a,int $b)
{
echo $a+$b.'<br/>';
}
//返回值
function Test_4($a,$b) {
return $a*$b;
}
Test_1();
Test_2('hello','world');
Test_3(2,3);
echo Test_4(3,4);代码中通过指定 strict_types的值（1或者0），1表示严格类型校验模式，作用于函数调用和返回语句；0表示弱类型校验模式。
1、非严格
<?php
function sum(int ...$int){
return array_sum($int);
}
print(sum(2,'1',2.1));2、严格
declare(strict_types=1);
function sum(int ...$int){
return array_sum($int);
}
print(sum(2,'1',2.1));返回类型声明
声明的类型有：
- int
- float
- bool
- string
- interfaces
- array
- callable
declare(strict_types=1);
function getStr(): string {
return 'wwww';
}
echo getStr();变量的作用域
变量的作用域是指脚本中可被引用/使用的部分
局部和全局（global）作用域
- 在所有函数外定义的变量拥有全局作用域
- 除函数外，全局变量可以被脚本中任何部分访问使用
- 要在一个函数中访问全局变量需要使用global关键字
- 函数内部声明的是局部变量，仅能在内部访问
$x="hello";
function printH()
{
global $x;
$y="world";
echo $x.$y;
}
printH();静态变量static
- 当一个函数完成时，他所有的局部变量都会被删除，当不希望这个变量值能重复使用不被删除，则使用 static 关键字修饰
- 每次调用是会保留调用后的值，但该变量仍是局部变量
代码
function Test() { static $x=1; return $x++; } echo Test(),"<br/>"; echo Test(),"<br/>"; echo Test(),"<br/>";执行结果
![[img_2024-04-14_20-33-32.png]]
函数的参数作用域
参数是通过调用函数将值传递给局部变量
删除变量unset()
判断变量是否存在isset()代码：
function Test() { $x=10; var_dump(isset($x)); echo '<br/>'; unset($x); var_dump(isset($x)); } Test();执行结果：
![[img_2024-04-14_21-41-59.png]]
超级全局变量
$GLOBALS
- $GLOBALS 是PHP的一个超级全局变量组，在一个PHP脚本的全部作用域中都可以访问。
- $GLOBALS 是一个包含了全部变量的全局组合数组。变量的名字就是数组的键。
代码：
$GLOBALS["diy"]="PHP.COM"; var_dump($GLOBALS)执行结果：
![[img_2024-04-14_21-51-52.png]]
$_ERVER
- $_ERVER 是一个包含头信息（header），路径（path），以及脚本位置（scriptLocation）等信息的数组
- 这个数据由web服务器创建，
- 不能保证每个服务器都提供全部项目，服务器可能会忽略一些
代码：
foreach($_SERVER as $key=>$value) { var_dump($key); echo ':-----' ; var_dump($value); echo '<br/>'; }执行结果
![[img_2024-04-14_22-33-05.png]]
下表列出了所有 $_SERVER 变量中的重要元素:
| 元素/代码 | 描述 |
|---|---|
| $_SERVER['PHP_SELF'] | 当前执行脚本的文件名，与 document root 有关。例如，在地址为 http://example.com/test.php/foo.bar 的脚本中使用 $_SERVER['PHP_SELF'] 将得到 /test.php/foo.bar。FILE 常量包含当前(例如包含)文件的完整路径和文件名。 从 PHP 4.3.0 版本开始，如果 PHP 以命令行模式运行，这个变量将包含脚本名。之前的版本该变量不可用。 |
| $_SERVER['GATEWAY_INTERFACE'] | 服务器使用的 CGI 规范的版本；例如，"CGI/1.1"。 |
| $_SERVER['SERVER_ADDR'] | 当前运行脚本所在的服务器的 IP 地址。 |
| $_SERVER['SERVER_NAME'] | 当前运行脚本所在的服务器的主机名。如果脚本运行于虚拟主机中，该名称是由那个虚拟主机所设置的值决定。(如: www.runoob.com) |
| $_SERVER['SERVER_SOFTWARE'] | 服务器标识字符串，在响应请求时的头信息中给出。 (如：Apache/2.2.24) |
| $_SERVER['SERVER_PROTOCOL'] | 请求页面时通信协议的名称和版本。例如，"HTTP/1.0"。 |
| $_SERVER['REQUEST_METHOD'] | 访问页面使用的请求方法；例如，"GET", "HEAD"，"POST"，"PUT"。 |
| $_SERVER['REQUEST_TIME'] | 请求开始时的时间戳。从 PHP 5.1.0 起可用。 (如：1377687496) |
| $_SERVER['QUERY_STRING'] | query string（查询字符串），如果有的话，通过它进行页面访问。 |
| $_SERVER['HTTP_ACCEPT'] | 当前请求头中 Accept: 项的内容，如果存在的话。 |
| $_SERVER['HTTP_ACCEPT_CHARSET'] | 当前请求头中 Accept-Charset: 项的内容，如果存在的话。例如："iso-8859-1,*,utf-8"。 |
| $_SERVER['HTTP_HOST'] | 当前请求头中 Host: 项的内容，如果存在的话。 |
| $_SERVER['HTTP_REFERER'] | 引导用户代理到当前页的前一页的地址（如果存在）。由 user agent 设置决定。并不是所有的用户代理都会设置该项，有的还提供了修改 HTTP_REFERER 的功能。简言之，该值并不可信。) |
| $_SERVER['HTTPS'] | 如果脚本是通过 HTTPS 协议被访问，则被设为一个非空的值。 |
| $_SERVER['REMOTE_ADDR'] | 浏览当前页面的用户的 IP 地址。 |
| $_SERVER['REMOTE_HOST'] | 浏览当前页面的用户的主机名。DNS 反向解析不依赖于用户的 REMOTE_ADDR。 |
| $_SERVER['REMOTE_PORT'] | 用户机器上连接到 Web 服务器所使用的端口号。 |
| $_SERVER['SCRIPT_FILENAME'] | 当前执行脚本的绝对路径。 |
| $_SERVER['SERVER_ADMIN'] | 该值指明了 Apache 服务器配置文件中的 SERVER_ADMIN 参数。如果脚本运行在一个虚拟主机上，则该值是那个虚拟主机的值。(如：someone@runoob.com) |
| $_SERVER['SERVER_PORT'] | Web 服务器使用的端口。默认值为 "80"。如果使用 SSL 安全连接，则这个值为用户设置的 HTTP 端口。 |
| $_SERVER['SERVER_SIGNATURE'] | 包含了服务器版本和虚拟主机名的字符串。 |
| $_SERVER['PATH_TRANSLATED'] | 当前脚本所在文件系统（非文档根目录）的基本路径。这是在服务器进行虚拟到真实路径的映像后的结果。 |
| $_SERVER['SCRIPT_NAME'] | 包含当前脚本的路径。这在页面需要指向自己时非常有用。FILE 常量包含当前脚本(例如包含文件)的完整路径和文件名。 |
| $_SERVER['SCRIPT_URI'] | URI 用来指定要访问的页面。例如 "/index.html"。 |
数组运算符
+ 合并运算符
- 两个数组合并，如果存在相同键名，则只保留第一个数组内的元素；
- 可以可以使用array_merge()函数合并数组，array_merge是多个参数是从后往前合并
代码：
var_dump($a1+$a2); echo '<br/>'; var_dump(array_merge($a1,$a2));执行结果：
![[img_2024-04-14_22-41-43.png]]
\== 与 \===
- \== 判断有相同键值对
- \=== 不仅键值对要相等，顺序也要一致
代码：
$a1=["a1"=>"aa1","a2"=>"aa2","a3"=>"aa3"]; $a2=["a1"=>"aa1","a3"=>"aa3","a2"=>"aa2"]; var_dump($a1==$a2); echo '<br/>'; var_dump($a1===$a2);执行结果：
![[img_2024-04-14_22-50-23.png]]
!=, <>, !==
- !=与<>作用相同
- !=与\== 相反
- !\== 与 \=== 相反
三元运算符?:
空合运算符
- 用于简化处理可能为null的变量或或空数组元素的情况
- 它的作用是判断一个变量是否未定义或为null，，如果未定义则返回指定默认值，否则则返回自身
代码：
$a=null; echo $a??"变量a的值为null";
组合比较符号
- 可比较整形，浮点型，字符串
- 只比较值，不比较类型
- 固定返回三个值（-1，0，1）
代码：
$a=1; $b=2; echo $a <=> $b;代码解析：
- 如果a大于b，则返回1
- 如果a等于b，则返回0
- 如果a小于b，则返回-1
比较undefined，0，flase，null，空值
- isset会判断变量是否声明了
- is_null，变量未定义时会返回true
- empty对未定义变量也会返回true，使用empty前要确保变量已被定义
常用函数
字符串函数
格式化函数
1、trim(): 删除字符串两端的空格或其他预定义字符
$str = "\r\nHello World!\r\n"; echo trim($str); // Hello World!2、rtrim(): 删除字符串右边的空格或其他预定义字符
$str = "Hello World!\n\n"; echo rtrim($str); // Hello World! echo chop($str); // Hello World! # chop() 是 rtrim()的别名3、ltrim(): 删除字符串左边的空格或其他预定义字符
$str = "\r\nHello World!"; echo ltrim($str);4、strtolower(): 字符串转为小写
echo strtolower("Hello World!"); // hello world!5、strtoupper(): 字符串转为大写
echo strtoupper("Hello World!"); // HELLO WORLD!6、ucfirst(): 字符串首字母大写
echo ucfirst("hello world"); // Hello world7、ucwords(): 字符串每个单词首字符转为大写
echo ucwords("hello world"); // Hello World8、lcfirst(): 把字符串中的首字符转换为小写。
echo lcfirst("Hello World!"); // hello world!
字符串定位
1、strpos():查找字符串在另一字符串中第一次出现的位置，区分大小写 ，返回位置或false
echo strpos("I love php, I love php too!","php"); // 72、stripos(): 计算字符串在另一字符串中第一次出现的位置，不区分大小写
echo stripos("I love php, I love php too!","PHP"); // 73、strrpos(): 计算字符串在另一字符串中最后一次出现的位置，区分大小写。
echo strrpos("I love php, I love php too!","php"); // 74、strripos(): 计算字符串在另一字符串中最后一次出现的位置，不区分大小写
echo strripos("I love php, I love php too!","PHP"); // 195、 strstr()|strchr(): 返回字符串在另一字符串中第一次出现的位置到结束的所有字符串，区分大小写
strstr()函数搜索字符串在另一字符串中是否存在，如果是，返回第一次出现该字符串及剩余部分，否则返回 FALSE。echo strstr("Hello world!","world"); // 输出 world! echo strchr("Hello world!","world"); // 输出 world!6、stristr(): 返回字符串在另一字符串中的第一次出现的位置到结束的所有字符串，不区分大小写
echo stristr("Hello world!","WORLD"); // world!7、strrchr(): 返回字符串在另一个字符串中最后一次出现的位置到结束的所有字符串，不区分大小写
echo strrchr("Hello world!","world"); // world!8、strpbrk(): 在字符串中搜索指定字符中的任意一个，区分大小写
echo strpbrk("Hello world!","oe"); // ello world!
字符串运算与字符串子串
1、substr() | mb_substr(): 返回字符串的一部分（截取字符串）
- substr() 函数，它只针对英文字符，如果要分割的中文文字则需要使用 mb_substr()。
//语法: substr(string,start,length) echo substr("Hello world",6); // world echo mb_substr("菜鸟教程", 0, 2);// 输出：菜鸟2、substr_replace(): 把字符串的一部分替换为另一个字符串
echo substr_replace("Hello","world",0); // world3、str_replace(): 替换字符串中的一些字符，区分大小写
echo str_replace("world","Peter","Hello world!"); // Hello Peter!4、str_ireplace(): 替换字符串中的一些字符，不区分大小写
echo str_ireplace("WORLD","Peter","Hello world!"); // Hello Peter!5、str_repeat(): 把字符串重复指定的次数
echo str_repeat(".",13); // .............6、str_pad(): 把字符串填充为指定的长度
$str = "Hello World"; echo str_pad($str,20,"."); // Hello World.........7、strrev(): 反转字符串
echo strrev("Hello World!"); // !dlroW olleH8、strtr(): 转换字符串中的某些字符
echo strtr("Hilla Warld","ia","eo"); // Hello World9、str_shuffle(): 随机地打乱字符串中的所有字符
echo str_shuffle("Hello World"); // lolWo drHle10、chunk_split()：将字符串分成小块
$str = "Hello world!"; echo chunk_split($str,1,"."); // H.e.l.l.o. .w.o.r.l.d.!.11、strtok(): 切开字符串
$string = "Hello world. Beautiful day today."; $token = strtok($string, " "); while ($token != false) { echo "$token<br>"; $token = strtok(" "); } // 输出: // Hello // world. // Beautiful // day // today.12、wordwrap(): 按照指定长度对字符串进行折行处理
$str = "An example of a long word is: Supercalifragulistic"; echo wordwrap($str,15,"<br>\n"); // 输出： // An example of a<br> // long word is:<br> // Supercalifragulistic13、number_format(): 通过千位分组来格式化数字
echo number_format("1000000")."<br>"; // 1,000,000 echo number_format("1000000",2)."<br>"; // 1,000,000.00 echo number_format("1000000",2,",","."); // 1.000.000,0014、dirname(): 返回路径中的目录部分
echo dirname("c:/testweb/home.php"); //c:/testweb
字符串比较
1、strnatcmp(): 使用一种"自然排序"算法来比较两个字符串，区分大小写
// 语法：strnatcmp(string1,string2); // 返回值： // 0 - 如果两个字符串相等 // <0 - 如果 string1 小于 string2 // >0 - 如果 string1 大于 string2 echo strnatcmp("2Hello world!","10Hello world!"); // -1 echo strnatcmp("10Hello world!","2Hello world!"); // 12、strnatcasecmp(): 使用一种"自然排序"算法来比较两个字符串，不区分大小写
//语法： strncasecmp(string1,string2,length); echo strncasecmp("Hello world!","hello earth!",6); // 03、strcasecmp(): 使用一种"自然排序"算法来比较两个字符串，不区分大小写
// 该函数与 strncasecmp() 函数类似，不同的是，通过 strncasecmp() 可以指定每个字符串用于比较的字符数。 // 语法： strcasecmp(string1,string2); // 返回值： // 0 - 如果两个字符串相等 // <0 - 如果 string1 小于 string2 // >0 - 如果 string1 大于 string2 echo strcasecmp("Hello world!","HELLO WORLD!"); // 04、substr_compare(): 从指定的开始位置（二进制安全和选择性区分大小写）比较两个字符串。
//语法：substr_compare(string1,string2,startpos,length,case); echo substr_compare("Hello world","Hello world",0); // 05、strncasecmp(): 前 n 个字符的字符串比较，不区分大小写
echo strncasecmp("Hello world!","hello earth!",6); // 06、strncmp(): 前 n 个字符的字符串比较，区分大小写
echo strncmp("Hello world!","Hello earth!",6); // 07、strcmp(): 区分大小写比较两字符串
echo strcmp("Hello world!","Hello world!"); // 08、strcoll(): 比较两个字符串（根据本地设置）
setlocale (LC_COLLATE, 'NL'); echo strcoll("Hello World!","Hello World!"); // 0 setlocale (LC_COLLATE, 'en_US'); echo strcoll("Hello World!","Hello World!"); // 09、similar_text(): 计算两个字符串的相似度
echo similar_text("Hello World","Hello Peter"); // 7 - 相同字符数量
字符串计数
1、strspn(): 返回在字符串中包含的特定字符的数目
echo strspn("Hello world!","kHlleo"); // 52、strcspn(): 返回在找到任何指定的字符之前，在字符串查找的字符数
echo strcspn("Hello world!","w"); // 63、str_word_count(): 计算字符串中的单词数
echo str_word_count("Hello world!"); // 24、count_chars(): 统计字符串中所有字母出现次数(0…255)
// 语法： count_chars(string,mode); // mode：可选。规定返回模式。默认是 0。有以下不同的返回模式： // 0 - 数组，ASCII 值为键名，出现的次数为键值 // 1 - 数组，ASCII 值为键名，出现的次数为键值，只列出出现次数大于 0 的值 // 2 - 数组，ASCII 值为键名，出现的次数为键值，只列出出现次数等于 0 的值 // 3 - 字符串，带有所有使用过的不同的字符 // 4 - 字符串，带有所有未使用过的不同的字符 $str = "Hello World!"; echo count_chars($str,3); // !HWdelor5、strlen(): 获取字符串的长
echo strlen("world"); // 5 //中文字符串的处理使用 mb_strlen() 函数。使用 mb_strlen 要开启 mbstring 扩展。6、substr_count(): 计算子串在字符串中出现的次数
echo substr_count("Hello world. The world is nice","world"); // 2
字符串与数组
1、str_split(): 将字符串转换为数组
print_r(str_split("Hello")); // Array ( [0] => H [1] => e [2] => l [3] => l [4] => o )2、implode() | join(): 将一个一维数组的值转化为字符串
$arr = array('Hello','World!','Beautiful','Day!'); echo implode(" ",$arr); // Hello World! Beautiful Day!3、explode(): 使用一个字符串分割另一个字符串，返回数组
$str = "www.baidu.com"; print_r(explode(".",$str)); // Array([0] => www [1] => baidu [2] => com)4、str_getcsv(): 把 CSV 字符串解析到数组中。
- str_getcsv() 函数解析 CSV 格式字段的字符串，并返回一个包含所读取字段的数组。
// 语法：str_getcsv(string,separator,enclosure,escape); //string 必需。规定要解析的字符串。 //separator 可选。设置字段分界符（只允许一个字符），默认值为逗号（ , ）。 //enclosure 可选。设置字段环绕符（只允许一个字符），默认值为双引号（ " ）。 //escape 可选。设置转义字符（只允许一个字符），默认值为反斜线（ \ ）。
字符串与html
1、htmlentities(): 把字符转换为 HTML 实体
$str = "<© Helloçh°°¦§>"; echo htmlentities($str); // 上面代码的浏览器输出如下： // <© Helloçh°°¦§>2、html_entity_decode(): 把 HTML 实体转换为字符
$str = "<© Helloçh°°¦§>"; echo html_entity_decode($str); // 上面代码的浏览器输出如下： // <© Hello°°¦§>3、htmlspecialchars(): 把一些预定义的字符转换为 HTML 实体。
$str = "This is some <b>bold</b> text."; echo htmlspecialchars($str); // 上面代码的浏览器输出如下： // This is some <b>bold</b> text.4、htmlspecialchars_decode(): 把一些预定义的 HTML 实体转换为字符
// 把预定义的 HTML 实体 "<"（小于）和 ">"（大于）转换为字符： $str = "This is some <b>bold</b> text."; echo htmlspecialchars_decode($str); // 上面代码的浏览器输出如下： // This is some bold text.5、 et_html_translation_table() 返回 htmlspecialchars() 和 htmlentities() 使用的翻译表。
print_r (get_html_translation_table()); // 输出： // Array // ( // ['] => " // [&] => & // [<] => < // [>] => > )6、addcslashes(): 在指定的字符前添加反斜杠的字符串
$str = addcslashes("Hello World!","W"); echo($str); // Hello \World!7、stripcslashes(): 删除由 addcslashes() 函数添加的反斜杠
$str = addcslashes("Hello World!","W"); echo($str); // Hello \World!8、addslashes(): 在预定义的字符前添加反斜杠的字符串
$str = addslashes('What does "yolo" mean?'); echo($str); // What does \"yolo\" mean?9、stripslashes(): 删除由 addslashes() 函数添加的反斜杠
echo stripslashes("Who\'s Peter Griffin?"); // Who's Peter Griffin?10、strip_tags(): 剥去 HTML、XML 以及 PHP 的标签
echo strip_tags("Hello <b>world!</b>"); //11、nl2br(): 在字符串中的每个新行之前插入 HTML 换行符
echo nl2br("One line.\nAnother line."); // 上面代码的浏览器输出如下： // One line. // Another line. // 上面代码的 HTML 输入如下（查看源代码）： // One line.<br /> // Another line.11、nl2br(): 在字符串中的每个新行之前插入 HTML 换行符
echo nl2br("One line.\nAnother line."); // 上面代码的浏览器输出如下： // One line. // Another line. // 上面代码的 HTML 输入如下（查看源代码）： //One line.<br /> //Another line.11、nl2br(): 在字符串中的每个新行之前插入 HTML 换行符
echo nl2br("One line.\nAnother line."); // 上面代码的浏览器输出如下： // One line. // Another line. // 上面代码的 HTML 输入如下（查看源代码）： // One line.<br /> // Another line.
字符串加密
1、md5(): 计算字符串的 MD5 散列值
$str = "Hello"; echo md5($str); // 8b1a9953c4611296a827abf8c47804d72、md5_file(): 计算指定文件的 MD5 散列值
$filename = "test.txt"; $md5file = md5_file($filename); echo $md5file; // d41d8cd98f00b204e9800998ecf8427e3、sha1(): 计算字符串的 sha1 散列值
$str = "Hello"; echo sha1($str); // f7ff9e8b7bb2e09b70935a5d785e0cc5d9d0abf04、sha1_file(): 计算文件的 sha1 散列值
$filename = "test.txt"; $sha1file = sha1_file($filename); echo $sha1file; // aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d5、crc32(): 计算一个字符串的 32 位 CRC（循环冗余校验）
$str = crc32("Hello World!"); printf("%un",$str); // 4724563556、crypt(): 单向的字符串加密法（hashing）
//语法： crypt(str,salt); // 实际用法参考官方文档
字符串与ASCII 值
1、ord(): 返回字符串中第一个字符的 ASCII 值。
echo ord("h"); // 104 echo ord("hello"); // 1042、chr(): 返回指定的字符
echo chr(52) ; // 4 echo chr(052); // * echo chr(0x52); // R3、bin2hex(): 把 ASCII 字符的字符串转换为十六进制值
$str = bin2hex("Hello World!"); echo($str); // 48656c6c6f20576f726c64214、hex2bin(): 把十六进制值的字符串转换为 ASCII 字符
echo hex2bin("48656c6c6f20576f726c6421"); // Hello World!
字符串输入与输出
1、vfprintf(): 将格式化字符串写入流（例如：文件或数据库）
$number = 9; $str = "Beijing"; $file = fopen("test.txt","w"); echo vfprintf($file,"There are %u million bicycles in %s.",array($number,$str)); // 40 返回被写的字符串的长度。 // 上面的文本将被写入到文件 "test.txt"：There are 9 million bicycles in Beijing.
> 2、fprintf(): 将格式化后的字符串写入到流（例如：文件或数据库）
```php
$number = 9;
$str = "Beijing";
$file = fopen("test.txt","w");
echo fprintf($file,"There are %u million bicycles in %s.",$number,$str); // 40
// 下面的文本将被写入到文件 "test.txt"：There are 9 million bicycles in Beijing.3、vprintf(): 输出格式化字符串
$number = 9; $str = "Beijing"; vprintf("There are %u million bicycles in %s.",array($number,$str)); // There are 9 million bicycles in Beijing.4、vsprintf(): 把格式化字符串写入变量中
$number = 9; $str = "Beijing"; $txt = vsprintf("There are %u million bicycles in %s.",array($number,$str)); echo $txt; // There are 9 million bicycles in Beijing.5、sscanf(): 根据指定的格式解析来自一个字符串的输入
- sscanf() 函数基于格式字符串解析字符串到变量中。
$str = "age:30 weight:60kg"; sscanf($str,"age:%d weight:%dkg",$age,$weight); // show types and values var_dump($age,$weight); // int(30) int(60)6、parse_str(): 把查询字符串解析到变量中
parse_str("name=Peter&age=43"); echo $name; // Peter echo $age; // 43注释：php.ini 文件中的 magic_quotes_gpc 设置影响该函数的输出。如果已启用，那么在 parse_str() 解析之前，变量会被 addslashes() 转换。
7、其他字符串输入函数
print(): // 输出字符串 printf(): // 输出格式化字符串 echo(): // 输出一个或多个字符串
字符串编码函数
1、convert_cyr_string(): 把字符串由一种 Cyrillic 字符集转换成另一种
$str = "Hello world! æøå"; echo $str . "<br>"; // Hello world! æøå echo convert_cyr_string($str,'w','a'); // Hello world! ¦è¥2、convert_uudecode(): 对 uuencode 编码的字符串进行解码
$str = ",2&5L;&@=V]R;&0A `"; echo convert_uudecode($str); // Hello world!3、convert_uuencode(): 使用 uuencode 算法对字符串进行编码
$str = "Hello world!"; echo convert_uuencode($str); // ,2&5L;&\@=V]R;&0A `4、str_rot13(): 对字符串执行 ROT13 编码
echo str_rot13("Hello World"); // Uryyb Jbeyq echo str_rot13("Uryyb Jbeyq"); // Hello World
其他字符串函数
1、setlocale() 设置地区信息（地域信息）。
echo setlocale(LC_ALL,"US"); // English_United States.1252 echo setlocale(LC_ALL,NULL); // English_United States.12522、nl_langinfo() 返回指定的本地信息。
// 语法：nl_langinfo(element); 详情参考官方手册。3、localeconv() 返回本地数字及货币格式信息。
setlocale(LC_ALL,"US"); $locale_info = localeconv(); print_r($locale_info); // 输出： Array ( [decimal_point] => . [thousands_sep] => [int_curr_symbol] => [currency_symbol] => [mon_decimal_point] => [mon_thousands_sep] => [positive_sign] => [negative_sign] => [int_frac_digits] => 127 [frac_digits] => 127 [p_cs_precedes] => 127 [p_sep_by_space] => 127 [n_cs_precedes] => 127 [n_sep_by_space] => 127 [p_sign_posn] => 127 [n_sign_posn] => 127 [grouping] => Array ( ) [mon_grouping] => Array (
))
> 4、money_format() 返回格式化为货币字符串的字符串。
```php
$number = 1234.56;
setlocale(LC_MONETARY,"en_US");
echo money_format("The price is %i", $number); // The price is USD 1,234.565、levenshtein() 返回两个字符串之间的 Levenshtein 距离。
echo levenshtein("Hello World","ello World"); // 1 echo levenshtein("Hello World","ello World",10,20,30); // 306、quotemeta() 引用元字符。
$str = "Hello world. (can you hear me?)"; echo quotemeta($str); // Hello world\. \(can you hear me\?\)7、quoted_printable_decode() 把 quoted-printable 字符串转换为 8 位字符串。
$str = "Hello=0Aworld."; echo quoted_printable_decode($str); // 上面代码的浏览器输出如下： // Hello world.
// 上面代码的 HTML 输出如下（查看源代码）：
// Hello
// world.> 8、quoted_printable_encode() 把 8 位字符串转换为 quoted-printable 字符串。
```php
// 语法： quoted_printable_encode(string); 详情参考官方手册。9、soundex() 计算字符串的 soundex 键。
echo soundex("Hello"); // H40010、metaphone() 计算字符串的 metaphone 键。
echo metaphone("World"); // WRLT11、hebrev() 把希伯来（Hebrew）文本转换为可见文本。
echo hebrev("á çùåï äúùñâ"); // âñùúä ïåùç á12、hebrevc() 把希伯来（Hebrew）文本转换为可见文本，并把新行（\n）转换为 \<br>。
echo hebrevc("á çùåï äúùñâ\ná çùåï äúùñâ"); // 输出： // âñùúä ïåùç á // âñùúä ïåùç á
数组函数
数组键值相关函数
1、list() 把数组中的值赋给一些数组变量。
$my_array = array("Dog","Cat","Horse"); list($a, $b, $c) = $my_array; echo "I have several animals, a $a, a $b and a $c."; // I have several animals, a Dog, a Cat and a Horse.2、range() 创建一个包含指定范围的元素的数组。
$number = range(0,5); print_r ($number); // Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 )3、key() 从关联数组中取得键名。
$people=array("Peter","Joe","Glenn","Cleveland"); echo key($people); // 04、in_array() 检查数组中是否存在指定的值。
$sites = array("Google", "Runoob", "Taobao", "Facebook"); var_dump(in_array("Runoob", $sites)); // bool(true)5、each() 返回数组中当前的键／值对。
$people = array("Peter", "Joe", "Glenn", "Cleveland"); print_r (each($people)); // Array ( [1] => Peter [value] => Peter [0] => 0 [key] => 0 )6、compact() 创建一个包含变量名和它们的值的数组。
$firstname = "Peter"; $lastname = "Griffin"; $age = "41"; $result = compact("firstname", "lastname", "age"); print_r($result); // Array ( [firstname] => Peter [lastname] => Griffin [age] => 41 )7、extract() 从数组中将变量导入到当前的符号表。
$a = "Original"; $my_array = array("a" => "Cat","b" => "Dog", "c" => "Horse"); extract($my_array); echo "\$a = $a; \$b = $b; \$c = $c"; // $a = Cat; $b = Dog; $c = Horse8、array_key_exists() 检查指定的键名是否存在于数组中。
$a=array("Volvo"=>"XC90","BMW"=>"X5"); var_dump(array_key_exists("Volvo", $a)); // bool(true)9、array_key_first() 获取指定数组的第一个键值。
$array = ['a' => 1, 'b' => 2, 'c' => 3]; $firstKey = array_key_first($array); echo $firstKey; // a10、array_key_last() 获取指定数组的最后一个键值。
$array = ['a' => 1, 'b' => 2, 'c' => 3]; $lastKey = array_key_last($array); echo $lastKey; // c11、array_keys() 返回数组中所有的键名。
$a=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander"); print_r(array_keys($a)); // Array ( [0] => Volvo [1] => BMW [2] => Toyota )12、array_rand() 从数组中随机选出一个或多个元素，返回键名。
$a=array("red","green","blue","yellow","brown"); $random_keys=array_rand($a,3); echo $a[$random_keys[0]]; // red echo $a[$random_keys[1]]; // blue echo $a[$random_keys[2]]; // brown13、array_values() 返回数组中所有的值。
$a=array("Name"=>"Peter","Age"=>"41","Country"=>"USA"); print_r(array_values($a)); // Array ( [0] => Peter [1] => 41 [2] => USA )14、array_count_values() 用于统计数组中所有值出现的次数。
$a=array("A","Cat","Dog","A","Dog"); print_r(array_count_values($a)); // Array ( [A] => 2 [Cat] => 1 [Dog] => 2 )
数组更改函数
1、array_map() 将用户自定义函数作用到给定数组的每个值上，返回新的值。
function myfunction($num) { return($num*$num); } $a=array(1,2,3,4,5); print_r(array_map("myfunction",$a)); // Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )2、array_pad() 将指定数量的带有指定值的元素插入到数组中
$a=array("red","green"); print_r(array_pad($a,5,"blue")); // Array ( [0] => red [1] => green [2] => blue [3] => blue [4] => blue )3、array_pop() 删除数组中的最后一个元素（出栈）。
$a=array("red","green","blue"); array_pop($a); print_r($a); // Array ( [0] => red [1] => green )4、array_push() 将一个或多个元素插入数组的末尾（入栈）。
$a=array("red","green"); array_push($a,"blue","yellow"); print_r($a); // Array ( [0] => red [1] => green [2] => blue [3] => yellow )5、array_reduce() 通过使用用户自定义函数，迭代地将数组简化为一个字符串，并返回。
function myfunction($v1,$v2) { return $v1 . "-" . $v2; } $a=array("Dog","Cat","Horse"); print_r(array_reduce($a,"myfunction")); // -Dog-Cat-Horse6、array_replace() 使用后面数组的值替换第一个数组的值。
$a1=array("red","green"); $a2=array("blue","yellow"); print_r(array_replace($a1,$a2)); // Array ( [0] => blue [1] => yellow )7、array_replace_recursive() 递归地使用后面数组的值替换第一个数组的值。
$a1=array("a"=>array("red"),"b"=>array("green","blue"),); $a2=array("a"=>array("yellow"),"b"=>array("black")); print_r(array_replace_recursive($a1,$a2)); // Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black [1] => blue ) )8、array_reverse() 将原数组中的元素顺序翻转，创建新的数组并返回。
$a=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota"); print_r(array_reverse($a)); // Array ( [c] => Toyota [b] => BMW [a] => Volvo )9、array_search() 在数组中搜索给定的值，如果成功则返回相应的键名。
$a=array("a"=>"red","b"=>"green","c"=>"blue"); echo array_search("red",$a); // a10、array_shift() 删除数组中的第一个元素，并返回被删除元素的值。
$a=array("a"=>"red","b"=>"green","c"=>"blue"); echo array_shift($a); // red print_r ($a); // Array ( [b] => green [c] => blue )11、array_slice() 返回数组中的选定部分。
$a=array("red","green","blue","yellow","brown"); print_r(array_slice($a,2)); // Array ( [0] => blue [1] => yellow [2] => brown )12、array_splice() 把数组中的指定元素去掉并用其它值取代。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow"); $a2=array("a"=>"purple","b"=>"orange"); array_splice($a1,0,2,$a2); print_r($a1); // Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )13、array_unique() 删除数组中重复的值。对原数组不影响
$a=array("a"=>"red","b"=>"green","c"=>"red"); print_r(array_unique($a)); // Array ( [a] => red [b] => green )14、array_unshift() 在数组开头插入一个或多个元素。
$a=array("a"=>"red","b"=>"green"); array_unshift($a,"blue"); print_r($a); // Array ( [0] => blue [a] => red [b] => green )15、array_walk() 对数组中的每个成员应用用户函数。
function myfunction($value,$key) { echo "The key $key has the value $value<br>"; } $a=array("a"=>"red","b"=>"green","c"=>"blue"); array_walk($a,"myfunction"); // 输出： // The key a has the value red // The key b has the value green // The key c has the value blue16、array_walk_recursive() 对数组中的每个成员递归地应用用户函数。
function myfunction($value,$key) { echo "The key $key has the value $value<br>"; } $a1=array("a"=>"red","b"=>"green"); $a2=array($a1,"1"=>"blue","2"=>"yellow"); array_walk_recursive($a2,"myfunction"); // 输出： // The key a has the value red // The key b has the value green // The key 1 has the value blue // The key 2 has the value yellow
> 17、array_change_key_case() 返回其键均为大写或小写的数组。
```php
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
print_r(array_change_key_case($age,CASE_UPPER));
// Array([PETER] => 35 [BEN] => 37 [JOE] => 43)18、array_chunk() 把一个数组分割为新的数组块。
$cars=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel"); print_r(array_chunk($cars,2)); // 输出： // Array // ( // [0] => Array // ( // [0] => Volvo // [1] => BMW // ) // [1] => Array // ( // [0] => Toyota // [1] => Honda // ) // [2] => Array // ( // [0] => Mercedes // [1] => Opel // ) // )19、array_fill() 用给定的键值填充数组。
$a1=array_fill(3,4,"blue"); $b1=array_fill(0,1,"red"); print_r($a1); print_r($b1); // 输出： Array ( [3] => blue [4] => blue [5] => blue [6] => blue ) Array ( [0] => red )20、array_fill_keys() 用给定的指定键名的键值填充数组。
$keys=array("a","b","c","d"); $a1=array_fill_keys($keys,"blue"); print_r($a1); // Array ( [a] => blue [b] => blue [c] => blue [d] => blue )21、array_filter() 用回调函数过滤数组中的元素。
function test_odd($var) { return($var & 1); } $a1=array("a","b",2,3,4); print_r(array_filter($a1,"test_odd")); // Array ( [3] => 3 )22、array_flip() 反转/交换数组中的键名和对应关联的键值。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow"); $result=array_flip($a1); print_r($result); // Array ( [red] => a [green] => b [blue] => c [yellow] => d )23、array_column() 返回输入数组中某个单一列的值。
$a = array( array( 'id' => 5698, 'first_name' => 'Peter', 'last_name' => 'Griffin', ), array( 'id' => 4767, 'first_name' => 'Ben', 'last_name' => 'Smith', ), array( 'id' => 3809, 'first_name' => 'Joe', 'last_name' => 'Doe', ) ); $last_names1 = array_column($a, 'last_name'); print_r($last_names1); $last_names2 = array_column($a, 'last_name', 'id'); print_r($last_names2); // 输出1： // Array // ( // [0] => Griffin // [1] => Smith // [2] => Doe ) // 输出2： // Array // ( // [5698] => Griffin // [4767] => Smith // [3809] => Doe // )24、array_combine() 通过合并两个数组（一个为键名数组，一个为键值数组）来创建一个新数组。
$fname=array("Peter","Ben","Joe"); $age=array("35","37","43"); $c=array_combine($fname,$age); print_r($c); // Array ( [Peter] => 35 [Ben] => 37 [Joe] => 43 )25、array_merge() 把一个或多个数组合并为一个数组。
$a1=array("a"=>"red","b"=>"green"); $a2=array("c"=>"blue","b"=>"yellow"); print_r(array_merge($a1,$a2)); // Array([a] => red [b] => yellow [c] => blue)26、array_merge_recursive() 递归地把一个或多个数组合并为一个数组
$a1=array("a"=>"red","b"=>"green"); $a2=array("c"=>"blue","b"=>"yellow"); print_r(array_merge_recursive($a1,$a2)); // Array ( [a] => red [b] => Array ( [0] => green [1] => yellow ) [c] => blue )27、array_product() 计算数组中所有值的乘积。
$a=array(5,5); echo(array_product($a)); // 2528、array_sum() 返回数组中所有值的和。
$a=array(5,15,25); echo array_sum($a); // 45
数组比较函数
1、 array_diff() 比较数组，返回两个数组的差集（只比较键值）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow"); $a2=array("e"=>"red","f"=>"green","g"=>"blue"); $result=array_diff($a1,$a2); print_r($result); // Array ( [d] => yellow )2、array_diff_assoc() 比较数组，返回两个数组的差集（比较键名和键值）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow"); $a2=array("a"=>"red","b"=>"green","c"=>"blue"); $result=array_diff_assoc($a1,$a2); print_r($result); // Array ( [d] => yellow )3、array_diff_key() 比较数组，返回两个数组的差集（只比较键名）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue"); $a2=array("a"=>"red","c"=>"blue","d"=>"pink"); $result=array_diff_key($a1,$a2); print_r($result); // Array ( [b] => green )4、array_diff_uassoc() 比较数组，返回两个数组的差集（比较键名和键值，使用用户自定义的键名比较函数）。
function myfunction($a,$b) { if ($a===$b) { return 0; } return ($a>$b)?1:-1; } $a1=array("a"=>"red","b"=>"green","c"=>"blue"); $a2=array("d"=>"red","b"=>"green","e"=>"blue");
$result = array_diff_uassoc($a1,$a2,"myfunction");
print_r($result); // Array ( [a] => red [c] => blue )
> 5、array_diff_ukey() 比较数组，返回两个数组的差集（只比较键名，使用用户自定义的键名比较函数）。
```php
function myfunction($a,$b) {
if ($a===$b) {
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_diff_ukey($a1,$a2,"myfunction");
print_r($result); // Array ( [c] => blue )6、array_intersect() 比较数组，返回两个数组的交集（只比较键值）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow"); $a2=array("e"=>"red","f"=>"green","g"=>"blue");
$result=array_intersect($a1,$a2);
print_r($result); // Array ( [a] => red [b] => green [c] => blue )
> 7、array_intersect_assoc() 比较数组，返回两个数组的交集（比较键名和键值）。
```php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","c"=>"blue");
$result=array_intersect_assoc($a1,$a2);
print_r($result); // Array ( [a] => red [b] => green [c] => blue )8、array_intersect_key() 比较数组，返回两个数组的交集（只比较键名）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue"); $a2=array("a"=>"red","c"=>"blue","d"=>"pink");
$result=array_intersect_key($a1,$a2);
print_r($result); // Array ( [a] => red [c] => blue )
> 9、array_intersect_uassoc() 比较数组，返回两个数组的交集（比较键名和键值，使用用户自定义的键名比较函数）。
```php
function myfunction($a,$b) {
if ($a===$b) {
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("d"=>"red","b"=>"green","e"=>"blue");
$result=array_intersect_uassoc($a1,$a2,"myfunction");
print_r($result); // Array ( [b] => green )10、array_intersect_ukey() 比较数组，返回两个数组的交集（只比较键名，使用用户自定义的键名比较函数）。
function myfunction($a,$b) { if ($a===$b) { return 0; } return ($a>$b)?1:-1; }
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_intersect_ukey($a1,$a2,"myfunction");
print_r($result); // Array ( [a] => red [b] => green )
> 11、array_udiff() 比较数组，返回两个数组的差集（只比较键值，使用一个用户自定义的键名比较函数）。
```php
function myfunction($a,$b) {
if ($a===$b) {
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_udiff($a1,$a2,"myfunction");
print_r($result); // Array ( [a] => red [b] => green )12、array_udiff_assoc() 比较数组，返回两个数组的差集（比较键名和键值，使用内建函数比较键名，使用用户自定义函数比较键值）。
function myfunction($a,$b) { if ($a===$b) { return 0; } return ($a>$b)?1:-1; } $a1=array("a"=>"red","b"=>"green","c"=>"blue"); $a2=array("a"=>"red","b"=>"blue","c"=>"green");
$result=array_udiff_assoc($a1,$a2,"myfunction");
print_r($result); // Array ( [b] => green [c] => blue )
> 13、array_udiff_uassoc() 比较数组，返回两个数组的差集（比较键名和键值，使用两个用户自定义的键名比较函数）。
```php
function myfunction_key($a,$b) {
if ($a===$b) {
return 0;
}
return ($a>$b)?1:-1;
}
function myfunction_value($a,$b) {
if ($a===$b) {
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","c"=>"green");
$result=array_udiff_uassoc($a1,$a2,"myfunction_key","myfunction_value");
print_r($result); // Array ( [c] => blue )14、array_uintersect() 比较数组，返回两个数组的交集（只比较键值，使用一个用户自定义的键名比较函数）。
function myfunction($a,$b) { if ($a===$b) { return 0; } return ($a>$b)?1:-1; }
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_uintersect($a1,$a2,"myfunction");
print_r($result); // Array ( [c] => blue )
> 15、array_uintersect_assoc() 比较数组，返回两个数组的交集（比较键名和键值，使用内建函数比较键名，使用用户自定义函数比较键值）。
```php
function myfunction($a,$b) {
if ($a===$b) {
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"blue","c"=>"green");
$result=array_uintersect_assoc($a1,$a2,"myfunction");
print_r($result); // Array ( [a] => red )16、array_uintersect_uassoc() 比较数组，返回两个数组的交集（比较键名和键值，使用两个用户自定义的键名比较函数）。
function myfunction_key($a,$b) { if ($a===$b) { return 0; } return ($a>$b)?1:-1; } function myfunction_value($a,$b) { if ($a===$b) { return 0; } return ($a>$b)?1:-1; }
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","c"=>"green");
$result=array_uintersect_uassoc($a1,$a2,"myfunction_key","myfunction_value");
print_r($result); // Array ( [a] => red [b] => green )
#### 数组指针函数
> 1、current() | pos() 返回数组中的当前元素。
```php
$people = array("Peter", "Joe", "Glenn", "Cleveland");
echo current($people) ; // Peter2、next() 将数组中的内部指针向后移动一位。
$people = array("Peter", "Joe", "Glenn", "Cleveland"); echo current($people); // Peter echo next($people); // Joe3、prev() 将数组的内部指针倒回一位。
$people = array("Peter", "Joe", "Glenn", "Cleveland"); echo current($people); // Peter echo next($people); // Joe echo prev($people); // Peter4、reset() 将数组的内部指针指向第一个元素。
$people = array("Peter", "Joe", "Glenn", "Cleveland"); echo current($people); // Peter echo next($people) ;// Joe echo reset($people); // Peter5、end() 将数组的内部指针指向最后一个元素。
$people = array("Peter", "Joe", "Glenn", "Cleveland"); echo current($people) ; // Peter echo end($people); // Cleveland6、count() | sizeof() 返回数组中元素的数目。
$cars=array("Volvo","BMW","Toyota"); echo count($cars); // 3
数组排序函数
1、sort() 对数值数组进行升序排序。
$cars=array("Volvo","BMW","Toyota"); sort($cars);
$clength=count($cars);
for($x=0;$x<$clength;$x++)
{
echo $cars[$x];
echo "
";
}
// 输出：
BMW
Toyota
Volvo
> 2、rsort() 对数值数组进行降序排序。
```php
$cars=array("Volvo","BMW","Toyota");
rsort($cars);
$clength=count($cars);
for($x=0;$x<$clength;$x++)
{
echo $cars[$x];
echo "<br>";
}
// 输出：
Volvo
Toyota
BMW3、ksort() 对关联数组按照键名升序排序。
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43"); ksort($age); foreach($age as $x=>$x_value) { echo "Key=" . $x . ", Value=" . $x_value; echo "<br>"; } // 输出： Key=Ben, Value=37 Key=Joe, Value=43 Key=Peter, Value=354、krsort() 对关联数组按照键名降序排序。
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43"); krsort($age); foreach($age as $x=>$x_value) { echo "Key=" . $x . ", Value=" . $x_value; echo "<br>"; } // 输出： Key=Peter, Value=35 Key=Joe, Value=43 Key=Ben, Value=375、asort() 对关联数组按照键值进行升序排序。
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43"); asort($age); foreach($age as $x=>$x_value) { echo "Key=" . $x . ", Value=" . $x_value; echo "<br>"; } // 输出： Key=Peter, Value=35 Key=Ben, Value=37 Key=Joe, Value=436、arsort() 对关联数组按照键值进行降序排序。
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43"); arsort($age);
foreach($age as $x=>$x_value) {
echo "Key=" . $x . ", Value=" . $x_value;
echo "
";
}
// 输出：
Key=Joe, Value=43
Key=Ben, Value=37
Key=Peter, Value=35
> 7、usort() 使用用户自定义的比较函数对数组进行排序
```php
function my_sort($a,$b) {
if ($a==$b) return 0;
return ($a<$b)?-1:1;
}
$a=array(4,2,8,6);
usort($a,"my_sort");
$arrlength=count($a);
for($x=0;$x<$arrlength;$x++) {
echo $a[$x];
echo "<br>";
}
// 输出：
2
4
6
88、uksort() 使用用户自定义的比较函数对数组中的键名进行排序。
function my_sort($a,$b) { if ($a==$b) return 0; return ($a<$b)?-1:1; }
$a=array(4,2,8,6);
uksort($a,"my_sort");
$arrlength=count($a);
for($x=0;$x<$arrlength;$x++) {
echo "Key=" . $x . ", Value=" . $x_value;
echo "
";
}
// 输出：
Key=a, Value=4
Key=b, Value=2
Key=c, Value=8
Key=d, Value=6
> 9、uasort() 使用用户自定义的比较函数对数组中的键值进行排序。
```php
function my_sort($a,$b) {
if ($a==$b) return 0;
return ($a<$b)?-1:1;
}
$arr=array("a"=>4,"b"=>2,"c"=>8,d=>"6");
uasort($arr,"my_sort");
foreach($arr as $x=>$x_value) {
echo "Key=" . $x . ", Value=" . $x_value;
echo "<br>";
}
// 输出：
Key=b, Value=2
Key=a, Value=4
Key=d, Value=6
Key=c, Value=810、natsort() 用"自然排序"算法对数组排序。
$temp_files = array("temp15.txt","temp10.txt","temp1.txt","temp22.txt","temp2.txt");
sort($temp_files);
echo "Standard sorting: ";
print_r($temp_files);
echo "
";
natsort($temp_files);
echo "Natural order: ";
print_r($temp_files);
// 输出：
Standard sorting: Array ( [0] => temp1.txt [1] => temp10.txt [2] => temp15.txt [3] => temp2.txt [4] => temp22.txt )
Natural order: Array ( [0] => temp1.txt [3] => temp2.txt [1] => temp10.txt [2] => temp15.txt [4] => temp22.txt )
> 11、natcasesort() 用"自然排序"算法对数组进行不区分大小写字母的排序。
```php
$temp_files = array("temp15.txt","Temp10.txt",
"temp1.txt","Temp22.txt","temp2.txt");
natsort($temp_files);
echo "Natural order: ";
print_r($temp_files);
echo "<br />";
natcasesort($temp_files);
echo "Natural order case insensitve: ";
print_r($temp_files);
//上面代码将输出：
Natural order:
Array
(
[0] => Temp10.txt
[1] => Temp22.txt
[2] => temp1.txt
[4] => temp2.txt
[3] => temp15.txt
)
Natural order case insensitve:
Array
(
[2] => temp1.txt
[4] => temp2.txt
[0] => Temp10.txt
[3] => temp15.txt
[1] => Temp22.txt
)12、shuffle() 把数组中的元素按随机顺序重新排列。
$my_array = array("red","green","blue","yellow","purple"); shuffle($my_array); print_r($my_array); // Array ( [0] => blue [1] => green [2] => yellow [3] => red [4] => purple )13、array_multisort() 对多个数组或多维数组进行排序。
$a=array("Dog","Cat","Horse","Bear","Zebra"); array_multisort($a); print_r($a); // Array ( [0] => Bear [1] => Cat [2] => Dog [3] => Horse [4] => Zebra )
数学函数
取整、取余函数
1、ceil(): 进一法取整
echo ceil(9.999); // 102、floor(): 舍去法取整
echo floor(9.999); // 93、round(): 浮点数四舍五入
echo round(1.95583, 2); // 1.964、fmod(): 浮点数取余
$x = 5.7; $y = 1.3; echo fmod($x, $y); // 0.5
最大值、最小值、绝对值
1、max(): 求最大值
多个数字或数组 返回其中的最大值 echo max(1, 3, 5, 6, 7); // 7 echo max(array(2, 4, 5)); // 52、min(): 求最小值
echo max(1, 3, 5, 6, 7); // 1 echo max(array(2, 4, 5)); // 23、abs(): 求绝对值
echo(abs(6.7)); // 6.7 echo(abs(-6.7)); // 6.7 echo(abs(-3)); // 3 echo(abs(3)); // 3
数值类型判断
1、is_finite(): 判断是否为有限值。
echo is_finite(2); // 1 echo is_finite(log(0)); // echo is_finite(2000); // 12、is_infinite(): 判断是否为无限值。
echo is_infinite(2); // echo is_infinite(log(0)); // echo is_infinite(2000); // 13、is_nan(): 判断是否为非数值。
echo is_nan(200); // echo is_nan(acos(1.01)); // 1
角度弧度函数
1、pi(): 返回圆周率 PI 的值。
echo pi(); // 3.14159265358982、rad2deg(): 把弧度值转换为角度值。
echo rad2deg(pi()); // 180 echo rad2deg(pi()/4); // 453、deg2rad(): 将角度值转换为弧度值。
随机数相关函数
1、rand(): 返回随机整数。
- mt_rand() 函数是产生随机值的更好选择，返回结果的速度是 rand() 函数的 4 倍。
echo(rand()); // 2044656758 echo(rand()); // 1367782590 echo(rand(10,100)); // 292、mt_rand(): 使用 Mersenne Twister 算法生成随机整数（更好的随机数）。
输入: 最小|最大, 输出: 随机数随机返回范围内的值 echo rand(100000,999999); // 637223 # rand() 函数默认使用 libc 随机数发生器，很多老的 libc 的随机数发生器具有一些不确定和未知的特性而且效率很低； mt_rand() 则是用了 Mersenne Twister 中已知的特性作为随机数发生器，它产生随机数值的平均速度比 libc 提供的 rand() 快四倍。 所以在PHP中mt_rand()函数是非正式用来替换rand()的。3、srand(): 播种随机数生成器。
- 提示：从 PHP 4.2.0 开始，随机数生成器自动播种，因此没有必要使用该函数。
srand(mktime()); echo(rand()); // 632477794、mt_srand(): 播种 Mersenne Twister 随机数生成器。
mt_srand(mktime()); echo(mt_rand()); // 11562434985、getrandmax(): 返回通过调用 rand() 函数显示的随机数的最大可能值。
- 提示：从 PHP 4.2.0 开始，随机数生成器自动播种，因此没有必要使用该函数。
echo(mt_getrandmax()); // 21474836476、mt_getrandmax(): 返回通过调用 mt_rand() 函数显示的随机数的最大可能值。
echo(mt_getrandmax()); // 21474836477、lcg_value(): 返回范围为 (0, 1) 的一个伪随机数。
echo lcg_value(); // 0.18644057443034 echo lcg_value(); // 0.54099505751669
幂等相关函数
1、pow() 返回 x 的 y 次方。
echo pow(-1, 20); // 1 基础数|n次方乘方值2、sqrt() 返回一个数的平方根。
echo sqrt(9); //33、log() 返回一个数的自然对数（以 E 为底）。
echo(log(2.7183)); // 1.000006684914 echo(log(2)); // 0.69314718055995 echo(log(1)); // 0 echo(log(0); // -INF4、log10() 返回一个数的以 10 为底的对数。
echo(log10(2.7183)); // 0.43429738512451 echo(log10(2)); // 0.30102999566398 echo(log10(1)); // 0 echo(log10(0); // -INF5、log1p() 返回 log(1+number)
echo(log1p(2.7183)); // 1.3132665745863 echo(log1p(2)); // 1.0986122886681 echo(log1p(1)); // 0.69314718055995 echo(log1p(0)); // 06、exp() 返回 E^x 的值。
echo(exp(0)); // 1 echo(exp(1)); // 2.718281828459 echo(exp(10)); // 22026.465794807 echo(exp(4.8)); //121.510417518737、expm1() 返回 Ex - 1 的值。
echo(expm1(0)); // 0 echo(expm1(1)); // 1.718281828459 echo(expm1(10)); // 22025.465794807 echo(expm1(4.8)); //120.51041751873
进制转换函数
1、bindec() 把二进制数转换为十进制数。
echo bindec("0011"); // 3 echo bindec("01"); // 1 echo bindec("11000110011"); // 1587 echo bindec("111"); // 72、decbin() 把十进制数转换为二进制数。
echo decbin("3"); // 11 echo decbin("1"); // 1 echo decbin("1587"); // 11000110011 echo decbin("7"); // 1113、dechex() 把十进制数转换为十六进制数。
echo dechex("30"); // 1e echo dechex("10"); // a echo dechex("1587"); // 633 echo dechex("70"); // 464、hexdec() 把十六进制数转换为十进制数。
echo hexdec("1e"); // 30 echo hexdec("a"); // 10 echo hexdec("11ff"); // 4607 echo hexdec("cceeff"); // 134305275、decoct() 把十进制数转换为八进制数。
echo decoct("30"); // 36 echo decoct("10"); // 12 echo decoct("1587"); // 3063 echo decoct("70"); // 1066、octdec() 把八进制数转换为十进制数。
echo octdec("36"); // 30 echo octdec("12"); // 10 echo octdec("3063"); // 1587 echo octdec("106"); // 707、base_convert() 在任意进制之间转换数字。
语法：base_convert(number,frombase,tobase); 参数 描述 number 必需。规定要转换的数。 frombase 必需。规定数字原来的进制。介于 2 和 36 之间（包括 2 和 36）。高于十进制的数字用字母 a-z 表示，例如 a 表示 10，b 表示 11 以及 z 表示 35。 tobase 必需。规定要转换的进制。介于 2 和 36 之间（包括 2 和 36）。高于十进制的数字用字母 a-z 表示，例如 a 表示 10，b 表示 11 以及 z 表示 35。
$hex = "E196";
echo base_convert($hex,16,8); // 160626
#### 三角函数
> 1、asin() 返回一个数的反正弦。
```php
echo(asin(0.64)); 0.69449826562656
echo(asin(-0.4)); // -0.41151684606749
echo(asin(0)); // 0
echo(asin(-1)); // -1.5707963267949
echo(asin(1)); // 1.5707963267949
echo(asin(2)); // NAN2、asinh() 返回一个数的反双曲正弦。
echo(asinh(7)); // 2.6441207610586 echo(asinh(56)); //4.7185785811518 echo(asinh(2.45)); //1.62849981928423、acos() 返回一个数的反余弦。
echo(acos(0.64) ); // 0.87629806116834 echo(acos(-0.4)); // 1.9823131728624 echo(acos(0)); // 1.5707963267949 echo(acos(-1)); // 3.1415926535898 echo(acos(1)); // 0 echo(acos(2)); // NAN4、acosh() 返回一个数的反双曲余弦。
echo(acosh(7));// 2.6339157938496 echo(acosh(56));// 4.7184191423729 echo(acosh(2.45));// 1.54471311787075、atan() 返回一个数的反正切。
echo(atan(0.50)); // 0.46364760900081 echo(atan(-0.50)); // -0.46364760900081 echo(atan(5)); // 1.373400766945 echo(atan(-5)); // -1.373400766945 echo(atan(100)); // 1.5607966601082 echo(atan(-100)); // -1.56079666010826、atanh() 返回一个数的反双曲正切。
echo(atanh(M_PI_4)); // 1.0593061708232 echo(atanh(0.50)); // 0.54930614433405 echo(atanh(-0.50)); // -0.54930614433405 echo(atanh(1)); // INF echo(atanh(-1)); // -INF7、sin() 返回一个数的正弦。
echo(sin(3)); // 0.14112000805987 echo(sin(-3)); // -0.14112000805987 echo(sin(0)); // 0 echo(sin(M_PI)); // 1.2246467991474E-16 echo(sin(M_PI_2)); // 18、sinh() 返回一个数的双曲正弦。
echo(sinh(3)); // 10.01787492741 echo(sinh(-3)); // -10.01787492741 echo(sinh(0)); // 0 echo(sinh(M_PI)); // 11.548739357258 echo(sinh(M_PI_2)); // 2.30129890230739、cos() 返回一个数的余弦。
echo(cos(3)); // -0.98999249660045 echo(cos(-3)); // -0.98999249660045 echo(cos(0)); // 1 echo(cos(M_PI)); // -1 echo(cos(2*M_PI)); // 110、cosh() 返回一个数的双曲余弦。
echo(cosh(3)); // 10.067661995778 echo(cosh(-3)); // 10.067661995778 echo(cosh(0)); // 1 echo(cosh(M_PI)); // 11.591953275522 echo(cosh(2*M_PI)); // 267.7467614837511、tan() 返回一个数的正切。
echo(tan(M_PI_4)); // 1 echo(tan(0.50)); // 0.54630248984379 echo(tan(-0.50)); // -0.54630248984379 echo(tan(5)); // -3.3805150062466 echo(tan(10)); // 0.64836082745909 echo(tan(-5)); // 3.3805150062466 echo(tan(-10)); // -0.6483608274590912、tanh() 返回一个数的双曲正切。
echo(tanh(M_PI_4)); // 0.65579420263267 echo(tanh(0.50)); // 0.46211715726001 echo(tanh(-0.50)); // -0.46211715726001 echo(tanh(5)); // 0.9999092042626 echo(tanh(10)); // 0.99999999587769 echo(tanh(-5)); // -0.9999092042626 echo(tanh(-10)); // -0.9999999958776913、atan2() 返回两个变量 x 和 y 的反正切。
echo(atan2(0.50,0.50)); // 0.78539816339745 echo(atan2(-0.50,-0.50)); // -2.3561944901923 echo(atan2(5,5)); // 0.78539816339745 echo(atan2(10,20)); // 0.46364760900081 echo(atan2(-5,-5)); // -2.3561944901923 echo(atan2(-10,10)); // -0.7853981633974514、hypot() 计算直角三角形的斜边长度。
- hypot() 函数计算直角三角形的斜边长度。 提示：该函数等同于 sqrt(xx + yy)。
echo hypot(3,4); // 5 echo hypot(4,6); // 7.211102550928 echo hypot(1,3); // 3.1622776601684 echo sqrt(3*3+4*4); // 5
目录、文件函数
目录函数
1、is_dir(): 检查指定的文件是否是一个目录。
2、dir() 返回 Directory 类的实例。
$d = dir(getcwd()); echo "Handle: " . $d->handle . "<br>"; echo "Path: " . $d->path . "<br>"; while (($file = $d->read()) !== false){ echo "filename: " . $file . "<br>"; } $d->close();
结果：
Handle: Resource id #2
Path: /etc/php
filename: .
filename: ..
filename: index.php
> 3、getcwd() 返回当前工作目录。
```php
echo getcwd(); // /home/php4、opendir()) 打开目录句柄。
$dir = "/images/"; if (is_dir($dir)){ if ($dh = opendir($dir)){ while (($file = readdir($dh)) !== false){ echo "filename:" . $file . "<br>"; } closedir($dh); } } 结果： filename: cat.gif filename: dog.gif filename: horse.gif5、readdir() 返回目录中的条目。
6、rewinddir() 重置目录句柄。
$dir = "/images/"; // 打开目录并读取内容 if (is_dir($dir)){ if ($dh = opendir($dir)){ // 列出 images 目录的文件 while (($file = readdir($dh)) !== false){ echo "filename:" . $file . "<br>"; } rewinddir(); // 再次列出 images 目录中的文件 while (($file = readdir($dh)) !== false){ echo "filename:" . $file . "<br>"; } closedir($dh); } } 结果： filename: cat.gif filename: dog.gif filename: horse.gif filename: cat.gif filename: dog.gif filename: horse.gif7、scandir() 返回指定目录中的文件和目录的数组。
$dir = "/images/"; $a = scandir($dir); $b = scandir($dir,1); print_r($a); print_r($b);
结果：
Array
(
[0] => .
[1] => ..
[2] => cat.gif
[3] => dog.gif
[4] => horse.gif
[5] => myimages
)
Array
(
[0] => myimages
[1] => horse.gif
[2] => dog.gif
[3] => cat.gif
[4] => ..
[5] => .
)
> 8、closedir() 关闭目录句柄。
> 9、chdir() 改变当前的目录
```php
echo getcwd() . "<br>";
chdir("images");
echo getcwd();
结果：
/home/php
/home/php/images10、chroot() 改变根目录。
- chroot() 函数改变当前进程的根目录为 directory，并把当前工作目录改为 “/”。
- 注意：该函数需要 root 权限，且仅在 GNU 和 BSD 系统上仅当使用 CLI、CGI、嵌入式 SAPI 时可用。该函数没有在 Windows 平台上实现。
chroot("/path/to/chroot/"); echo getcwd();
结果：
/
#### 文件函数
##### 1、路径相关函数
> 1、dirname() 返回路径中的目录名称部分。
> 2、basename() 返回路径中的文件名部分。
> 3、pathinfo() 返回关于文件路径的信息。
> 4、realpath() 返回绝对路径名。
##### 2、ini配置函数
> 1、parse_ini_file() 解析一个配置文件。
> 2、parse_ini_string() 解析一个配置字符串。
##### 3、缓冲相关函数
> 1、set_file_buffer() 设置已打开文件的缓冲大小。
> 2、realpath_cache_get() 返回高速缓存条目。
> 3、realpath_cache_size() 返回高速缓存大小。
> 4、clearstatcache() 清除文件状态缓存。
##### 4、文件权限
> 1、chgrp() 改变文件组。
> 2、chmod() 改变文件模式。
> 3、chown() 改变文件所有者。
> 4、umask() 改变文件的文件权限。
> 5、lchgrp() 改变符号连接的组所有权。
> 6、lchown() 改变符号连接的用户所有权。
##### 5、磁盘相关
> 1、disk_free_space() 返回目录的可用空间。
> 2、diskfreespace() disk_free_space() 的别名。
> 3、disk_total_space() 返回一个目录的磁盘总容量。
##### 6、文件内容相关
> 1、readfile() 读取一个文件，并写入到输出缓冲。
> 2、fopen() 打开一个文件或 URL。
> 3、fclose() 关闭打开的文件。
> 4、feof() 测试文件指针是否到了文件末尾。
> 5、fflush() 向打开的文件刷新缓冲输出。
> 6、fgetc() 从打开的文件中返回字符。
> 7、fgetcsv() 从打开的文件中解析一行，校验 CSV 字段。
> 8、fgets() 从打开的文件中返回一行。
> 9、fgetss() 从打开的文件中返回一行，并过滤掉 HTML 和 PHP 标签。
> 10、fnmatch() 根据指定的模式来匹配文件名或字符串。
> 11、fpassthru() 从打开的文件中读数据，直到文件末尾（EOF），并向输出缓冲写结果。
> 12、fputcsv() 把行格式化为 CSV 并写入一个打开的文件中。
> 13、fputs() fwrite() 的别名。
> 14、fread() 读取打开的文件。
> 15、fscanf() 根据指定的格式对输入进行解析。
> 16、fseek() 在打开的文件中定位。
> 17、fstat() 返回关于一个打开的文件的信息。
> 18、flock() 锁定或释放文件。
> 19、ftell() 返回在打开文件中的当前位置。
> 20、ftruncate() 把打开文件截断到指定的长度。
> 21、fwrite() 写入打开的文件。
> 22、rewind() 倒回文件指针的位置。
> 23、popen() 打开一个进程。
> 24、pclose() 关闭由 popen() 打开的进程。
> 25、glob() 返回一个包含匹配指定模式的文件名/目录的数组。
##### 7、文件|目录操作
> 1、touch() 设置文件的访问和修改时间。
> 2、move_uploaded_file() 把上传的文件移动到新位置。
> 3、mkdir() 创建目录。
> 4、rename() 重命名文件或目录。
> 5、tempnam() 创建唯一的临时文件。
> 6、tmpfile() 创建唯一的临时文件。
> 7、unlink() 删除文件。
> 8、delete() 参见 unlink() 或 unset()
> 9、rmdir() 删除空的目录。
> 10、copy() 复制文件。
##### 8、文件信息
> 1、file() 把文件读入一个数组中。
> 2、file_exists() 检查文件或目录是否存在。
> 3、file_get_contents() 把文件读入字符串。
> 4、file_put_contents() 把字符串写入文件。
> 5、fileatime() 返回文件的上次访问时间。
> 6、filectime() 返回文件的上次修改时间。
> 7、filegroup() 返回文件的组 ID。
> 8、fileinode() 返回文件的 inode 编号。
> 9、filemtime() 返回文件内容的上次修改时间。
> 10、fileowner() 返回文件的用户 ID （所有者）。
> 11、fileperms() 返回文件的权限。
> 12、filesize() 返回文件大小。
> 13、filetype() 返回文件类型。
##### 9、文件判断
> 1、is_dir() 判断文件是否是一个目录。
> 2、is_executable() 判断文件是否可执行。
> 3、is_file() 判断文件是否是常规的文件。
> 4、is_link() 判断文件是否是连接。
> 5、is_readable() 判断文件是否可读。
> 6、is_uploaded_file() 判断文件是否是通过 HTTP POST 上传的。
> 7、is_writable() 判断文件是否可写。
> 8、is_writeable() is_writable() 的别名。
##### 10、文件连接相关
> 1、link() 创建一个硬连接。
> 2、linkinfo() 返回有关一个硬连接的信息。
> 3、stat() 返回关于文件的信息。
> 4、lstat() 返回关于文件或符号连接的信息。
> 5、symlink() 创建符号连接。
> 6、readlink() 返回符号连接的目标。
### 其他常用函数
#### 类型转换相关函数
> 1、settype() 设置变量的类型
> 2、gettype() 获取变量的类型
> 3、intval() 获取变量的整数值
> 4、boolval() 获取变量的布尔值
> 5、floatval() | doubleval() 获取变量的浮点值
> 6、strval() 获取变量的字符串值
> 7、serialize() 序列化对象
> 8、unserialize() 从已存储的表示中创建 PHP 的值
> 9、debug_zval_dump() 查看一个变量在zend引擎中的引用计数、类型信息
> 10、get_resource_type() 返回资源（resource）类型
> 11、get_defined_vars() 返回由所有已定义变量所组成的数组
> 12、import_request_variables() 将 GET／POST／Cookie 变量导入到全局作用域中
#### 判断相关函数
> 2、is_bool() 检测变量是否是布尔型
> 3、is_callable() 检测参数是否为合法的可调用结构
> 4、is_double() | is_float() 的别名
> 5、is_float() 检测变量是否是浮点型
> 6、is_int() 检测变量是否是整数
> 7、is_integer() is_int 的别名
> 8、is_iterable() 检测变量的内容是否是一个可迭代的值
> 9、is_long is_int() 的别名
> 10、is_null() 检测变量是否为 NULL
> 11、is_numeric() 检测变量是否为数字或数字字符串
> 12、is_object() 检测变量是否是一个对象
> 13、is_real() | is_float() 的别名
> 14、is_resource() 检测变量是否为资源类型
> 15、is_scalar() 检测变量是否是一个标量
> 16、is_string() 检测变量是否是字符串
> 17、empty() 检查一个变量是否为空
> 18、isset() 检测变量是否已设置并且非 NULL
> 19、unset() 释放给定的变量
##### 输出相关函数
> 1、print_r() 打印变量，输出易于阅读的信息。
> 2、var_dump() 打印变量的相关信息
> 3、var_export() 输出或返回一个变量，以字符串形式表示
## 特殊变量
也叫变变量，将一个变量的值设置为另一个变量的名称
> 代码
```php
$x="测试";
$$x="World";
var_dump($x);
echo '<br/>';
var_dump($$x);
echo '<br/>';
var_dump($测试);执行结果
![[img_2024-04-17_22-32-25.png]]
释义
- 将变量x的值设为 '测试'
- 创建一个名为 ‘测试‘ 的变量
- 打印 ’测试‘ 的类型与值
- 不仅可以将变量值设置为变量名，还可以多层嵌套 \$\$\$\$
应用场景
for ($i = 0; $i < 3; $i++) { $Name = "var" . $i; $$Name = '测试:' . $i; } var_dump($var0); echo '<br/>'; var_dump($var1); echo '<br/>'; var_dump($var2); echo '<br/>';执行结果
![[img_2024-04-17_22-31-39.png]]
常量
常量的定义
常量值被定义后不可更改
常量名严格区分大小写，但无需 $ 符
常量默认时全局，可以在脚本的任何位置使用
定义方式有两种（define(’常量名‘,常量值)，const 常量名=常量值）
define('百度','www.baidu.com');
echo 百度;
echo '<br/>';
const 腾讯='www.Tencent.com';
echo 腾讯;
echo '<br/>';
$x=1;
define('var'.$x,'常量值');
echo constant('var1');
echo '<br/>';
echo constant('var'.$x);
echo '<br/>';fefine与const的区别
- const不能定义在方法内
- const用于类程序员常量的定义
- define不可用于类成员常量的定义，可用于全局常量
-
const可以在类内定义，define不可以
类内调用const常量方法
class TestClass { const MB='Hello'; function Test() { echo self::MB; } } $t=new TestClass; $t->Test();
常量与变量的区别
- 常量前面不能有 $ 符号
- 常量可以不用理会变量的作用域在任何地方定义和访问
- 常量一点定义不能重新设置值
- 常量值只能时标量（整数，浮点，布尔，字符串），新版支持数组
获取所有常量
const MB='Hello'; get_define_constants(); get_define_constants(true); get_define_constants(true)['user'];
魔术常量
预定义常量：预定义常量就是PHP内置的常量，预先定义好的
PHP有很多预定义常量，比如：PHP_VERSION（版本号）、PHP_OS（操作系统）。
这些普通的预定义常量在程序中的值是固定的，不会因为在不同的位置而改变自身的值。
在PHP有八个特殊的预定义常量，它们的值会随着它们在代码中的位置改变而改变，我们称之为魔术常量。
PHP的8个魔术常量
| 常量 | 作用 |
|---|---|
| _LINE_ | 返回魔术常量输出时所在的行号 |
| _FILE_ | 返回文件路径（绝对路径） |
| _DIR_ | 返回文件所在的目录，当前文件位置 |
| _FUNCTION_ | 返回函数名称，区分大小写，不在函数中时返回空字符串 |
| _CLASS_ | 返回当前所在类名，包含命名空间，区分大小写 |
| _METHOD_ | 返回当前所在方法名，包含命名空间，区分大小写 |
| _NAMESPACE_ | 返回当前命名空间，区分大小写 |
| _TRAIT_ | 返回当前所在Trait名，包含命名空间，区分大小写 |
class TestClass
{
function Test()
{
echo '所在行号:', __LINE__, '<br/>';
echo '返回文件路径:', __FILE__, '<br/>';
echo '返回文件所在的目录:', __DIR__, '<br/>';
echo '函数名称:', __FUNCTION__, '<br/>';
echo '当前所在类名:', __CLASS__, '<br/>';
echo '前所在方法名:', __METHOD__, '<br/>';
echo '当前命名空间:', __NAMESPACE__, '<br/>';
echo '当前所在Trait名:', __TRAIT__, '<br/>';
}
}
$t = new TestClass;
$t->Test();包含文件
include与require
include与require的区别
- include与require除了错误处理方式不同其他都相同
- requir在产生一个致命错误（E_COMPLIE_ERROR）会停止执行后面的代码
- include产生警告（E_WARNING）后会继续执行后面的代码
- 如果被引用文件时必须文件，则用requir
- 如果被引用文件时可选的，缺失时可继续执行，则使用include
代码
include './index.php';
require './index.php';只引用一次(（防止重复调用）
include_once './index.php'; require_once './index.php';
面向对象
面向对象的三大特征 继承 多态封装
面向对象的内容
类：对一类事务的抽象描述 ，成员包含 属性，方法 例如 电脑为一个类 他的属性有品牌 型号 颜色 类型 尺寸 方法有看电影 听音乐 办公 学习
对象：类的实例，代之某类事务的实体 比如 Apple电脑 型号A2289 颜色为银灰色 类型为笔记本电脑 尺寸为13
能电影 听音乐 办公 学习成员变量：定义在类内部的变量，成员变量有多种访问权限 私有的（private）成员方法可访问 类外部与子类无法访问，公开的（public）类外部、成员方法，子类均可可访问，子类也可访问，受保护的（protected），类成员方法及子类可访问
成员函数：定义在类内部的函数
父类：也叫基类，可以被继承，子类继承后拥有父类所有访问级别为公开（public）的与受保护（protected）的成员（类只能单继承，接口可以多实现）
子类：也叫派生类，继承了其他类的类
继承：父子类共享数据结构与方法，对已有功能可不必重新编写代码
多态：相同的函数作用于不同的对象，并产生不同的结果
重载：重载就是用相同函数名称，但是函数签名不一致（参数列表不一致），这样同名不同参的函数叫重载
抽象性：指将一类具有一致属性与行为的的对象抽象为类，对实体的抽象性描述
封装：将具有每种特定功能的的属性与行为捆绑在一起
构造函数
类
类的定义
类内可以包含常量 函数 变量 等内容
类内一定包含构造函数与析构函数，在未显式声明时类内将包含默认构造函数以析构函数
构造函数在对象创建时调用，析构函数在对象被销毁时调用
销毁对象有两种方式，1、给对象赋值null对象将自动销毁 ，使用unset函数销毁对象
类内未声明访问控制权限的方法默认为公开的（public）
<?php
class ClassName
{
const Version = '20240419'; // 常量
public $Name = ""; // 属性
private $id; // 内部成员变量
static $Count; // 今静态成员
public function SetValue($x) // 成员方法
{
$this->id = $x;
}
public function TestFun() // 成员方法
{
echo 'Version:', self::Version, "<br/>";
echo 'Nmae:', $this->Name, "<br/>";
echo 'id:', $this->Name, "<br/>";
}
public static function StaFun() //成员静态方法
{
echo '静态方法:', __FUNCTION__, "<br/>";
echo '静态成员变量:', self::$Count, "<br/>";
}
}
ClassName::$Count = 100; //设置静态成员变量值
ClassName::StaFun(); //调用静态成员方法
echo ClassName::$Count; //打印静态成员变量
echo "<br/>";
$v = new ClassName(); //创建对象
$v->SetValue(999); //调用赋值方法给内部成员赋值
$v->Name = 'Deepsea'; //设置属性
$v->TestFun(); //调用成员方法- 成员方法调用静态成员变量：self::$Count
- 静态成员方法调用静态成员变量：self::$Count
- 类外部调用静态成员方法 ClassName::StaFun();
- 类外部调用静态成员变量 ClassName::$Count
- 类外部调用成员变量 $v->Name
- 类外部调用成员方法 $v->TestFun();
构造函数__construct
class ClassName
{
public function __construct()
{
echo '构造方法';
}
}php 不支持重载，想要多个参数重载需要通过其他途径，例如使用func_get_args方法
class ClassName
{
public function construct()
{
$fun = func_get_args();
switch (count($fun)) {
case 0:
break;
case 1:
$this->Fun1($fun[0]);
break;
case 2:
$this->Fun2($fun[0],$fun[1]);
break;
case 3:
$this->Fun3($fun[0],$fun[1],$fun[2]);
break;
}
}
function Fun1($x)
{
echo '一个参数构造函数:',$x,'
';
}
function Fun2($x,$y)
{
echo '2个参数构造函数:',$x,'-',$y,'
';
}
function Fun3($x,$y,$z)
{
echo '3个参数构造函数:',$x,'-',$y,'-',$z,'
';
}
function call($name, $arguments)
{
echo '未知方法被唤起','
';
}
}
$a = new ClassName();
$a = new ClassName('A');
$a = new ClassName('A','B');
$a = new ClassName('A','B','C');
$a->Err('','');
### 析构函数__destruct
> 析构函数在对象被销毁时调用，就是生命周期结束时
> 对象除了在生命周期结束自动销毁外还可以通过unset方法手动销毁;
```php
<?php
class ClassName
{
function __construct()
{
echo '构造函数', '<br/>';
}
function Fun()
{
echo '自定义成员方法', '<br/>';
}
function __destruct()
{
echo '析构函数', '<br/>';
}
}
$a = new ClassName();
$a->Fun();魔术方法
PHP的魔术方法（Magic methods）是一组以双下划线(__)开头的特殊方法，它们在满足特定条件时自动被调用。常见的魔术方法包括：
构造函数__construct()
php中构造方法是对象创建完成后第一个被对象自动调用的方法。在每个类中都有一个构造方法，如果没有显示地声明它，那么类中都会默认存在一个没有参数且内容为空的构造方法。
1、 构造方法的作用
通常构造方法被用来执行一些有用的初始化任务，如对成员属性在创建对象时赋予初始值。
2、 构造方法的在类中的声明格式
function __constrct([参数列表]){
方法体 //通常用来对成员属性进行初始化赋值
}3、 在类中声明构造方法需要注意的事项
- 在同一个类中只能声明一个构造方法，原因是，PHP不支持构造函数重载。
- 构造方法名称是以两个下画线开始的__construct()
<?php
class Person
{
public $name;
public $age;
public $sex;
/**
* 显示声明一个构造方法且带参数
*/
public function __construct($name="", $sex="男", $age=22)
{
$this->name = $name;
$this->sex = $sex;
$this->age = $age;
}
/**
* say 方法
*/
public function say()
{
echo "我叫：" . $this->name . "，性别：" . $this->sex . "，年龄：" . $this->age;
}
}创建对象$Person1且不带任参数
$Person1 = new Person();echo $Person1->say(); //输出:我叫：，性别：男，年龄：27创建对象$Person2且带参数“小明”
$Person2 = new Person("小明");echo $Person2->say(); //输出：我叫：张三，性别：男，年龄：27创建对象$Person3且带三个参数
$Person3 = new Person("李四","男",25);echo $Person3->say(); //输出：我叫：李四，性别：男，年龄：25析构函数__destruct()
析造方法的声明格式与构造方法 __construct() 比较类似，也是以两个下划线开始的方法 __destruct() ，这种析构方法名称也是固定的。
1、 析构方法的声明格式
function __destruct(){ //方法体}注意：析构函数不能带有任何参数。
2、 析构方法的作用
- 一般来说，析构方法在PHP中并不是很常用，它属类中可选择的一部分，通常用来完成一些在对象销毁前的清理任务。
举例演示，如下：
<?php
class Person{
public $name;
public $age;
public $sex;
public function __construct($name="", $sex="男", $age=22)
{
$this->name = $name;
$this->sex = $sex;
$this->age = $age;
}
/**
* say 说话方法
*/
public function say()
{
echo "我叫：".$this->name."，性别：".$this->sex."，年龄：".$this->age;
}
/**
* 声明一个析构方法
*/
public function __destruct()
{
echo "我觉得我还可以再抢救一下，我的名字叫".$this->name;
}
}
$Person = new Person("小明");
unset($Person); //销毁上面创建的对象$Person上面的程序运行时输出：
我觉得我还可以再抢救一下，我的名字叫小明_call()，在对象中调用一个不可访问方法时调用。
该方法有两个参数，第一个参数 $function_name 会自动接收不存在的方法名，第二个 $arguments 则以数组的方式接收不存在方法的多个参数。
1、 __call() 方法的格式：
function __call(string $function_name, array $arguments)
{
// 方法体
}2、 __call() 方法的作用：
- 为了避免当调用的方法不存在时产生错误，而意外的导致程序中止，可以使用 __call() 方法来避免。
- 该方法在调用的方法不存在时会自动调用，程序仍会继续执行下去。
<?php
class Person
{
function say()
{
echo "Hello, world!<br>";
}
/**
* 声明此方法用来处理调用对象中不存在的方法
*/
function __call($funName, $arguments)
{
echo "你所调用的函数：" . $funName . "(参数：" ; // 输出调用不存在的方法名
print_r($arguments); // 输出调用不存在的方法时的参数列表
echo ")不存在！<br>\n"; // 结束换行
}
}
$Person = new Person();
$Person->run("teacher"); // 调用对象中不存在的方法，则自动调用了对象中的__call()方法
$Person->eat("小明", "苹果");
$Person->say(); 你所调用的函数：run(参数：Array ( [0] => teacher ) )不存在！
你所调用的函数：eat(参数：Array ( [0] => 小明 [1] => 苹果 ) )不存在！
Hello, world!Debug
显示实际错误信息
- 修改php配置信息，加分号注释掉track_errors=On;
