PHP初步学习

8/13/2024, 7:18:59 PM

开发

后端

PHP 学习文档

简介

PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言；很多时候你大可以吧PHP当作服务端的一种类似JavaScript即可。

对比Java的优势

Php是解释执行的服务器脚本语言，首先php有简单容易上手的特点。语法和c语言比较象，所以学过c语言的程序员可以很快的熟悉php的开发。 PHP适合于快速开发，中小型应用系统，开发成本低，能够对变动的需求作出快速的反应。而Java适合于开发大型的应用系统，应用的前景比较广阔，系统易维护、可复用性较好。还有，同样功能的系统用Java开发的系统要比PHP开发的系统的价格要高.

对比Java的劣势

PHP只能实现简单的分布式两层或三层的架构，而JAVA在这方面就比较强大，可以实现多层的网络架构。数据库层(持久化层)、应用(业务)逻辑层、表示逻辑层彼此分开，而且现在不同的层都已经有一些成熟的开发框架的支持。

PHP开发的程序的源代码都是公开的，他人拿到php开发的程序后都可以进行修改；Java开发的程序，最后用户拿到的是只是一些编译好的class类，无法看到完整的源代码，安全性高。

PHP一般来说，性能不如Java。

安装环境

apache执行环境
PHP直接解释执行

语法

虽然PHP在某些情况下允许省略分号(语句块结束或文件结束时候)，但遵循最佳实践，即在所有PHP语句的末尾都加上分号，是一个好习惯。

文件规范

PHP 脚本可以放在文档中的任何位置。PHP 脚本以<?php开始，以?>结束(即使在php文件中，这种开始和结束标签也要加); 有两种在浏览器输出文本的基础指令：echo 和 print。

注释

<!DOCTYPE html>
<html>
<body>
    <?php
        // 这是 PHP 单行注释
        /*
        这是 
        PHP 多行
        注释
        */
    ?>
</body>
</html>

变量和变量作用域

PHP变量以 $ 符号开始，后面跟着变量的名称；不必向PHP声明该变量的数据类型，PHP根据变量的值，自动把变量转换为正确的数据类型。同样的函数不可在同一作用域多次声明，否则报错（不同于JavaScript）；但是变量可以。

PHP 有四种不同的变量作用域：local局部变量、global全局变量、static静态变量、parameter参数作用域

local 本地变量: 函数内能访问本地/局部变量;如果要在一个函数中访问一个全局变量，需要使用 global 关键字。

<?php
$x=5; // 全局变量

function myTest()
{
    $y = 100; // 局部变量
    $y = 1000;
    echo "<p>测试函数内变量:<p>";
    // 不能输出 $x 的值，因为 $x 变量在函数外定义，无法在函数内使用，如果要在一个函数中访问一个全局变量，需要使用 global 关键字。
    echo "变量 x 为: $x";
    echo "<br>";
    echo "变量 y 为: $y";
} 

myTest();

echo "<p>测试函数外变量:<p>";
echo "变量 x 为: $x";
echo "<br>";
echo "变量 y 为: $y";
?>

global 全局变量：全局变量是在函数外部定义的变量，其作用域是整个脚本文件。这意味着，在函数内部，全局变量默认是不可见的。如果你想在函数内部访问全局变量，需要使用global关键字来声明它。

<?php
$x=5;
$y=10;
 
function myTest()
{
    global $x;
    $y = 100;
    $y=$x+$y; // 输出105
    echo $y.'<br/>'; 
    // y=global $x+ global$y; // 这样报错
}
 
myTest();
echo $y.'<br/>'; // 输出 10
?>

PHP 将所有全局变量存储在一个名为 $GLOBALS[index] 的数组中。 index 保存变量的名称。这个数组可以在函数内部访问，也可以直接用来更新全局变量。因此也可以这样改写：

<?php
$x=5;
$y=10;
 
function myTest()
{
    $GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y'];
} 
 
myTest();
echo $y.'<br/>';  // html 中拼接换行符
?>

static 作用域: 当一个函数完成时，它的所有变量通常都会被删除。然而，有时候您希望某个局部变量不要被删除。要做到这一点，请在您第一次声明变量时使用static关键字：

<?php
function myTest()
{
    static $x=0;
    echo $x;
    $x++;
    echo PHP_EOL;    // 换行符，是在html里面输出使用是无效的
}
 
myTest(); // 0
myTest(); // 1
myTest(); // 2
?>

parameter 参数作用域: （类似js的参数）参数是通过调用代码将值传递给函数的局部变量。参数是在参数列表中声明的，作为函数声明的一部分：

<?php
function myTest2($x)
{
    echo $x*2;
}
myTest2(5); // 10
?>

超级全局变量

超级全局变量是 PHP 中特殊的变量集，它们在脚本的全部作用域中都是可用的。这意味着，你无需在函数或方法中使用 global 关键字来访问它们。这些变量是 PHP 预定义的，并且提供了关于服务器、脚本环境、请求和会话的详细信息。

PHP 中的超级全局变量包括：

$GLOBALS：包含了全局作用域中可用的全部变量的一个引用数组。
$_SERVER：包含了诸如头信息(header)、路径(path)和脚本位置(script locations)的服务器和执行环境信息。
$_GET：通过 URL 参数传递给脚本的变量数组。
$_POST：通过 HTTP POST 方法传递给脚本的变量数组。
$_FILES：通过 HTTP POST 方法上传的文件信息。
$_COOKIE：通过 HTTP Cookies 传递给脚本的变量数组。
$_SESSION：会话变量，用于存储关于用户会话的信息。
$_REQUEST：包含了 $_GET、$_POST 和 $_COOKIE 的数组。
$_ENV：包含了通过环境方式传递给脚本的变量的数组。

<?php  
    echo $_GET['name']; // 假设 URL 是 http://example.com/test.php?name=John , 则返回'John'
?>

环境变量的值通常是在服务器级别设置的，而不是在 PHP 脚本中。例如，在 Apache 服务器上，你可以在 .htaccess 文件中使用 SetEnv 指令来设置环境变量：

SetEnv MY_CUSTOM_VAR "some_value"

获取

echo $_ENV['PATH']; // 尝试输出 PATH 环境变量的值

// 另外一种方式读取环境变量
echo getenv('PATH'); // 尝试输出 PATH 环境变量的值
echo getenv('MY_CUSTOM_VAR', 'default_value'); // 如果 MY_CUSTOM_VAR 不存在，则输出 'default_value'

运算符

通常运算符(如加+、减-、乘*、除/、取余%)，和JavaScript一致，但是链接字符串PHP和JavaScript不一样：PHP中a . b才表示连接两个字符串（.前后的空格可选，但是为了可读性，建议加上），而不是JavaScript的加号+

<?php
   $x =  a . b;
?>

另外，PHP 还支持双引号（"）字符串中的变量解析，这意味着你可以直接在双引号字符串中嵌入变量，而不需要使用点（.）来拼接。这种方式在构建包含变量值的字符串时非常方便：

$str1 = "Hello";  
$str2 = "World";  
$result = "$str1 $str2"; // 结果是 "Hello World"，注意这里使用了空格来分隔两个变量

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 是弱类型语言，但也需要明白变量类型及它们的意义，因为我们经常需要对 PHP 变量进行比较，包含松散和严格比较:（和JavaScript一样）

松散比较：使用两个等号 == 比较，只比较值，不比较类型。
严格比较：用三个等号 === 比较，除了比较值，也比较类型。

<?php
if(42 == "42") {
    echo '1、值相等'; // 打印
}
 
echo PHP_EOL; // 换行符
 
if(42 === "42") {
    echo '2、类型相等'; 
} else {
    echo '3、类型不相等'; // 打印这一句
}
?>

此外，空串''、null、整数0、浮点数0.0、字符串"0"、NULL、空数组[] 在 if 语句中被评估时，都被视为false。

但是PHP中不以任何数字开头的字符串和数字比较，会进行隐式转换，被转为数字0：

echo 0 == "a" ? "true" : "false"; // 输出 "true"，因为 "a" 被转换为 0  
echo 0 == "abc" ? "true" : "false"; // 输出 "true"，同样因为 "abc" 被转换为 0

分支条件控制: if-else/switch

if-else

注意PHP的else if连在一起了，写成elseif也是可以的，但是原本的else if 也可以:

<?php
$t=date("H");
if ($t<"10"){
    echo "Have a good morning!";
}elseif ($t<"20"){ // 这里也可以写成 else if
    echo "Have a good day!"; // 执行这个分支语句
}else{
    echo "Have a good night!";
}
?>

此外，空串''、null、整数0、浮点数0.0、字符串"0"、NULL、空数组[] 在 if 语句中被评估时，都被视为false；反之其他的被视为true. 因为在 if 语句中直接使用 ==（宽松比较）, 这种宽松比较方式来转换布尔值。

switch

switch 语句用于根据多个不同条件执行不同动作; 此外switch 语句使用**严格比较（全等比较符 ===）**来匹配其条件与 case 标签。这意味着它会检查值和类型是否都相同。这与在 if 语句中直接使用 ==（等值比较））来比较值有所不同，但在 switch 语句的上下文中，你不需要（也不能）显式指定比较类型。

<?php
$favcolor="red";
switch ($favcolor){
    case "red":
        echo "你喜欢的颜色是红色!"; // 运行此句
    break;
    case "blue":
        echo "你喜欢的颜色是蓝色!";
        break;
    case "green":
        echo "你喜欢的颜色是绿色!";
        break;
    default:
        echo "你喜欢的颜色不是 红, 蓝, 或绿色!";
}
?>

循环条件控制： for/while

while循环

while (条件){
    要执行的代码;
}

案例：

<html>
<body>

<?php
$i=1;
while($i<=5)
{
    echo "The number is " . $i . "<br>";
    $i++;
}
?>

</body>
</html>

do-while循环

do{
    要执行的代码;
}while (条件);

for循环

for (初始值; 条件; 增量)
{
    要执行的代码;
}

案例

<?php
for ($i=1; $i<=5; $i++)
{
    echo "数字为 " . $i . PHP_EOL;
}
?>

foreach 循环 foreach 循环用于遍历数组。

foreach ($array as $element){
    要执行代码;
}

// 进一步，还可以将$element进一步转为 $key和$value分别对应键值对
foreach ($array as $key => $value){
    要执行代码;
}

<?php
$arr=array("Google","Runoob","Taobao");
foreach ($arr as $value){
    echo $value . PHP_EOL;
}

$arr2=array(1=>"Google", 2=>"Runoob", 3=>"Taobao");
foreach ($arr2 as $key => $value){
    echo "key  为 " . $key . "，对应的 value 为 ". $value . PHP_EOL;
}
?>

PHP函数

PHP 的真正威力源自于它的函数。在 PHP 中，提供了超过 1000 个内建的函数。定义PHP函数(跟JavaScript一样)：

<?php
function writeName($fname)
{
    echo $fname . " Refsnes.<br>";
}
 
echo "My name is ";
writeName("Kai Jim");
echo "My sister's name is ";
writeName("Hege");
echo "My brother's name is ";
writeName("Stale");
?>

命名空间(namespace)

PHP 命名空间(namespace)是在 PHP 5.3 中加入的，目的是解决重名问题，PHP中不允许两个函数或者类出现相同的名字，否则会产生一个致命的错误。

PHP 命名空间可以解决以下两类问题：

用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突。
为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，提高源代码的可读性。

定义命名空间

默认情况下，所有常量、类和函数名都放在全局空间下，就和PHP支持命名空间之前一样。命名空间通过关键字namespace 来声明。如果一个文件中包含命名空间，它必须在其它所有代码之前声明命名空间。(一般是第一句话) 语法格式如下:

<?php  
// 定义代码在 'MyProject' 命名空间中  
namespace MyProject;  
 
// ... 代码 ...

存在两种形式，第一种：

<?php  
namespace MyProject;

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */  }

namespace AnotherProject;

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */  }
?>

不建议使用语法在单个文件中定义多个命名空间。建议使用下面的大括号形式的语法。第二种：

<?php
namespace MyProject {
    const CONNECT_OK = 1;
    class Connection { /* ... */ }
    function connect() { /* ... */  }
}

namespace AnotherProject {
    const CONNECT_OK = 1;
    class Connection { /* ... */ }
    function connect() { /* ... */  }
}
?>

在全局的非命名空间使用命名空间中的变量

<?php
namespace MyProject {
    const CONNECT_OK = 1;
    class Connection { /* ... */ }
    function connect() { /* ... */  }
}

namespace { // 全局代码
    session_start();
    $a = MyProject\connect();
    echo MyProject\Connection::start();
}
?>

使用命名空间：

<?php
namespace foo;
use My\Full\Classname as Another; // 导入 My\Full\Classname 并重命名
// 下面的例子与 use My\Full\NSname as NSname 相同
use My\Full\NSname;

// 导入一个全局类
use \ArrayObject;

$obj = new namespace\Another; // 实例化 foo\Another 对象
$obj = new Another; // 实例化 My\Full\Classname　对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象
// 如果不使用 "use \ArrayObject" ，则实例化一个 foo\ArrayObject 对象
?>

常量

PHP 中的常量是指一旦定义后其值不能被改变的标识符。常量值被定义后，在脚本的其他任何地方都不能被改变。常量可以用define()函数或const关键字来定义, 在定义和使用常量的时候不需要使用 $ 符号。

特征：

不变性: 常量一旦定义，其值不能改变；
全局作用域: 常量在定义后，可以在整个脚本的任何地方使用，无需使用 global 关键字；
数据类型: 常量的值可以是标量数据类型（如布尔值、整数、浮点数、字符串）或数组（PHP 7 及以上版本）

<?php
// 区分大小写的常量名
define("GREETING", "欢迎访问 Runoob.com");
echo GREETING;    // 输出 "欢迎访问 Runoob.com"
// 不区分大小写的常量名
define("GREETING1", "欢迎访问 Runoob.com", true);
echo greeting1;  // 输出 "欢迎访问 Runoob.com"

const SITE_URL = "https://www.runoob.com";
echo SITE_URL; // 输出 "https://www.runoob.com"
?>

define 函数声明如下：

bool define ( string $name , mixed $value [, bool $case_insensitive = false ] );

该函数有三个参数:

name：必选参数，常量名称，即标志符。
value：必选参数，常量的值。
case_insensitive ：可选参数，如果设置为 TRUE，该常量则大小写不敏感，默认是大小写敏感的。注意：自 PHP 7.3.0 开始，定义不区分大小写的常量已被弃用。从 PHP 8.0.0 开始，只有 false 是可接受的值，传递 true 将产生一个警告。

预定义常量

PHP 提供了一些预定义常量，可以在脚本中直接使用。这些常量通常用于获取 PHP 的配置信息、版本信息等。常见的预定义常量有：

PHP_VERSION：当前 PHP 解析器的版本。
PHP_OS：服务器的操作系统。
PHP_INT_MAX：最大的整数值。
E_ERROR、E_WARNING、E_PARSE 等：错误报告级别。

魔术常量 __LINE__: 文件中的当前行号 __FILE__: 文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名 __DIR__: 文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。 __NAMESPACE__: 当前命名空间的名称（区分大小写） __FUNCTION__: 函数名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该函数被定义时的名字（区分大小写） __CLASS__: 类的名称（PHP 4.3.0 新加） __METHOD__: 类的方法名（PHP 5.0.0 新加）

EOF定界符--代码换行

EOF（也可以写成EOT）常被用作一种标记来定义多行字符串或代码块的结束。这种方法在 PHP（以及许多其他编程语言中）中非常有用，尤其是在需要嵌入大段文本（如 SQL 查询、HTML 模板、长字符串等）到 PHP 代码中时用来换行。

function  outputhtml(){
     echo  <<<EOT
     <html>
     <head><title>主页</title></head>
     <body>主页内容</body>
     </html>
     EOT;
}

等同于

function  outputhtml(){
     echo  "<html>" ;
     echo  "<head><title>主页</title></head>" ;
     echo  "<body>主页内容</body>" ;
     echo  "</html>;
}

数据类型

PHP 支持以下几种数据类型:

String（字符串）
Integer（整型）: 简写Int
Float（浮点型）
Boolean（布尔型）
Array（数组）
Object（对象）
NULL（空值）
Resource（资源类型）

字符串

字符串可以将任何文本放在单引号和双引号中（同JavaScript）：

<?php 
    $x = "Hello world!";
    echo $x;
    echo "<br>"; 
    $x = 'Hello world!';
    echo $x;
?>

字符串常用函数(全局函数)：

strlen() - 获取字符串的长度（字节数）。注意，对于多字节字符集（如 UTF-8），可能需要使用 mb_strlen() 函数来获取字符数。
strpos() - 查找字符串首次出现的位置。如果未找到字符串，则返回 false
str_replace() - 替换字符串中的一些字符（区分大小写）
strtolower() - 将字符串转换为小写
strtoupper() - 将字符串转换为大写
trim() - 去除字符串两端的空白字符（或其他字符）
substr() - 返回字符串的一部分
str_repeat() - 重复字符串
explode() 函数- 用于把字符串分割成数组。它接受两个参数：第一个参数是分隔符（用于分割字符串的字符或字符串），第二个参数是要分割的字符串(类似js的split)。
str_split() 函数。这个函数将字符串分割成指定长度的多个子字符串，并返回一个包含这些子字符串的数组;

整型-整数

整型可以用三种格式来指定：十进制，十六进制（以 0x 为前缀）或八进制（前缀为 0）

<?php 
    $x = 5985;
    var_dump($x); // int(5985)
    echo "<br>"; 
    $x = -345; // 负数 
    var_dump($x); // int(-345)
    echo "<br>"; 
    $x = 0x8C; // 十六进制数
    var_dump($x); // int(140)
    echo "<br>";
    $x = 047; // 八进制数
    var_dump($x); // int(39)
?>

浮点型-小数

<?php 
    $x = 10.365;
    var_dump($x);  // float(10.365)
    echo "<br>"; 
    $x = 2.4e3;
    var_dump($x); // float(2400)
    echo "<br>"; 
    $x = 8E-5;
    var_dump($x); // float(8.0E-5)
?>

布尔型

布尔型可以是 TRUE 或 FALSE。

<?php
    $x = true;
    $y = false;
    var_dump($x, $y); // bool(true) bool(false)
?>

数组：简介及常用方法

数组可以在一个变量中存储多个值

<?php 
    $cars=array("Volvo","BMW","Toyota");
    var_dump($cars); // array(3) { [0]=> string(5) "Volvo" [1]=> string(3) "BMW" [2]=> string(6) "Toyota" }
?>

数组常用操作函数（注意这些都是全局函数，而不是数组的方法）：

array() 函数用于创建数组
count() 函数用于返回数组的长度（元素的数量）
implode() 和 join() 函数是等价的，它们都用于将数组元素组合成一个字符串。这两个函数接受两个参数：第一个参数是元素之间的分隔符（字符串），第二个参数是要组合的数组。
sort() - 对数组进行升序排列
rsort() - 对数组进行降序排列
json_encode() 函数可以将 PHP 数组转换为 JSON 格式的字符串, 常用于返回json报文
json_decode() 函数是 PHP 中用于将 JSON 格式的字符串转换成 PHP 变量的函数。这个函数非常有用，因为它允许你将存储在 JSON 字符串中的数据转换为 PHP 数组或对象，进而可以在 PHP 脚本中轻松操作这些数据。

数组：类型

PHP 中，有三种类型的数组：（数组的键必须是数字或字符串）

数值数组 - 带有数字 ID 键的数组，最常见（数值数组可以看作是键为数字的特殊关联数组）
关联数组 - 带有指定的键的数组，每个键关联一个值，但是键(Key)的值是字符串
多维数组 - 包含一个或多个数组的数组

数值数组

<?php
    // 方式1创建 数值数组
    $cars=array("Volvo","BMW","Toyota");
    // 方式2创建 数值数组, 不需要声明变量，直接定义数组第1个位置的值即可
    $cars[0]="Volvo";
    $cars[1]="BMW";
    $cars[2]="Toyota";

    echo "I like " . $cars[0] . ", " . $cars[1] . " and " . $cars[2] . ".";
?>

PHP关联数组 关联数组是使用您分配给数组的指定的键的数组

<?php
    $age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
    echo "Peter is " . $age['Peter'] . " years old.";
?>

多维数组

<?php
// 二维数组
$array = array(
    array(1, 2, 3),
    array(4, 5, 6),
    array(7, 8, 9)
);

// 三维数组
$threeDArray = array(
    array(
        array(10, 11),
        array(12, 13)
    ),
    array(
        array(14, 15),
        array(16, 17)
    )
);

$value = $array[1][2]; // 获取值 6
$value = $threeDArray[0][1][1]; // 获取值 13
?>

数组：遍历数组

<?php
// 遍历 数值数组
$cars=array("Volvo","BMW","Toyota");
$arrlength=count($cars);
 
for($x=0;$x<$arrlength;$x++)
{
    echo $cars[$x];
    echo "<br>";
}

// 关联数组
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
foreach($age as $x=>$x_value)
{
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
}
?>

对象

对象数据类型也可以用于存储数据。在 PHP 中，对象必须声明。首先，你必须使用class关键字声明类对象。类是可以包含属性和方法的结构。然后我们在类中定义数据类型，然后在实例化的类中使用数据类型：

注意 JavaScript/java中的.访问属性/方法；而在PHP中用->箭头访问实例属性/方法, 用双冒号::访问静态属性/方法。

<?php
class Car{
  var $color; // 类属性
  function  __construct($color="green") { // 构造函数
    $this->color = $color;
  }
  function what_color() { // 类方法
    return $this->color;
  }
}

function print_vars($obj) {
   foreach (get_object_vars($obj) as $prop => $val) {
     echo "\t $prop = $val \n";
   }
}

// 实例一个对象
$herbie = new Car("white");

// 显示 herbie 属性
echo "\t herbie: Properties \n";
print_vars($herbie);
var_dump($herbie);
?>

get_object_vars() 是 PHP 中的一个内置函数，用于获取由对象属性组成的关联数组；这个函数非常有用，特别是当你需要访问或操作对象的所有公开（public）属性时。需要注意的是，get_object_vars() 函数不会返回受保护（protected）或私有（private）属性，除非你使用了某种反射机制（如 ReflectionClass）来绕过这些访问限制。

NULL

NULL 值表示变量没有值。NULL 是数据类型为 NULL 的值。 NULL 值指明一个变量是否为空值。同样可用于数据空值和NULL值的区别。可以通过设置变量值为 NULL 来清空变量数据：

<?php
    $x="Hello world!";
    $x=null;
    var_dump($x); // NULL
?>

资源类型

PHP 资源 resource 是一种特殊变量，保存了到外部资源的一个引用,常见资源数据类型有打开文件、数据库连接、图形画布区域等。由于资源类型变量保存有为打开文件、数据库连接、图形画布区域等的特殊句柄，因此将其它类型的值转换为资源没有意义。

使用get_resource_type()函数可以返回资源（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 面向对象

PHP中用->箭头访问实例属性/方法, 用双冒号::访问静态属性/方法。

类的定义：构造函数和析构函数

<?php
class Site {
  /* 成员变量 */
  var $url;
  var $title;
  
  /* 成员函数 */
  function setUrl($par){
     $this->url = $par;
  }
  
  // php构造函数，没有返回值
  function __construct( ) {
    echo 'contruct';
  }

  // 当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数；同样，析构函数也没有返回值
  function __destruct() {
    print "销毁 \n";
  }

  function getUrl(){
     echo $this->url . PHP_EOL;
  }
  
  function setTitle($par){
     $this->title = $par;
  }
  
  function getTitle(){
     echo $this->title . PHP_EOL;
  }
}

$runoob = new Site;
$taobao = new Site;
$google = new Site;

// 调用成员函数，设置标题和URL
$runoob->setTitle( "菜鸟教程" );
$taobao->setTitle( "淘宝" );
$google->setTitle( "Google 搜索" );
?>

继承和重写

PHP 使用关键字 extends 来继承一个类，PHP 不支持多继承；另外，如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。此外，PHP 不会在子类的构造方法中自动的调用父类的构造方法。要执行父类的构造方法，需要在子类的构造方法中调用parent::__construct()。

<?php 
// 子类扩展站点类别
class Child_Site extends Site {
   var $category;

    function __construct() {
        parent::__construct();  // 子类构造方法不能自动调用父类的构造方法, 需要手动调用
        print "SubClass 类中构造方法" . PHP_EOL;
    }

    function setCate($par){
        $this->category = $par;
    }
  
    function getCate(){
        echo $this->category . PHP_EOL;
    }

    // 重写父类的 getUrl 的方法
    function getUrl() {
        echo $this->url . PHP_EOL;
        return $this->url;
    }
}

控制访问

PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的:

public（公有）：公有的类成员可以在任何地方被访问;
protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问;
private（私有）：私有的类成员则只能被其定义所在的类访问

类属性必须定义为公有，受保护，私有之一。如果用var定义，则被视为公有。如果方法没有设置这些关键字，则该方法默认为公有.

接口和抽象类

接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。接口中定义的所有方法都必须是公有，这是接口的特性。要实现一个接口，使用implements操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。

<?php

// 声明一个'iTemplate'接口
interface iTemplate
{
    public function setVariable($name, $var);
    public function getHtml($template);
}

// 实现接口
class Template implements iTemplate
{
    private $vars = array();
  
    public function setVariable($name, $var){
        $this->vars[$name] = $var;
    }
  
    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }
        return $template;
    }
}

任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。定义为抽象的类不能被实例化（用来继承和实现接口部分方法）。被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；而且，子类这些实现的抽象方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的而不能定义为私有的；此外，子类方法可以包含父类抽象方法中不存在的可选参数，例如，子类定义了一个可选参数，而父类抽象方法的声明里没有，则也是可以正常运行的。(这两点同JAVA的区别很大)。

<?php
abstract class AbstractClass{
    // 我们的抽象方法仅需要定义需要的参数
    abstract protected function prefixName($name);

}

class ConcreteClass extends AbstractClass{
    // 我们的子类可以定义父类签名中不存在的可选参数
    public function prefixName($name, $separator = ".") {
        if ($name == "Pacman") {
            $prefix = "Mr";
        } elseif ($name == "Pacwoman") {
            $prefix = "Mrs";
        } else {
            $prefix = "";
        }
        return "{$prefix}{$separator} {$name}";
    }
}

$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
?>

static静态成员

声明类属性或方法为static(静态)，就可以不实例化类而直接访问。静态属性不能通过一个类已实例化的对象来访问，但静态方法可以（这么神奇？）, 即静态属性不可以由对象通过->操作符来访问，需要通过双冒号::访问。由于静态方法不需要通过对象即可调用，所以伪变量$this在静态方法中不可用（类似Java中的this，代表本类的实例）。

<?php
class Foo {
  public static $my_static = 'foo';
  
  public function staticValue() {
     // self 代表本类
     return self::$my_static;
  }
}

print Foo::$my_static . PHP_EOL;
$foo = new Foo();

print $foo->staticValue() . PHP_EOL;
?>

类常量-用来模拟枚举

在 PHP 中，类常量是在类中定义的常量值（使用const关键字来定义类常量），一旦定义后其值不能被改变。类常量可以通过类名和作用域解析操作符（::）来访问，无论是否有类的实例存在。需要注意的是，类常量可以通过类名和作用域解析操作符（::）来访问，无论它们是否被定义为静态成员。

类常量是在类中定义的常量值，它们在整个类的范围内都是可见的，并且可以在不创建类的实例的情况下被访问。

例如：

class Color
{
    const RED = 'red';
    const GREEN = 'green';
    const BLUE = 'blue';
}

你可以使用Color::RED、Color::GREEN和Color::BLUE来访问这些常量，而不需要创建Color类的实例。

这与静态成员变量（用static关键字定义的变量）不同，静态成员变量需要通过类名和作用域解析操作符来访问，但它们可以在类的不同实例之间共享状态。而类常量是不可变的值，不能被修改，并且在类的所有实例之间都是相同的。所以，类常量可以通过::访问，即使它们不是静态成员变量。这种行为是 PHP 语言的设计特点之一，使得类常量在一些情况下可以方便地用于表示固定的值或选项，而不需要创建类的实例。

各种关键字

上面面向对象OPP中出现了很多关键字，下面总结一下：

self : 代表本类，用于静态成员的访问，且self不能用来访问非静态成员（即，非静态属性和方法），尝试这样做将导致一个错误；
parent : 代表父类或父类实例，parent关键字用于访问父类的属性、方法或构造函数。在静态上下文中，它同样有效，允许你访问父类的静态成员。
$this伪变量：代表本类的实例
Final 关键字：如果父类中的方法被声明为final，则子类无法覆盖该方法。如果一个类被声明为final，则不能被继承(同Java一样)

打印和调试

PHP 中存在 echo 和 print 语句来打印内容，echo 和 print 区别:

echo - 可以输出一个或多个字符串
print - 只允许输出一个字符串，返回值总为 1

提示：echo 输出的速度比 print 快， echo 没有返回值，print有返回值1。

echo

echo 是一个语言结构，使用的时候可以不用加括号，也可以加上括号： echo 或 echo()。

<?php
    echo "<h2>PHP 很有趣!</h2>";
    echo "Hello world!<br>";
    echo "我要学 PHP!<br>";
    echo "这是一个", "字符串，", "使用了", "多个", "参数。";

    // 打印变量
    $txt1="学习 PHP";
    $txt2="RUNOOB.COM";
    $cars=array("Volvo","BMW","Toyota");
    
    echo $txt1;
    echo "<br>";
    echo "在 $txt2 学习 PHP ";
    echo "<br>";
    echo "我车的品牌是 {$cars[0]}";
?>

print

<?php
    print "<h2>PHP 很有趣!</h2>";
    print "Hello world!<br>";
    print "我要学习 PHP!";

    // 打印变量
    $txt1="学习 PHP";
    $txt2="RUNOOB.COM";
    $cars=array("Volvo","BMW","Toyota");
    
    print $txt1;
    print "<br>";
    print "在 $txt2 学习 PHP ";
    print "<br>";
    print "我车的品牌是 {$cars[0]}";
?>

var_dump

PHPvar_dump()函数返回变量的数据类型和值

<?php 
    $x = 10.365;
    var_dump($x);  // float(10.365)
    echo "<br>"; 
    $x = 2.4e3;
    var_dump($x); // float(2400)
    echo "<br>"; 
    $x = 8E-5;
    var_dump($x); // float(8.0E-5)
?>

print_r

print_r() 以一种易于阅读的方式输出变量的内容。对于数组，它会以树状结构显示数组的元素，但不包括元素的类型（除了说明它们是数组的一部分外;不输出具体类型是和var_dump()最大区别）。对于对象，如果对象实现了 __toString()方法，print_r()会调用该方法；否则，它只会显示对象的类名。

print_r() 的输出通常比 var_dump() 更易于阅读，特别是在处理大型数据结构时;print_r()适用于需要快速查看变量内容，但不需要知道具体类型的场景。

$array = array(1, 2, 3, 'a' => 'apple', 'b' => 'banana');  
echo "<pre>"; // 使用 pre 标签提高可读性  
var_dump($array);  
/*  
array(3) {  
  [0]=>  
  int(1)  
  [1]=>  
  int(2)  
  [2]=>  
  int(3)  
  ["a"]=>  
  string(5) "apple"  
  ["b"]=>  
  string(6) "banana"  
}  
*/  
  
print_r($array);  
/*  
Array  
(  
    [0] => 1  
    [1] => 2  
    [2] => 3  
    [a] => apple  
    [b] => banana  
)  
*/

终止线程: exit()和die()

在 PHP 中，exit()和die()函数实际上是等价的，它们都可以用来终止脚本的执行。这两个函数都接受一个可选的字符串参数，该参数会被输出到浏览器（如果是 Web 环境）或命令行（如果是 CLI 环境），然后脚本执行会立即停止。

<?php  
echo "Hello, world!";  
exit("Exiting the script."); // 或者使用 die("Exiting the script.");  
echo "This line will not be executed.";  // 这句不会执行
?>

调试和断点

在 PHP 中进行断点调试并不像在一些集成开发环境（IDE）中那样直接支持断点调试，如 Java 或 C# 在 Visual Studio 中那样，PHP并没有内置断点调试的插件或功能。但是，有几种方法可以帮助你在 PHP 中进行调试，其中一些方法可以模拟断点调试的行为。

使用 Xdebug 或 Zend Debugger等额外插件: Xdebug 是 PHP 的一个流行扩展，它提供了强大的调试功能，包括断点、步进执行、变量监视等。
使用var_dump()或print_r()再配合exit()或die()
日志记录

进阶

PHP 反射

PHP 枚举

PHP 中没有像 Java 或 C# 那样内置的枚举类型，我们一般采取两种方式模拟：

使用类常量模拟枚举: 推荐

<?php
class Color
{
    const RED = 'red';
    const GREEN = 'green';
    const BLUE = 'blue';
}

$color = Color::GREEN;
if ($color === Color::GREEN) {
    echo "The color is green.";
}
?>

使用类的静态属性模拟枚举

class ColorEnum
{
    private static $colors = [
        'RED' => 'red',
        'GREEN' => 'green',
        'BLUE' => 'blue'
    ];

    public static function getColorValue($key)
    {
        if (isset(self::$colors[$key])) {
            return self::$colors[$key];
        }
        return null;
    }
}

$color = ColorEnum::getColorValue('RED');
if ($color==ColorEnum::getColorValue('RED')) {
    echo "The color is valid.";
}
?>

表单校验

文件处理和文件上传

Cookie和Session以及登录

过滤器

JSON: JSON 相关操作

转为JSON字符串

<?php
// 数组转为JSON字符串
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
echo json_encode($age); // {"Peter":"35","Ben":"37","Joe":"43"}

// 对象转为JSON字符串
class MyObject {  
    public $name = "John";  
    public $age = 30;  
    protected $city = "New York"; // 注意：这个属性在默认情况下不会直接转换为 JSON，因为它是受保护的  
  
    // 一个 getter 方法，允许外部访问受保护的属性  
    public function getCity() {  
        return $this->city;  
    }  
}  
  
$obj = new MyObject();  // 默认情况下，只有公共属性会被转换; 若需要包含受保护的属性（或私有属性），你需要自定义处理逻辑
$json = json_encode($obj);  
echo $json; // 输出: {"name":"John","age":30}  
?>

JSON字符串转为对象或数组

<?php
// 转为对象
$json = '{"name":"John", "age":30, "city":"New York"}';  
$obj = json_decode($json);  
  
echo $obj->name; // 输出: John

// 转为 关联数组
$json = '{"name":"John", "age":30, "city":"New York"}';  
$arr = json_decode($json, true);  // 第二个参数为true，则返回关联数组；为false(默认) 则发挥对象
echo $arr['name']; // 输出: John

// 转为 数值数组，数值数组可以看作key为数字的 特殊关联数组
$jsonString = '[1,2,3,4,5]';
$decodedArray = json_decode($jsonString, true);
print_r($decodedArray);

?>
// 转为对象

多线程

文章目录

简介