PHP
PHP（全称：PHP：Hypertext Preprocessor，即"PHP：超文本预处理器"）是一种通用开源脚本语言。
PHP脚本在服务器上执行。
PHP文件
PHP文件可包含HTML、CSS、JavaScript代码和 PHP 代码
PHP代码在服务器上执行，结果以纯 HTML 形式返回给浏览器
PHP 文件的默认文件扩展名是.php
PHP功能
PHP 可以生成动态页面内容
PHP 可以创建、打开、读取、写入、关闭服务器上的文件
PHP 可以收集表单数据
PHP 可以发送和接收 cookies
PHP 可以添加、删除、修改您的数据库中的数据
PHP 可以限制用户访问您的网站上的一些页面
PHP 可以加密数据
通过 PHP，不再限于输出 HTML。您、可以输出图像、PDF 文件，甚至 Flash 电影。还可以输出任意的文本，比如 XHTML 和 XML。
为什么使用 PHP
PHP 可在不同的平台上运行（Windows、Linux、Unix、Mac OS X 等）
PHP 与目前几乎所有的正在被使用的服务器相兼容（Apache、IIS 等）
PHP 提供了广泛的数据库支持(但是无)
PHP 是开源免费: www.php.net
PHP 易于学习
PHP安装
Web 服务器(Apache)
MySQL数据库
集成服务器组件
Windows 系统可以使用 WampServer
XAMPP 支持 Mac OS 和 Windows 系统
IDE集成开发环境
Eclipse for PHP（免费开源）
PhpStorm（收费）
PHP语法
PHP 脚本在服务器上执行，然后将纯 HTML 结果发送回浏览器。
PHP标签
PHP 脚本可以放在文档中的任何位置。
<?php //PHP代码 ?>
PHP 脚本以 结束.
PHP注释
<!DOCTYPE html> <html> <body> <h1>My first PHP page</h1> <?php // 这是 PHP 单行注释 /* 这是 PHP 多行 注释 */ echo "Hello World!"; ?> </body> </html>
PHP变量
变量以 $ 符号开始，后面跟着变量的名称
变量名必须以字母或者下划线字符开始
变量名只能包含字母、数字以及下划线（A-z、0-9 和 _ ）
变量名不能包含空格
变量名是区分大小写的（$y 和 $Y 是两个不同的变量）
<?php $txt="Hello world!"; $x=5; $y=10.5; ?>
PHP 是一门弱类型语言，PHP 会根据变量的值，自动把变量转换为正确的数据类型。在强类型的编程语言中，必须在使用变量前先声明（定义）变量的类型和名称。
PHP 变量作用域
变量的作用域是脚本中变量可被引用/使用的部分。
local
global
static
parameter
局部和全局作用域
在所有函数外部定义的变量，拥有全局作用域。除了函数外，全局变量可以被脚本中的任何部分访问，要在一个函数中访问一个全局变量，需要使用 global 关键字。在 PHP 函数内部声明的变量是局部变量，仅能在函数内部访问;
<?php $x=5; // 全局变量 function myTest() { $y=10; // 局部变量 echo "<p>测试函数内变量:<p>"; echo "变量 x 为: $x"; //没使用global, echo "<br>"; echo "变量 y 为: $y"; } myTest(); echo "<p>测试函数外变量:<p>"; echo "变量 x 为: $x"; echo "<br>"; echo "变量 y 为: $y"; ?>
global关键字
global关键字用于函数内访问全局变量。在函数内调用函数外定义的全局变量，需要在函数中的变量前加上 global 关键字：
<?php $x=5; $y=10; function myTest() { global $x,$y; $y=$x+$y; } myTest(); echo $y; // 输出 15 ?>
PHP 将所有全局变量存储在一个名为 $GLOBALS[index] 的数组中。 index 保存变量的名称。这个数组可以在函数内部访问，也可以直接用来更新全局变量。
<?php $x=5; $y=10; function myTest() { $GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y']; } myTest(); echo $y; ?>
Static作用域
当一个函数完成时，它的所有变量通常都会被删除。有时候希望某个局部变量不要被删除。需要第一次声明变量时使用 static 关键字：
<?php function myTest() { static $x=0; echo $x; $x++; echo PHP_EOL; // 换行符 } myTest(); myTest(); myTest(); ?>
参数作用域
参数是通过调用代码将值传递给函数的局部变量。参数是在参数列表中声明的，作为函数声明的一部分：
<?php function myTest($x) { echo $x; } myTest(5); ?>
echo/print 语句
<?php $txt1="PHP"; $txt2="PHP2"; $cars=array("Volvo","BMW","Toyota"); echo $txt1; echo "<br>"; echo "在字符串中显示 $txt2 变量 "; print "<br>"; print "字符串中显示数组 {$cars[0]}"; ?>
EOF
- 必须后接分号，否则编译通不过。
- EOF 可以用任意其它字符代替，只需保证结束标识与开始标识一致。
- 结束标识必须顶格独自占一行(即必须从行首开始，前后不能衔接任何空白和字符)。
- 开始标识可以不带引号或带单双引号，不带引号与带双引号效果一致，解释内嵌的变量和转义符号，带单引号则不解释内嵌的变量和转义符号。
- 当内容需要内嵌引号（单引号或双引号）时，不需要加转义符，本身对单双引号转义，此处相当与q和qq的用法。
1.以 <<<EOF 开始标记开始，以 EOF 结束标记结束，结束标记必须顶头写，不能有缩进和空格，且在结束标记末尾要有分号 。
2.开始标记和结束标记相同，比如常用大写的 EOT、EOD、EOF 来表示，但是不只限于那几个(也可以用：JSON、HTML等)，只要保证开始标记和结束标记不在正文中出现即可。
3.位于开始标记和结束标记之间的变量可以被正常解析，但是函数则不可以。在 heredoc 中，变量不需要用连接符 . 或 , 来拼接
<?php $name="php"; $a= <<<EOF "abc"$name "123" EOF; // 结束需要独立一行且前后不能空格 echo $a; ?>
数据类型
// String（字符串） <?php $x = "Hello world!"; echo $x; echo "<br>"; $x = 'Hello world!'; echo $x; ?> // Integer（整型） <?php $x = 5985; var_dump($x); echo "<br>"; $x = -345; // 负数 var_dump($x); echo "<br>"; $x = 0x8C; // 十六进制数 var_dump($x); echo "<br>"; $x = 047; // 八进制数 var_dump($x); ?> // Float（浮点型） <?php $x = 10.365; var_dump($x); echo "<br>"; $x = 2.4e3; var_dump($x); echo "<br>"; $x = 8E-5; var_dump($x); ?> // Boolean（布尔型） $x=true; $y=false; // Array（数组） <?php $cars=array("Volvo","BMW","Toyota"); var_dump($cars); ?> // Object（对象） <?php class Car { var $color; function __construct($color="green") { $this->color = $color; } function what_color() { return $this->color; } } ?> // NULL（空值） <?php $x="Hello world!"; $x=null; var_dump($x); ?> // Resource（资源类型） <?php $c = mysql_connect(); echo get_resource_type($c)."\n"; // 打印：mysql link $fp = fopen("foo","w"); echo get_resource_type($fp)."\n"; // 打印：file $doc = new_xmldoc("1.0"); echo get_resource_type($doc->doc)."\n"; // 打印：domxml document ?>
类型比较
松散比较：使用两个等号 == 比较，只比较值，不比较类型。
严格比较：用三个等号 === 比较，除了比较值，也比较类型。
<?php if(42 == "42") { echo '1、值相等'; } echo PHP_EOL; // 换行符 if(42 === "42") { echo '2、类型相等'; } else { echo '3、类型不相等'; } ?> // 比较 0、false、null <?php echo '0 == false: '; var_dump(0 == false); echo '0 === false: '; var_dump(0 === false); echo PHP_EOL; echo '0 == null: '; var_dump(0 == null); echo '0 === null: '; var_dump(0 === null); echo PHP_EOL; echo 'false == null: '; var_dump(false == null); echo 'false === null: '; var_dump(false === null); echo PHP_EOL; echo '"0" == false: '; var_dump("0" == false); echo '"0" === false: '; var_dump("0" === false); echo PHP_EOL; echo '"0" == null: '; var_dump("0" == null); echo '"0" === null: '; var_dump("0" === null); echo PHP_EOL; echo '"" == false: '; var_dump("" == false); echo '"" === false: '; var_dump("" === false); echo PHP_EOL; echo '"" == null: '; var_dump("" == null); echo '"" === null: '; var_dump("" === null);
PHP常量
设置常量，使用 define() 函数，函数语法如下：
bool define ( string $name , mixed $value [, bool $case_insensitive = false ] )
该函数有三个参数:
name：必选参数，常量名称，即标志符。
value：必选参数，常量的值。
case_insensitive ：可选参数，如果设置为 TRUE，该常量则大小写不敏感，默认是大小写敏感的。
<?php define("GREETING", "Hello World"); function myTest() { echo GREETING; } myTest(); ?>
注意：自 PHP 7.3.0 开始，定义不区分大小写的常量已被弃用。从 PHP 8.0.0 开始，只有 false 是可接受的值，传递 true 将产生一个警告。
字符串运算
<?php $txt1="Hello world!"; $txt2="What a nice day!"; // 连接字符串 echo $txt1 . " " . $txt2; // 计算字符串长度 echo strlen("Hello world!"); // 在字符串内查找一个字符或一段指定的文本 echo strpos("Hello world!","world"); //返回6 ?>
PHP运算符
算数运算符
赋值运算符
递增/递减运算符
比较运算符
逻辑运算符
数组运算符
<?php $x = array("a" => "red", "b" => "green"); $y = array("c" => "blue", "d" => "yellow"); $z = $x + $y; // $x 和 $y 数组合并 var_dump($z); var_dump($x == $y); var_dump($x === $y); var_dump($x != $y); var_dump($x <> $y); var_dump($x !== $y); ?>
三元运算符
在 PHP7+ 版本多了一个 NULL 合并运算符 ??
<?php // 如果 $_GET['user'] 不存在返回 'nobody'，否则返回 $_GET['user'] 的值 $username = $_GET['user'] ?? 'nobody'; // 类似的三元运算符 $username = isset($_GET['user']) ? $_GET['user'] : 'nobody'; ?>
组合比较符(PHP7+)
PHP7+ 支持组合比较符（combined comparison operator）也称之为太空船操作符，符号为 <=>。组合比较运算符可以轻松实现两个变量的比较，当然不仅限于数值类数据的比较。
$c = $a <=> $b;
如果 $a > $b, 则 $c 的值为 1。
如果 $a == $b, 则 $c 的值为 0。
如果 $a < $b, 则 $c 的值为 -1。
<?php // 整型 echo 1 <=> 1; // 0 echo 1 <=> 2; // -1 echo 2 <=> 1; // 1 // 浮点型 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1 // 字符串 echo "a" <=> "a"; // 0 echo "a" <=> "b"; // -1 echo "b" <=> "a"; // 1 ?>
运算符优先级
<?php // 优先级： && > = > and // 优先级： || > = > or $a = 3; $b = false; $c = $a or $b; var_dump($c); // 这里的 $c 为 int 值3，而不是 boolean 值 true $d = $a || $b; var_dump($d); //这里的 $d 就是 boolean 值 true ?>
条件语句
if 语句 - 在条件成立时执行代码
if...else 语句 - 在条件成立时执行一块代码，条件不成立时执行另一块代码
if...elseif....else 语句 - 在若干条件之一成立时执行一个代码块
switch 语句 - 在若干条件之一成立时执行一个代码块
<?php $t=date("H"); if ($t<"10") { echo "Have a good morning!"; } elseif ($t<"20") { echo "Have a good day!"; } else { echo "Have a good night!"; } ?>
switch
<?php $favcolor="red"; switch ($favcolor) { case "red": echo "你喜欢的颜色是红色!"; break; case "blue": echo "你喜欢的颜色是蓝色!"; break; case "green": echo "你喜欢的颜色是绿色!"; break; default: echo "你喜欢的颜色不是 红, 蓝, 或绿色!"; } ?>
数组
array();
数值数组 - 带有数字 ID 键的数组
<?php $cars=array("Volvo","BMW","Toyota"); $arrlength=count($cars); for($x=0;$x<$arrlength;$x++) { echo $cars[$x]; echo "<br>"; } ?>
关联数组 - 带有指定的键的数组，每个键关联一个值
<?php $age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43"); foreach($age as $x=>$x_value) { echo "Key=" . $x . ", Value=" . $x_value; echo "<br>"; } ?>
数组排序方法:
sort() - 对数组进行升序排列
rsort() - 对数组进行降序排列
asort() - 根据关联数组的值，对数组进行升序排列
ksort() - 根据关联数组的键，对数组进行升序排列
arsort() - 根据关联数组的值，对数组进行降序排列
krsort() - 根据关联数组的键，对数组进行降序排列
PHP 超级全局变量
PHP中预定义了几个超级全局变量（superglobals） ，这意味着它们在一个脚本的全部作用域中都可用。 你不需要特别说明，就可以在函数及类中使用。
PHP 超级全局变量列表:
$GLOBALS $_SERVER $_REQUEST $_POST $_GET $_FILES $_ENV $_COOKIE $_SESSION
$GLOBALS
$GLOBALS 是PHP的一个超级全局变量组，在一个PHP脚本的全部作用域中都可以访问。
$GLOBALS 是一个包含了全部变量的全局组合数组。变量的名字就是数组的键。
<?php $x = 75; $y = 25; function addition() { $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y']; } addition(); echo $z; ?>
变量z是一个$GLOBALS数组中的超级全局变量，该变量同样可以在函数外访问。
$_SERVER
$_SERVER 是一个包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组。这个数组中的项目由 Web 服务器创建。不能保证每个服务器都提供全部项目；服务器可能会忽略一些，或者提供一些没有在这里列举出来的项目。
<?php echo $_SERVER['PHP_SELF']; echo "<br>"; echo $_SERVER['SERVER_NAME']; echo "<br>"; echo $_SERVER['HTTP_HOST']; echo "<br>"; echo $_SERVER['HTTP_REFERER']; echo "<br>"; echo $_SERVER['HTTP_USER_AGENT']; echo "<br>"; echo $_SERVER['SCRIPT_NAME']; ?>
$_POST
$_POST 被广泛应用于收集表单数据，在HTML form标签的指定该属性："method="post"。
一个输入字段（input）及提交按钮(submit)的表单(form)。 当用户通过点击 "Submit" 按钮提交表单数据时, 表单数据将发送至
标签中 action 属性中指定的脚本文件。 在这里指定文件来处理表单数据。如果希望其他的PHP文件来处理该数据，可以修改该指定的脚本文件名。 然后使用超级全局变量 $_POST 来收集表单中的 input 字段数据:
<html> <body> <form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>"> Name: <input type="text" name="fname"> <input type="submit"> </form> <?php $name = $_POST['fname']; echo $name; ?> </body> </html>
$_GET
$_GET 同样被广泛应用于收集表单数据，在HTML form标签的指定该属性："method="get"。
$_GET 也可以收集URL中发送的数据。
<html> <body> <a href="test_get.php?subject=PHP&web=baidu.com">Test $GET</a> </body> </html>
接收端,通过$_GET['subject']获取url中的参数
<html> <body> <?php echo "Study " . $_GET['subject'] . " @ " . $_GET['web']; ?> </body> </html>
循环
while - 只要指定的条件成立，则循环执行代码块
<?php $i=1; while($i<=5) { echo "The number is " . $i . "<br>"; $i++; } ?>
do...while - 首先执行一次代码块，然后在指定的条件成立时重复这个循环
<?php $i=1; do { $i++; echo "The number is " . $i . "<br>"; } while ($i<=5); ?>
for - 循环执行代码块指定的次数
初始值：主要是初始化一个变量值，用于设置一个计数器（但可以是任何在循环的开始被执行一次的代码）。
条件：循环执行的限制条件。如果为 TRUE，则循环继续。如果为 FALSE，则循环结束。
增量：主要用于递增计数器（但可以是任何在循环的结束被执行的代码）。
<?php for ($i=1; $i<=5; $i++) { echo "数字为 " . $i . PHP_EOL; } ?>
foreach - 根据数组中每个元素来循环代码块
//数值型数组 <?php $x=array("Google","Baidu","Bing"); foreach ($x as $value) { echo $value . PHP_EOL; } ?> //键值对数组 <?php $x=array(1=>"Google", 2=>"Baidu", 3=>"Bing"); foreach ($x as $key => $value) { echo "key 为 " . $key . "，对应的 value 为 ". $value . PHP_EOL; } ?>
函数
内置函数
自定义函数
<?php function add($x,$y) { $total=$x+$y; return $total; } echo "1 + 16 = " . add(1,16); ?>
变量函数
<?php class Foo { function Variable() { $name = 'Bar'; $this->$name(); // 调用 Bar() 方法 } function Bar() { echo "This is Bar"; } } $foo = new Foo(); $funcname = "Variable"; $foo->$funcname(); // 调用 $foo->Variable() ?>
魔术常量
<?php echo '这是第 " ' . __LINE__ . ' " 行'; echo '该文件位于 " ' . __FILE__ . ' " '; echo '该文件位于 " ' . __DIR__ . ' " '; function test() { echo '函数名为：' . __FUNCTION__ ; } test(); class test { function _print() { echo '类名为：' . __CLASS__ . "<br>"; echo '函数名为：' . __FUNCTION__ ; } } $t = new test(); $t->_print(); function test() { echo '函数名为：' . __METHOD__ ; } test(); namespace MyProject; echo '命名空间为："', __NAMESPACE__, '"'; // 输出 "MyProject" ?>
命名空间(namespace)
PHP 命名空间(namespace)是在 PHP 5.3 中加入的，目的是解决重名问题，PHP中不允许两个函数或者类出现相同的名字，否则会产生一个致命的错误。
PHP 命名空间可以解决以下两类问题：
用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突。
为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，提高源代码的可读性。
<?php declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码 namespace MyProject { const CONNECT_OK = 1; class Connection { /* ... */ } function connect() { /* ... */ } } namespace AnotherProject { const CONNECT_OK = 1; class Connection { /* ... */ } function connect() { /* ... */ } } namespace { // 全局代码 session_start(); $a = MyProject\connect(); echo MyProject\Connection::start(); } ?>
子命名空间
namespace MyProject\Sub\Level; //声明分层次的单个命名空间 const CONNECT_OK = 1; class Connection { /* ... */ } function Connect() { /* ... */ } ?>
上面创建了常量 MyProject\Sub\Level\CONNECT_OK，类 MyProject\Sub\Level\Connection 和函数 MyProject\Sub\Level\Connect。
php1.php
<?php namespace Foo\Bar\subnamespace; const FOO = 1; function foo() {} class foo { static function staticmethod() {} } ?>
file2.php
<?php namespace Foo\Bar; include 'file1.php'; const FOO = 2; function foo() {} class foo { static function staticmethod() {} } /* 非限定名称 */ foo(); // 解析为函数 Foo\Bar\foo foo::staticmethod(); // 解析为类 Foo\Bar\foo ，方法为 staticmethod echo FOO; // 解析为常量 Foo\Bar\FOO /* 限定名称 */ subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo, // 以及类的方法 staticmethod echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO /* 完全限定名称 */ \Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo \Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO ?>
命名空间顺序
<?php namespace A; use B\D, C\E as F; // 函数调用 foo(); // 首先尝试调用定义在命名空间"A"中的函数foo() // 再尝试调用全局函数 "foo" \foo(); // 调用全局空间函数 "foo" my\foo(); // 调用定义在命名空间"A\my"中函数 "foo" F(); // 首先尝试调用定义在命名空间"A"中的函数 "F" // 再尝试调用全局函数 "F" // 类引用 new B(); // 创建命名空间 "A" 中定义的类 "B" 的一个对象 // 如果未找到，则尝试自动装载类 "A\B" new D(); // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象 // 如果未找到，则尝试自动装载类 "B\D" new F(); // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象 // 如果未找到，则尝试自动装载类 "C\E" new \B(); // 创建定义在全局空间中的类 "B" 的一个对象 // 如果未发现，则尝试自动装载类 "B" new \D(); // 创建定义在全局空间中的类 "D" 的一个对象 // 如果未发现，则尝试自动装载类 "D" new \F(); // 创建定义在全局空间中的类 "F" 的一个对象 // 如果未发现，则尝试自动装载类 "F" // 调用另一个命名空间中的静态方法或命名空间函数 B\foo(); // 调用命名空间 "A\B" 中函数 "foo" B::foo(); // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法 // 如果未找到类 "A\B" ，则尝试自动装载类 "A\B" D::foo(); // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法 // 如果类 "B\D" 未找到，则尝试自动装载类 "B\D" \B\foo(); // 调用命名空间 "B" 中的函数 "foo" \B::foo(); // 调用全局空间中的类 "B" 的 "foo" 方法 // 如果类 "B" 未找到，则尝试自动装载类 "B" // 当前命名空间中的静态方法或函数 A\B::foo(); // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法 // 如果类 "A\A\B" 未找到，则尝试自动装载类 "A\A\B" \A\B::foo(); // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法 // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B" ?>
类
类使用 class 关键字后加上类名定义。
类名后的一对大括号({})内可以定义变量和方法。
类的变量使用 var 来声明, 变量也可以初始化值。
函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。
类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
对象 − 是类的实例。
成员变量 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可成为对象的属性。
成员函数 − 定义在类的内部，可用于访问对象的数据。
继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
子类 − 一个类继承其他类称为子类，也可称为派生类。
多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
构造函数 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。
<?php class Site { /* 成员变量 */ var $url; var $title; /* 成员函数 */ function setUrl($par){ $this->url = $par; } function getUrl(){ echo $this->url . PHP_EOL; } function setTitle($par){ $this->title = $par; } function getTitle(){ echo $this->title . PHP_EOL; } } $taobao = new Site(); $google = new Site(); // 调用成员函数，设置标题和URL $taobao->setTitle( "淘宝" ); $google->setTitle( "Google 搜索" ); $taobao->setUrl( 'www.taobao.com' ); $google->setUrl( 'www.google.com' ); // 调用成员函数，获取标题和URL $taobao->getTitle(); $google->getTitle(); $taobao->getUrl(); $google->getUrl(); ?>
静态变量和静态方法
类中静态变量、静态方法、常量都用::访问.
静态类内部调用静态类使用self:: ,静态类外部调用使用类名::
static::访问当前类的方法
class MyClass { public static $myStaticProperty = 'Hello'; const MY_CONSTANT = 'constant value'; public static function myStaticMethod() { return 'World'; } } echo MyClass::$myStaticProperty; // 输出: Hello echo MyClass::myStaticMethod(); // 输出: World echo MyClass::MY_CONSTANT; // 输出: constant value
static::和self::区别
self::关键字用于访问当前类中定义的静态属性和方法。无论是在当前类还是在继承类中使用self::时，它总是指向最初定义方法或属性的类。即使子类覆盖了父类的静态方法，调用这个静态方法时也会使用父类中的版本。
static::的行为更加灵活，因为它在运行时决定应该调用哪个类的方法或访问哪个类的属性。如果你在子类中使用static::调用一个静态方法，它会调用那个子类中的方法（如果子类覆盖了该方法的话），而不是父类中的版本。
这使得static::特别适合在设计可扩展的类层次结构时使用，因为它允许子类覆盖父类的静态方法。
