PHP程序设计教案

PHP（全称：PHP：Hypertext Preprocessor，即"PHP：超文本预处理器"）是一种通用开源脚本语言


特点
    1.PHP是一种创建动态交互性站点的强有力的[服务器端脚本语言]
      PHP脚本在[服务器]上执行，结果以[纯HTML]形式返回给浏览器

    2.PHP文件可包含文本、HTML、JavaScript代码和 PHP 代码

    3.PHP与目前几乎所有的正在被使用的服务器相兼容（Apache、IIS 等）

    4.PHP文件的默认文件扩展名是 .php

    5.PHP是一门弱类型语言
      不必向 PHP 声明该变量的数据类型，PHP会根据变量的值，自动把变量转换为正确的数据类型

<!DOCTYPE html>
<html>
	<body>

		<?php
			//PHP 代码
			echo "Hello World!";
		?>

	</body>
</html>

2.环境安装

PHP 与 MySQL 结合是跨平台的（您可以在 Windows 上开发，在 Unix 平台上应用）

PHPstudy + MySQL（Navicat 地址1、地址2 提取码24ywt）(MySQL环境)

1.进行环境变量设置
  用户变量：找到MySQL 的 bin 文件路径进行复制
  系统变量Path：%MYSQL_HOME%\bin


2.在Windows的搜索栏内输入cmd打开终端：输入命令：mysql -u root -p，再输入 password为root


3.配置Web Server 、数据库和php 大家可以根据需要安装指定版本软件，点击安装按钮即可


3.连接数据库
    连接名：随便写
    主机名或IP地址：localhost        127.0.0.1
    端口：3306
    用户名
    密码

本地解析：在电脑浏览器请求没有到达DNS服务器之前的host里面验证（有记录就把IP拿过来——>IP地址对应的端口返给浏览器信息）

其他选项
    打开host：127.0.0.1    www.baidu.com
    站点域名管理：
        网站域名：www,baidu.dom

        网站目录：自己搭建网站的文件目录
        网站：管理——>打开根目录



网站：创建新的网站
    1.点击创建网站——>基本配置——>域名
                           ——>端口PHP 端口号
                           ——>同步hosts
                           ——>程序类型PHP

    2.在新站点根目录下添加 index.php 文件
        管理——>打开根目录 ——新建一个 index.php 文件


    3.浏览器测试访问新站点的 index.php 文件
        浏览器输入域名

3. 语法规范

3.1 注释

// 这是 PHP 单行注释


#  与//一样


/*
    这是
    PHP 多行
    注释
*/

3.2 分隔符

英文状态下的分号”;“

3.3 其他规范

PHP是区分大小写的：在PHP中，变量名、函数名、常量名都是区分大小写的

二：基础语法

1.输出

1.1 echo

echo：可以输出一个或多个字符串，没有返回值，输出的速度比 print 快

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


技巧
    echo "<br>";                        //换行

    echo "Hello world!<br>";            //后面换行

    echo "\Hello world!\n";             //后面换行

    //PHP_EOL是一个预定义常量，‌代表当前操作系统中的换行符
    echo "数字为 " . $i . PHP_EOL;

    echo $x ." ";                       //空格间隔开

    echo "<pre>";                       //格式化输出
    echo "</pre>";    

    echo "<hr/>";                       //分割线

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			echo "<h2>PHP 很有趣!</h2>";			    //PHP 很有趣!
			
			echo "Hello world!<br>";				//Hello world!
			
			echo "我要学 PHP!<br>";					//我要学 PHP!
			
            //使用了多个参数:可以一次输出多个值，多个值之间用逗号分隔
			echo "这是一个", "字符串，", "使用了", "多个", "参数。";
			
			$txt1="学习 PHP";
			$txt2="bili.com";
			$cars=array("Volvo","BMW","Toyota");
			
            //引用
			echo $txt1;								//学习 PHP				
			echo "<br>";
			echo "在 $txt2 学习 PHP ";				//在bili.com学习 PHP
			echo "<br>";
			echo "我车的品牌是 {$cars[0]}";			//我车的品牌是 Volvo
		?>
	</body>
</html>

1.2 print

print：只允许输出一个字符串，返回值总为 1
       打印一个值（它的参数），如果字符串成功显示则返回true，否则返回false

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			print "<h2>PHP 很有趣!</h2>";		//PHP 很有趣!
			
			print "Hello world!<br>";			//Hello world!
			
			print "我要学习 PHP!";				//我要学习 PHP!
			
			//引用
			$txt1="学习 PHP";
			$txt2="bili.com";
			$cars=array("Volvo","BMW","Toyota");

			print $txt1;						//学习 PHP
			print "<br>";
			print "在 $txt2 学习 PHP ";			//在 bili.com 学习 PHP
			print "<br>";
			print "我车的品牌是 {$cars[0]}";	//我车的品牌是 Volvo
		?>
	</body>
</html>

1.3 var_dump类型和值

var_dump()函数用于输出变量的详细信息（‌包括类型和值）‌

它对于调试复杂的数据类型（‌如数组和对象）‌特别有用，‌因为它会提供关于变量类型和值的详细输出
    数组将递归展开值，通过缩进显示其结构

举例

$array = array('apple', 'banana', 'cherry');
var_dump($array);


输出
	array(3) {
		=>
		string(5) "apple"
		=>
		string(6) "banana"
		=>
		string(6) "cherry"
	}

1.4 print_r()易读

print_r() 函数用于打印关于变量的易于阅读的信息

它对于打印数组和对象特别有用，‌因为它会以更结构化的格式显示这些信息

举例

$array = array('apple', 'banana', 'cherry');
print_r($array);


输出
	Array
	(
		 => apple
		 => banana
		 => cherry
	)

2.常量变量

2.1 常量

2.1.1 define()/const

什么是常量？
    1.常量是指一旦定义后其值不能被改变的标识符
    2.常量可以用 define()函数   或  const关键字来定义


特点
    1.不变性: 常量一旦定义，其值不能改变
    2.全局作用域: 常量在定义后，可以在整个脚本的任何地方使用，无需使用 global 关键字
    3.数据类型: 常量的值可以是标量数据类型（如布尔值、整数、浮点数、字符串）或数组（及以上版本）
    4.区分大小写: 常量名称默认是区分大小写的

      如果需要定义大小写不敏感的常量，可以在 define() 函数的第三个参数设置true
      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 将产生一个警告

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			//define() 函数
				//区分大小写的常量名
				define("GREETING", "欢迎访问 bili.com");
				echo GREETING;    // 输出 "欢迎访问bili.com"
				echo '<br>';
				echo greeting;   // 输出 "greeting"，但是有警告信息，表示该常量未定义
				
				
				//不区分大小写的常量名
				define("GREETING", "欢迎访问bili.com", true);
				echo greeting;  // 输出 "欢迎访问bili.com"
			
			
			//const 关键字
			const SITE_URL = "https://www.baidu.com";
			echo SITE_URL; // 输出 "https://www.baidu.com"


			//常量是全局的
			define("GREETING", "欢迎访问 bili.com");
			function myTest() {
				echo GREETING;
			}		 
			myTest();    // 输出 "欢迎访问 bili.com"
			
			
			//预定义常量
			echo PHP_VERSION; // 输出 PHP 版本，例如 "7.4.1"
			echo PHP_OS;      // 输出操作系统，例如 "Linux"
			echo PHP_INT_MAX; // 输出最大的整数值，例如 "9223372036854775807"
			
			
			//常量数组
			define("FRUITS", [
				"Apple",
				"Banana",
				"Orange"
			]);
			echo FRUITS[0]; // 输出 "Apple"
		?>
	</body>
</html>

2.1.2 魔术常量

<!DOCTYPE html>
<html>
	<body>
		<?php
			//__LINE__:文件中的当前行号
			echo '这是第 " '  . __LINE__ . ' " 行';					//这是第 “ 2 ” 行
				
				
			//__FILE__:文件的完整路径和文件名
			echo '该文件位于 " '  . __FILE__ . ' " ';				//该文件位于 “ E:\wamp\www\test\index.php ”
			
			
			//__DIR__:文件所在的目录
			echo '该文件位于 " '  . __DIR__ . ' " ';				//该文件位于 “ E:\wamp\www\test ”
			
			
			//__FUNCTION__:函数名称
			function test() {
				echo  '函数名为：' . __FUNCTION__ ;
			}
			test();													//函数名为：test
			
			
			//__CLASS__:类的名称
			class test {
				function _print() {
					echo '类名为：'  . __CLASS__ . "<br>";			//类名为：test
					echo  '函数名为：' . __FUNCTION__ ;				//函数名为：_print
				}
			}
			$t = new test();
			$t->_print();
			
			
			//__METHOD__:类的方法名
			function test() {
				echo  '函数名为：' . __METHOD__ ;					//函数名为：test
			}
			test();
			
			
			//__TRAIT__:Trait 的名字代码复用的一个方法
			class Base {
				public function sayHello() {
					echo 'Hello ';
				}
			}
			 
			trait SayWorld {
				public function sayHello() {
					parent::sayHello();
					echo 'World!';
				}
			}
			 
			class MyHelloWorld extends Base {
				use SayWorld;
			}
			 
			$o = new MyHelloWorld();
			$o->sayHello();											//Hello World!
			
			
			//__NAMESPACE__:当前命名空间的名称（区分大小写）
			namespace MyProject;
			echo '命名空间为："', __NAMESPACE__, '"'; 				// "MyProject"
		?>
	</body>
</html>

2.2 变量$

2.2.1 命名规则

PHP 变量规则：
    1.变量以 $ 符号开始，后面跟着变量的名称

    2.变量名必须以字母或者下划线字符开始（不能以数字开头）

    3.变量名只能包含字母、数字以及下划线（A-z、0-9 和 _ ）

    4.变量名不能包含空格

    5.PHP 语句和 PHP 变量都是区分大小写的
      变量名是区分大小写的（$y 和 $Y 是两个不同的变量）

举例

<!DOCTYPE html>
<html>
	<body>

		<?php
			$x=5;
			$y=6;

			$z=$x+$y;

			echo $z;
		?>

	</body>
</html>

2.2.2 PHP 变量作用域

作用域	描述	解释
local	局部作用域	本地的内部声明的变量是局部变量，仅能在函数内部访问
global	全局作用域	总体的外部定义的变量是全局变量，除了函数外，全局变量可以被脚本中的任何部分访问要在一个函数中访问一个全局变量，需要使用 global 关键字
static	静态作用域	静态的函数执行完成时，若不想局部变量被删除，就在第一次声明变量时使用 static 关键字
parameter	函数参数作用域	参数

<!DOCTYPE html>
<html>
	<body>
		<?php
			$x=5; // 全局变量

			//-------------------------------------------------------------------------------//
			
			function myTest1()
			{
				$y=10; // 局部变量
				echo "变量 x 为: $x";                    //变量 x 为：不能输出 $x 的值（在函数外定义）
				echo "<br>";
				echo "变量 y 为: $y";                    //变量 y 为: 10
			} 

			function myTest2()
			{
				global $x; // 声明要使用的全局变量
				$y=10; // 局部变量
				echo "变量 x 为: $x";                    //变量 x 为：5
				echo "<br>";
				echo "变量 y 为: $y";                    //变量 y 为: 10
			} 

			
			function myTest3() {
				static $x=0;
				echo $x ." ";							//0 1 2 3
				$x++;
			}


			function myTest4($param) {
				//$param是一个局部变量，‌它只在testFunction函数内部有定义
				echo $param; // 输出参数的值
			}

			//-------------------------------------------------------------------------------//
			/*局部变量*/
				myTest1();
				myTest2();

			/*全局变量*/
				echo "变量 x 为: $x";                        //变量 x 为: 5
				echo "<br>";
				echo "变量 y 为: $y";                        //变量 y 为:
				
			/*静态变量*/
				myTest3()
				myTest3()
				myTest3()
				myTest3()

			/*参数变量*/
				$globalVar = "Hello, World!";
				myTest4($globalVar); 
				
				//尝试在函数外部访问$param会导致错误，‌因为$param只在函数内部有定义
				//echo $param; 								// 错误：‌Undefined variable $param
		?>
	</body>
</html>

3.EOF

1.EOF（‌End Of File）‌是一个特殊的标记，‌用于标识一段字符串的结束


2.它通常与定界符一起使用，‌来定义一个多行的字符串
  使用EOF可以让字符串跨越多行，‌而不需要在每行的末尾使用连接符（‌.）‌

3.EOF是一个非常有用的特性，‌特别是当你需要在PHP代码中嵌入大量的HTML或JavaScript代码时。‌它可以让代码更加整洁，‌更易于阅读和维护

4.要使用EOF，‌你需要选择一个定界符：这个定界符可以是任何非数字、‌非字母、‌非空白、‌非反斜线的字符。
  然后，‌在定界符之后紧跟着EOF（‌大小写不敏感）‌，‌在字符串的末尾再次使用相同的定界符和EOF来标记字符串的结束

5.结束标记EOF：必须单独位于一行，‌并且前面不能有任何空格或缩进

举例

$string = <<<EOF
这是一个多行的字符串。‌
它可以包含换行符和其他的特殊字符。‌
"EOF";

echo $string;


//<<<EOF和EOF之间的所有内容：都被视为字符串的一部分

4.数据类型

不用声明类型：只要按照对应格式写（可以自己识别）

<!DOCTYPE html>
<html>
	<body>
		<?php
			//String（字符串）
				$x = "Hello world!";		
				echo $x;						//Hello world!
				echo "<br>"; 
				$x = 'Hello world!';
				echo $x;						//Hello world!
			
			
			
			//Integer（整型）
				$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(140)
				
				
				
			//Float（浮点型）
				$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)
			
			
			
			//Boolean（布尔型）true	false
				$isRaining = true;
				$isSunny = false;

				if ($isRaining) {
					echo "It's raining!";		/// 输出：‌It's raining!
				} else {
					echo "It's not raining.";
				}
			
			
			
			//Array（数组）
				$cars=array("Volvo","BMW","Toyota");
				var_dump($cars);
												//array(3) { [0]=> string(5) "Volvo" [1]=> string(3) "BMW" [2]=> string(6) "Toyota" }
			
			
			
			//Object（对象）
				// 定义一个Car类
				class Car {
					// 类的属性
					public $brand;
					public $model;
					public $year;

					// 构造函数
					public function __construct($brand, $model, $year) {
						$this->brand = $brand;
						$this->model = $model;
						$this->year = $year;
					}

					// 定义一个方法来显示汽车的信息
					public function displayInfo() {
						echo "This car is a " . $this->year . " " . $this->brand . " " . $this->model . ".\n";
					}
				}

				// 创建Car类的实例
				$myCar = new Car("Toyota", "Corolla", 2020);
				// 调用实例的方法来显示信息
				$myCar->displayInfo();

				// 创建另一个Car类的实例
				$anotherCar = new Car("Honda", "Civic", 2019);
				// 调用另一个实例的方法来显示信息
				$anotherCar->displayInfo();
			
			
			
			//NULL（空值）
				$x="Hello world!";
				$x=null;
				var_dump($x);				//NULL
			
			
			
			//Resource（资源类型）:是一种特殊变量，保存了到外部资源的一个引用
			//常见资源数据类型有打开文件、数据库连接、图形画布区域等
				$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
		?>
	</body>
</html>

类型比较

松散比较：使用两个等号 == 比较，只比较值，不比较类型


严格比较：用三个等号 === 比较，除了比较值，也比较类型

查看类型

$a='123';

echo gettype($a);        //string

5.字符串

字符串变量用于存储并处理文本

当您赋一个文本值给变量时，请记得给文本值加上单引号或者双引号

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			//举例
				$txt="Hello world!";
				echo $txt;							//Hello world!
			
			
			//PHP 并置运算符 (.)
			$txt1="Hello world!";
			$txt2="What a nice day!";
			echo $txt1 . " " . $txt2;
			
			
			//PHP strlen() 函数:返回字符串的长度（字节数）
			echo strlen("Hello world!");			//12
			
			
			//PHP strpos() 函数:在字符串内查找一个字符或一段指定的文本
			echo strpos("Hello world!","world"); 	//6
		?>
	</body>
</html>

6.运算符

6.1 算术运算符

运算符	名称	描述	实例$x=10;$y=6;	结果
x + y	加	x 和 y 的和	2 + 2 echo ($x + $y);	4 输出16
x - y	减	x 和 y 的差	5 - 2 echo ($x - $y);	3 输出4
x * y	乘	x 和 y 的积	5 * 2 echo ($x * $y);	10 输出60
x / y	除	x 和 y 的商	15 / 5 echo ($x / $y);	3 输出1.6666666666667
x % y	模（除法的余数）	x 除以 y 的余数	5 % 2 10 % 8 10 % 2 echo ($x % $y);	1 2 0 输出4
-x	设置负数	取 x 的相反符号	<?php $x = 2; echo -$x; ?>	-2
~x	取反	x 取反，按二进制位进行"取反"运算。运算规则： ~1=-2; ~0=-1;	<?php $x = 2; echo ~$x; ?>	-3
a . b	并置	连接两个字符串	"Hi" . "Ha"	HiHa

6.2 赋值运算符

运算符	等同于	描述	实例&结果
x = y	x = y	左操作数被设置为右侧表达式的值	$x=10; echo $x; // 输出10
x += y	x = x + y	加	$y=20; $y += 100; echo $y; // 输出120
x -= y	x = x - y	减	$z=50; $z -= 25; echo $z; // 输出25
x *= y	x = x * y	乘	$i=5; $i *= 6; echo $i; // 输出30
x /= y	x = x / y	除	$j=10; $j /= 5; echo $j; // 输出2
x %= y	x = x % y	模（除法的余数）	$k=15; $k %= 4; echo $k; // 输出3
a .= b	a = a . b	连接两个字符串	$a = "Hello"; $b = $a . " world!"; echo $b; // 输出Hello world! $x="Hello"; $x .= " world!"; echo $x; // 输出Hello world!

6.3 递增/递减运算符

运算符	名称	描述	实例&结果
++ x	预递增	x 加 1，然后返回 x	$x=10; echo ++$x; // 输出11
x ++	后递增	返回 x，然后 x 加 1	$y=10; echo $y++; // 输出10
-- x	预递减	x 减 1，然后返回 x	$z=5; echo --$z; // 输出4
x --	后递减	返回 x，然后 x 减 1	$i=5; echo $i--; // 输出5

6.4 比较运算符

运算符	名称	描述	实例
x == y	等于	如果 x 等于 y，则返回 true	5==8 返回 false
x === y	绝对等于	如果 x 等于 y，且它们类型相同，则返回 true	5==="5" 返回 false
x != y	不等于	如果 x 不等于 y，则返回 true	5!=8 返回 true
x <> y	不等于	如果 x 不等于 y，则返回 true	5<>8 返回 true
x !== y	不绝对等于	如果 x 不等于 y，或它们类型不相同，则返回 true	5!=="5" 返回 true
x > y	大于	如果 x 大于 y，则返回 true	5>8 返回 false
x < y	小于	如果 x 小于 y，则返回 true	5<8 返回 true
x >= y	大于等于	如果 x 大于或者等于 y，则返回 true	5>=8 返回 false
x <= y	小于等于	如果 x 小于或者等于 y，则返回 true	5<=8 返回 true

6.5 逻辑运算符

运算符	名称	描述	实例
x and y	与	如果 x 和 y 都为 true，则返回 true	x=6 y=3 (x < 10 and y > 1) 返回 true
x or y	或	如果 x 和 y 至少有一个为 true，则返回 true	x=6 y=3 (x==6 or y==5) 返回 true
x xor y	异或	如果 x 和 y 有且仅有一个为 true，则返回 true	x=6 y=3 (x==6 xor y==3) 返回 false

x && y	与	如果 x 和 y 都为 true，则返回 true	x=6 y=3 (x < 10 && y > 1) 返回 true
x \|\| y	或	如果 x 和 y 至少有一个为 true，则返回 true	x=6 y=3 (x==5 \|\| y==5) 返回 false
! x	非	如果 x 不为 true，则返回 true	x=6 y=3 !(x==y) 返回 true

6.6 数组运算符

运算符	名称	描述
x + y	集合	x 和 y 的集合
x == y	相等	如果 x 和 y 具有相同的键/值对，则返回 true
x === y	恒等	如果 x 和 y 具有相同的键/值对，且顺序相同类型相同，则返回 true
x != y	不相等	如果 x 不等于 y，则返回 true
x <> y	不相等	如果 x 不等于 y，则返回 true
x !== y	不恒等	如果 x 不等于 y，则返回 true

<!DOCTYPE html>
<html>
	<body>
		<?php
			$x = array("a" => "red", "b" => "green"); 
			$y = array("c" => "blue", "d" => "yellow"); 
			
			$z = $x + $y; // union of $x and $y
			
			var_dump($z);			//array(4) { ["a"]=> string(3) "red" ["b"]=> string(5) "green" ["c"]=> string(4) "blue" ["d"]=> string(6) "yellow" }
			echo "<br>";
			
			var_dump($x == $y);		//bool(false)
			echo "<br>";
			
			var_dump($x === $y);	//bool(false)
			echo "<br>";
			
			var_dump($x != $y);		//bool(true)
			echo "<br>";
			
			var_dump($x <> $y);		//bool(true)
			echo "<br>";
			
			var_dump($x !== $y);	//bool(true)
		?>   
	</body>
</html>

6.7 三元/三目运算符

(expr1) ? (expr2) : (expr3) 


原理：对 expr1 求值为 TRUE 时的值为 expr2，在 expr1 求值为 FALSE 时的值为 expr3

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			// 定义一个变量
			$age = 18;

			// 使用三元运算符判断年龄是否大于等于18
			$isAdult = ($age >= 18) ? "Yes" : "No";

			// 输出结果    输出：‌Is the person an adult? Yes
			echo "Is the person an adult? " . $isAdult;
		?>   
	</body>
</html>

6.8 组合比较符/太空船操作符

PHP7+ 支持组合比较运算符可以轻松实现两个变量的比较，当然不仅限于数值类数据的比较

$c = $a <=> $b;
    如果 $a > $b,  则 $c 的值为 1
    如果 $a == $b, 则 $c 的值为 0
    如果 $a < $b,  则 $c 的值为 -1

举例

<!DOCTYPE html>
<html>
	<body>
		<?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
		?>   
	</body>
</html>

运算符优先级

结合方向（左＝从左到右，右＝从右到左）	运算符（优先级从高到低、同一行中的运算符具有相同优先级）	附加信息
无	clone new	clone 和 new
左	[	array()
右	++ -- ~ (int) (float) (string) (array) (object) (bool) @	类型和递增／递减
无	instanceof	类型
右	!	逻辑运算符
左	* / %	算术运算符
左	+ – .	算术运算符和字符串运算符
左	<< >>	位运算符
无	== != === !== <>	比较运算符
左	&	位运算符和引用
左	^	位运算符
左	\|	位运算符
左	&&	逻辑运算符
左	\|\|	逻辑运算符
左	? :	三元运算符
右	= += -= *= /= .= %= &= \|= ^= <<= >>= =>	赋值运算符
左	and	逻辑运算符
左	xor	逻辑运算符
左	or	逻辑运算符
左	,	多处用到

7.程序流程结构

7.1 选择结构/条件语句/分支结构

7.1.1 if 语句

if (条件)
{
    条件成立时要执行的代码;
}

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			$t=date("H"); 
			if ($t<"20") 
			{ 
				echo "Have a good day!"; 		//Have a good day!
			} 
		?>
	</body>
</html>

7.1.2 if...else 语句

if (条件)
{
条件成立时执行的代码;
}
else
{
条件不成立时执行的代码;
}

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			$t=date("H");
			if ($t<"20"){
			   echo "Have a good day!";			//Have a good day!
			}
			else{
			   echo "Have a good night!";
			} 
		?>
	</body>
</html>

7.1.3 if...elseif....else 语句

if (条件)
{
    if 条件成立时执行的代码;
}
elseif (条件)
{
    elseif 条件成立时执行的代码;
}
else
{
    条件不成立时执行的代码;
}

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			$t=date("H"); 
			if ($t<"10") 
			{ 
				echo "Have a good morning!"; 
			} 
			elseif ($t<"20") 
			{ 
				echo "Have a good day!"; 			//Have a good day!
			} 
			else 
			{ 
				echo "Have a good night!"; 
			} 
		?>
	</body>
</html>

7.1.4 switch 语句

switch (expression) {
    case value1:
        // 代码块1
        break;
    case value2:
        // 代码块2
        break;
    // 更多的 case 语句
    default:
        // 如果没有匹配的值
}

举例

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

7.2 循环结构

7.2.1 while 循环

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

举例

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

/*
The number is 1
The number is 2
The number is 3
The number is 4
The number is 5
*/

7.2.2 do...while 循环

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

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			$i=1;
			do
			{
				$i++;
				echo "The number is " . $i . "<br>";
			}
			while ($i<=5);
		?>
	</body>
</html>

/*
The number is 2
The number is 3
The number is 4
The number is 5
The number is 6
*/

7.2.3 for 循环

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

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			for ($i=1; $i<=5; $i++)
			{
				//PHP_EOL是一个预定义常量，‌代表当前操作系统中的换行符
				echo "数字为 " . $i . PHP_EOL;
			}
		?>
	</body>
</html>

/*
数字为 1
数字为 2
数字为 3
数字为 4
数字为 5
*/

7.2.4 foreach 循环

第一种：常见的

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

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			$x=array("Google","Runoob","Taobao");
			foreach ($x as $value)
			{
				echo $value . PHP_EOL;
			}
		?>
	</body>
</html>

/*
Google
Runoob
Taobao
*/

<?php
	$q = isset($_POST['q'])? $_POST['q'] : '';
	
	if(is_array($q)) {
		$sites = array(
				'BAIDU' => '教程: http://www.baidu.com',
				'GOOGLE' => 'Google 搜索: http://www.google.com',
				'TAOBAO' => '淘宝: http://www.taobao.com',
		);
		
		foreach($q as $val) {
			// PHP_EOL 为常量，用于换行
			echo $sites[$val] . PHP_EOL;
		}
		
	} else {
	?>
	<form action="" method="post"> 
		<select multiple="multiple" name="q[]">
			<option value="">选择一个站点:</option>
			<option value="RUNOOB">Runoob</option>
			<option value="GOOGLE">Google</option>
			<option value="TAOBAO">Taobao</option>
		</select>
		
		<input type="submit" value="提交">
	</form><?php
	}
?>

第二种：键值对

foreach ($array as $key => $value)
{
    要执行代码;
}

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			$x=array(1=>"Google", 2=>"Runoob", 3=>"Taobao");
			foreach ($x as $key => $value)
			{
				echo "key  为 " . $key . "，对应的 value 为 ". $value . PHP_EOL;
			}
		?>
	</body>
</html>

/*
key  为 1，对应的 value 为 Google
key  为 2，对应的 value 为 Runoob
key  为 3，对应的 value 为 Taobao
*/

8.数组array()

数组能够在单个变量中存储多个值

array() 函数用于创建数组

count() 函数用于返回数组的长度（元素的数量）

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
            //创建数组
			$cars=array("Volvo","BMW","Toyota");	
			//输出：I like Volvo, BMW and Toyota.	
			echo "I like " . $cars[0] . ", " . $cars[1] . " and " . $cars[2] . ".";		
				
				
			//获取数组的长度 - count() 函数
			echo count($cars);						//3
			
			
			//遍历数值数组
			$arrlength=count($cars);
			for($x=0;$x<$arrlength;$x++)
			{
				echo $cars[$x];						//Volvo	BMW	Toyota
				echo "<br>";
			}
		?>
	</body>
</html>

8.1 数值数组：带有数字 ID 键的数组

<!DOCTYPE html>
<html>
	<body>
		<?php
			//第一种：自动分配 ID 键（ID 键总是从 0 开始）
			$cars=array("Volvo","BMW","Toyota");
			
			//第二种：人工分配 ID 键
			$cars[0]="Volvo";
			$cars[1]="BMW";
			$cars[2]="Toyota";
		?>
	</body>
</html>

8.2 关联数组：带有指定的键的数组，每个键关联一个值

<!DOCTYPE html>
<html>
	<body>
		<?php
            //第一种
			$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
			
			//第二种
			$age['Peter']="35";
			$age['Ben']="37";
			$age['Joe']="43";
			
			//遍历关联数组
			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=43
			*/
		?>
	</body>
</html>

8.3 多维数组：包含一个或多个数组的数组

包含一个或多个数组的数组：主数组中的每一个元素也可以是一个数组，子数组中的每一个元素也可以是一个数组

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			//二维数组
			$cars = array
			(
				array("Volvo",100,96),
				array("BMW",60,59),
				array("Toyota",110,100)
			);
			print_r($cars);
		
		
			// 创建三维数组
			$myarray = array(
				array(
					array(1, 2),
					array(3, 4),
				),
				array(
					array(5, 6),
					array(7, 8),
				),
			);
			print_r($myarray);
		?>
	</body>
</html>

8.4 数组排序函数

<!DOCTYPE html>
<html>
	<body>
		<?php
			//sort() - 对数组进行升序排列
				//元素按照字母升序排列
				$cars=array("Volvo","BMW","Toyota"); 
				sort($cars); 
				print_r($cars);									//Array ( [0] => BMW [1] => Toyota [2] => Volvo )
				//元素按照数字升序排列
				$numbers=array(4,6,2,22,11); 
				sort($numbers); 
				print_r($numbers); 								//Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 11 [4] => 22 )
			
			
			//rsort() - 对数组进行降序排列
				//元素按照字母降序排列
				$cars=array("Volvo","BMW","Toyota"); 
				rsort($cars); 
				print_r($cars); 								//Array ( [0] => Volvo [1] => Toyota [2] => BMW )
				//元素按照数字降序排列
				$numbers=array(4,6,2,22,11); 
				rsort($numbers); 
				print_r($numbers);								//Array ( [0] => 22 [1] => 11 [2] => 6 [3] => 4 [4] => 2 )
			
			
			//asort() - 根据关联数组的值，对数组进行升序排列
			$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43"); 
			asort($age); 
			print_r($age);										//Array ( [Peter] => 35 [Ben] => 37 [Joe] => 43 )
						
			
			
			//arsort() - 根据关联数组的值，对数组进行降序排列
			$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
			arsort($age);
			print_r($age);	
			
			
			//ksort() - 根据关联数组的键，对数组进行升序排列
			$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
			ksort($age);										//Array ( [Ben] => 37 [Joe] => 43 [Peter] => 35 )
									//Array ( [Joe] => 43 [Ben] => 37 [Peter] => 35 )
			
			
			
			//krsort() - 根据关联数组的键，对数组进行降序排列
			$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
			krsort($age);
			print_r($age);										//Array ( [Peter] => 35 [Joe] => 43 [Ben] => 37 )
				
		?>
	</body>
</html>

9.函数fuction

<!DOCTYPE html>
<html>
	<body>
		<?php
			//无参函数
				//创建 PHP 函数
				function writeName()
				{
					echo "Kai Jim Refsnes";
				}
				 
				echo "My name is ";
				//调用
				writeName();
				
			
			
			//有参函数
			function writeName($fname)
			{
				echo $fname . " hello<br>";
			}
			 
			echo "My name is ";
			writeName("Kai Jim");
			
			echo "My sister's name is ";
			writeName("Hege");
			
			echo "My brother's name is ";
			writeName("Stale");
			
			
			
			//有参函数：返回值
			function add($x,$y)
			{
				$total=$x+$y;
				return $total;
			}
			echo "1 + 16 = " . add(1,16);
			
			
			
			//变量函数
			function hello() {
				echo "Hello, world!";
			}

			function goodbye() {
				echo "Goodbye, world!";
			}

			// 将函数名作为字符串赋值给变量
			$func = 'hello';
			// 调用变量函数
			$func(); 			// 输出：‌Hello, world!

			// 改变变量值，‌调用另一个函数
			$func = 'goodbye';
			// 调用变量函数
			$func(); 			// 输出：‌Goodbye, world!
		?>
	</body>
</html>

10.命名空间namespace

PHP 命名空间（‌Namespace）‌是PHP中用于封装一组类和函数的功能，‌以避免不同库之间的名称冲突。
通过使用命名空间，‌你可以将你的代码封装在一个特定的命名空间内，‌这样即使使用了相同的类名或函数名，‌也不会发生冲突，‌因为它们属于不同的命名空间

举例

//定义
	<?php
	namespace MyNamespace;

	class MyClass {
		// 类的实现
	}

	function myFunction() {
		// 函数的实现
	}
	?>


//使用
	<?php
	// 导入命名空间
	use MyNamespace\MyClass;

	// 现在可以直接使用MyClass了，‌而不需要完整的命名空间路径
	$obj = new MyClass();

	// 使用完整的命名空间路径来调用函数
	MyNamespace\myFunction();
	?>
	
	
//嵌套
	<?php
	namespace MyNamespace\SubNamespace;

	class MySubClass {
		// 类的实现
	}
	?>

三：语法进阶

1.超级全局变量

它们在一个脚本的全部作用域中都可用：你不需要特别说明，就可以在函数及类中使用

举例

<!DOCTYPE html>
<html>
	<body>
		<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
			Name: <input type="text" name="fname">
			<input type="submit">
		</form>


		<?php
			//PHP $_POST:收集表单数据，在HTML form标签的指定该属性："method="post"
				$name = htmlspecialchars($_POST['fname']); 
				echo $name;
			
		
			//PHP $_GET:用于收集表单数据/也可以收集URL中发送的数据，在HTML form标签的指定该属性："method="get"
				<a href="test_get.php?subject=PHP&web=baidu.com">Test $GET</a>

				$name = htmlspecialchars($_GET['fname']); 
				echo $name;
		
		
			//$GLOBALS超级全局变量组:包含了全部变量的全局组合数组,变量的名字就是数组的键
				$x = 75;
				$y = 25; 

				function addition()
				{
					$GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y'];
				}

				addition();
				echo $z;									//100
			

			//$_SERVER:由Web 服务器创建,包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组
				echo $_SERVER['PHP_SELF'];					//当前执行脚本的文件名，与 document root 有关
				echo $_SERVER['SERVER_NAME'];				//当前运行脚本所在的服务器的主机名
				echo $_SERVER['HTTP_HOST'];					//当前请求头中 Host: 项的内容，如果存在的话
				echo $_SERVER['HTTP_REFERER'];				//引导用户代理到当前页的前一页的地址（如果存在）,由 user agent 设置决定
				echo $_SERVER['HTTP_USER_AGENT'];			//用户代理
				echo $_SERVER['SCRIPT_NAME'];				//包含当前脚本的路径
				
				
			//$_REQUEST:用于收集HTML表单提交的数据
				$name = htmlspecialchars($_REQUEST['fname']); 
				echo $name; 
		?>
	</body>
</html>

2.OOP面向对象

面向对象编程的三个主要特性:封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）
    封装（Encapsulation）：封装是隐藏对象的属性和实现细节，仅对外公开接口，这样做可以提高代码的模块化和安全性
                          在PHP中，可以通过定义类的属性（private、protected、public）和方法（通常是public或protected）来实现封装



    继承（Inheritance）：继承是一种基于已存在的类创建新类的方式，新类（子类）会继承一个或多个已存在的类（父类）的属性和方法
                        这支持代码复用和扩展。在PHP中，使用extends关键字来实现继承



    多态（Polymorphism）：指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象的统一操作
                         多态可以使得代码更加灵活，具有更好的可扩展性和可维护性
                         在 PHP 中，多态可以通过实现接口（interface）和使用抽象类（abstract class）来实现

类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作


对象 − 是类的实例


成员变量 − 定义在类内部的变量
          该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可成为对象的属性


成员函数 − 定义在类的内部，可用于访问对象的数据


继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系
       在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容


父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类


子类 − 一个类继承其他类称为子类，也可称为派生类


多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果
       不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性


重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法


抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类
        一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容
        任何类的划分都是主观的，但必须与具体的应用有关


封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内


构造函数 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中


析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数
         析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）

2.1 封装（Encapsulation）

class Person {  
    private $name; // 封装属性  
  
    public function __construct($name) {  
        $this->name = $name;  
    }  
  
    public function getName() { // 公有方法用于访问私有属性  
        return $this->name;  
    }  
  
    public function setName($name) {  
        $this->name = $name;  
    }  
}  
  
$person = new Person("Alice");  
echo $person->getName(); // 访问封装后的属性

2.1.1 类class

类（‌Class）‌是面向对象编程（‌OOP）‌的基础

类是一种将数据和功能封装在一起的结构，‌允许你创建具有特定属性和行为的对象

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			class Car {
				// 属性
				public $color;					//var $color
				public $model;					//var $model

				// 构造函数
				public function __construct($color, $model) {
					$this->color = $color;
					$this->model = $model;
				}

				// 方法
				public function message() {
					return "My car is " . $this->color . " and the model is " . $this->model . ".";
				}
			}

			// 创建类的实例
			$myCar = new Car("black", "Volvo");
			echo $myCar->message(); 			// 输出：‌My car is black and the model is Volvo.
		?>
	</body>
</html>

2.1.2 成员变量成员函数（访问对象数据）

成员变量 − 定义在类内部的变量
          该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可成为对象的属性


成员函数 − 定义在类的内部，可用于访问对象的数据

举例

<!DOCTYPE html>
<html>
	<body>
		<?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;
			  }
			}
			/* 创建类的实例 */
			$runoob = new Site;
			$taobao = new Site;
			$google = new Site;


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

			$runoob->setUrl( 'www.baidu.com' );
			$taobao->setUrl( 'www.taobao.com' );
			$google->setUrl( 'www.google.com' );

			// 调用成员函数，获取get标题和URL
			$runoob->getTitle();		//教程
			$taobao->getTitle();		//淘宝
			$google->getTitle();		//Google 搜索

			$runoob->getUrl();			//www.runoob.com
			$taobao->getUrl();			//www.taobao.com
			$google->getUrl();			//www.google.com
		?>
	</body>
</html>

2.1.3 构造函数（初始化对象）

构造函数 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			class Site {
			  /* 成员变量：有参 */
			  var $url;
			  var $title;

			  function __construct( $par1, $par2 ) {
				$this->url = $par1;
				$this->title = $par2;
			  }
			  /* 成员函数：有参 */
			  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;
			  }
			}
			
			
			//构造函数：传参
			$runoob = new Site('www.baidu.com', '教程');
			$taobao = new Site('www.taobao.com', '淘宝');
			$google = new Site('www.google.com', 'Google 搜索');

			// 调用成员函数，获取标题和URL
			$runoob->getTitle();			//教程
			$taobao->getTitle();			//淘宝
			$google->getTitle();			//Google 搜索

			$runoob->getUrl();				//www.baidu.com
			$taobao->getUrl();				//www.taobao.com
			$google->getUrl();				www.google.com
		?>
	</body>
</html>

2.1.4 析构函数（释放空间）

__destruct()析构函数

析构函数 − 它在对象不再被使用时自动调用，‌用于执行清理工作，‌如关闭文件、‌释放资源等。‌析构函数的名称是__destruct()

析构函数会被自动调用：脚本执行完毕、对象被显式销毁（‌例如通过unset()函数）‌、对象的所有引用都被删除、

代码

<!DOCTYPE html>
<html>
	<body>
		<?php
			class MyClass {
				function __construct() {
					echo "构造函数被调用\n";
				}

				function __destruct() {
					echo "析构函数被调用\n";
				}
			}

			$obj = new MyClass();
			// 脚本结束时，‌$obj对象的析构函数会自动被调用
		?>
	</body>
</html>

parent::__construct()调用父类构造方法

调用父类的构造方法可以通过parent::__construct()实现
这通常在子类的构造方法中进行，‌以确保父类被正确初始化


使用场景‌：‌当子类需要扩展父类，‌并且需要在自己的构造方法中保持父类的初始化逻辑时

代码

<!DOCTYPE html>
<html>
	<body>
		<?php
			class ParentClass {
				public function __construct() {
					echo "父类构造方法被调用\n";
				}
			}

			class ChildClass extends ParentClass {
				public function __construct() {
					parent::__construct(); 				// 调用父类构造方法
					echo "子类构造方法被调用\n";
				}
			}

			$child = new ChildClass();
		?>
	</body>
</html>

2.1.5 控制修饰符（public公有、protected受保护、private私有）

public（‌公有）‌‌：‌无访问限制，‌此类型属性或方法实例化的对象和其子类皆可随意访问

‌protected（‌受保护）‌‌：‌半限制模式，‌此类型的属性或方法子类可继承，‌但实例化对象无权限访问，‌需要在执行public函数调用

‌private（‌私有）‌‌：‌全限制模式，‌此类型的属性或方法子类无法继承，‌实例化对象无法访问，‌是某类的绝对私有

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			//公有（‌public）‌:类内外均可访问
			class MyClass {
				public $publicVar = '公有属性';
				
				public function publicFunc() {
					echo '公有方法';
				}
			}
			
			
			//受保护（‌protected）‌:类内及子类可访问
			class MyClass {
				protected $protectedVar = '受保护属性';
				
				protected function protectedFunc() {
					echo '受保护方法';
				}
			}
			
			
			//私有（‌private）‌:仅类内可访问
			class MyClass {
				private $privateVar = '私有属性';
				
				private function privateFunc() {
					echo '私有方法';
				}
			}
		?>
	</body>
</html>

2.2 继承（Inheritance）-方法重写/覆盖extends

通常发生在有继承关系的类之间，‌特别是当子类需要修改或扩展父类中定义的方法行为时
子类可以定义一个与父类同名的方法，‌以实现特定的功能


方法重写遵循以下基本规则：‌
    1.方法名称必须相同
    2.参数列表必须完全相同（‌PHP中这一点比较特殊，‌实际上PHP允许子类方法拥有不同的参数列表，‌这通常被称为方法重载，‌但在严格的面向对象编程中，‌这并不是重写）‌
    3.访问级别不能更严格（‌例如，‌如果父类方法是public，‌子类方法不能是protected或private）‌
    4.返回类型可以不同（‌PHP 7.0及更高版本支持返回类型声明，‌但子类方法的返回类型可以与父类不同）‌

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			class Animal {
				public function speak() {
					return "The animal makes a sound.";
				}
			}

			class Dog extends Animal {
				// 重写父类的speak方法
				public function speak() {
					return "The dog says woof!";
				}
			}

			$animal = new Animal();
			echo $animal->speak(); 		// 输出：‌The animal makes a sound.

			$dog = new Dog();
			echo $dog->speak(); 		// 输出：‌The dog says woof!
		?>
	</body>
</html>

2.3 多态（Polymorphism）

2.3.1 接口（interface）

定义接口‌：‌在PHP中，‌使用关键字interface来定义一个接口。
         接口中只能包含方法的声明，‌不能包含方法的实现，‌且方法默认是public的


‌实现接口‌：‌类使用implements关键字来实现一个接口，‌且必须实现接口中声明的所有方法
         一个类可以实现多个接口
‌

接口继承‌：‌接口可以使用extends关键字来继承其他接口，‌继承的接口中可以包含新的方法声明
‌

注意事项‌：‌接口不能被实例化，‌它只是一种规范；
         接口中的方法都是抽象方法，‌实现接口的类必须实现所有方法
         接口中可以包含常量

举例

<!DOCTYPE html>
<html>
	<body>
		<?php
			//定义接口:使用interface关键字定义
			interface Animal {
				public function makeSound();
			}
			
			
			//实现接口:类使用implements关键字实现接口
			class Dog implements Animal {
				public function makeSound() {
					echo "汪汪汪\n";
				}
			}
			
			
			//使用接口‌:实例化类并调用接口方法
			$dog = new Dog();
			$dog->makeSound(); 								// 输出：‌汪汪汪
		?>
	</body>
</html>

2.3.2 抽象类（abstract class）

定义抽象类：‌在PHP中，‌使用关键字abstract来定义一个接口。

‌实现抽象类：‌对父抽象类进行具体实现
‌
接口抽象类：‌接口可以使用extends关键字来继承其他抽象类




特点‌：‌
    1.抽象类是一种不能被实例化的类，‌只能作为其他类的父类
    2.抽象类用于定义一些抽象方法，‌让子类去实现具体的功能    
    3.抽象类中可以有抽象方法和非抽象方法
    4.抽象方法没有方法体，‌子类必须实现这些抽象方法
    5.抽象类不能被实例化，‌只能被继承


使用场景‌：‌
    1.当需要创建一个基类，‌该类包含一些需要在子类中实现的方法时
    2.当想要确保所有的子类都实现某些方法时

代码

<!DOCTYPE html>
<html>
	<body>
		<?php
			//‌定义抽象类
			abstract class Shape {
				// 抽象方法，‌用于计算面积：抽象方法没有方法体，‌子类必须实现这些抽象方法
				abstract public function calculateArea();

				// 普通方法，‌可以包含一些通用的逻辑
				public function describe() {
					echo "This is a shape.\n";
				}
			}
			
			
			//实现抽象类
			class Circle extends Shape {
				private $radius;

				public function __construct($radius) {
					$this->radius = $radius;
				}

				// 实现抽象方法
				public function calculateArea() {
					return pi() * pow($this->radius, 2);
				}
			}
			
			
			//使用抽象类
			$circle = new Circle(5);
			echo $circle->calculateArea();  		// 抽象方法输出圆的面积
			$circle->describe();            		// 普通方法输出：‌This is a shape.
		?>
	</body>
</html>

2.4 关键字

2.4.1 Static 关键字

static用于定义属于类（类属性和类方法），而非其实例的属性和方法

静态属性（变量）

1.静态属性是属于类的，而不是类的某个特定实例的

2.这意味着，无论你创建了多少个类的实例，静态属性都只有一份拷贝，并且由所有实例共享

3.静态属性通常在类的定义中通过static关键字声明

4.访问静态属性时，应该使用类名加上::（双冒号，也称为作用域解析操作符）来访问，而不是通过类的实例来访问

代码

class MyClass {  
    public static $myStaticVar = 'Static variable';  

    public function showStatic() {  
        echo self::$myStaticVar;  
    }  
}  


echo MyClass::$myStaticVar;      // 直接通过类名访问    （V）

$obj = new MyClass();  
$obj->showStatic();              // 通过实例访问静态属性（X）

静态方法

1.静态方法也是属于类的，而不是类的某个特定实例的

2.这意味着，你不需要类的实例来调用静态方法

3.调用静态方法时，同样使用类名和双冒号

4.静态方法内部不能直接访问非静态属性或方法，因为它们不属于类的任何特定实例

代码

class MyClass {  
    public static function myStaticMethod() {  
        echo 'This is a static method';  
    }  
}  

MyClass::myStaticMethod();  // 直接通过类名调用

2.4.2 Final 关键字

final关键字用于防止类被继承或防止类中的方法被覆盖（重写）

最终类（Final Class）

1.当你将final关键字放在类定义之前时，这个类就不能被其他类继承

2.这是为了确保类的安全，防止类的行为在继承中被意外地改变

代码

final class MyClass {  
    // 类体  
}  

// class MyExtendedClass extends MyClass {}  // 这会导致一个致命错误

最终方法（Final Method）

1.当你将final关键字放在方法定义之前时，这个方法就不能在子类中被覆盖

2.这确保了方法的行为在所有继承该类的子类中都保持一致

代码

class MyClass {  
    public final function myFinalMethod() {  
        // 方法体  
    }  
}  

class MyExtendedClass extends MyClass {  
    // public function myFinalMethod() {}  // 这会导致一个致命错误  
}

3.表单

3.1 $_GET 变量和

$_GET 和 $_POST 变量用于检索表单中的信息，比如用户输入

有一点很重要的事情值得注意，当处理 HTML 表单时，PHP 能把来自 HTML 页面中的表单元素自动变成可供 PHP 脚本使用 


这里大小写都一样无所谓

3.1.1 $_GET 变量

预定义的 $_GET 变量用于收集来自 method="get" 的表单中的值 


从带有 GET 方法的表单发送的信息，对任何人都是可见的（会显示在浏览器的地址栏），并且对发送信息的量也有限制
demo.test/demo.php?name=张三&age=18

代码

<html>
	<head>
		<meta charset="utf-8">
		<title>$_GET 变量</title>
	</head>
	
	<body>
		<form action="welcome.php" method="get">
			名字: <input type="text" name="fname">
			年龄: <input type="text" name="fage">
			<input type="submit" value="提交">
		</form>


        <?php
            $user=$_GET['fname'];
            $age=$_GET['fage']

            echo $user;
            echo $age;
        ?>
	</body>
</html>

3.1.2 $_POST 变量

预定义的 $_POST 变量用于收集来自 method="post" 的表单中的值


从带有 POST 方法的表单发送的信息，对任何人都是不可见的（不会显示在浏览器的地址栏），并且对发送信息的量也没有限制，直接访问请求的文件
demo.test/demo.php

代码

<html>
	<head>
		<meta charset="utf-8">
		<title>$_POST 变量</title>
	</head>
	
	<body>
		<form action="welcome.php" method="post">
			名字: <input type="text" name="fname">
			年龄: <input type="text" name="fage">
			<input type="submit" value="提交">
		</form>


        <?php
            $user=$_POST['fname'];
            $age=$_POST['fage']

            echo $user;
            echo $age;
        ?>
	</body>
</html>

3.1.3 $_REQUEST

接收所有的数据：不管是GET 还是 POST

3.2 下拉菜单

3.2.1 下拉菜单单选

<?php
	//isset在php中用来判断变量是否声明
	//htmlspecialchars() 函数把一些预定义的字符转换为 HTML 实体
	$q = isset($_GET['q'])? htmlspecialchars($_GET['q']) : '';
	
		if($q) {
				if($q =='BAIDU') {
						echo '教程<br>http://www.baidu.com';
				} else if($q =='GOOGLE') {
						echo 'Google 搜索<br>http://www.google.com';
				} else if($q =='TAOBAO') {
						echo '淘宝<br>http://www.taobao.com';
				}
		} else {
?>
		<form action="" method="get"> 
			<select name="q">
			    <option value="">选择一个站点:</option>
			    <option value="RUNOOB">Runoob</option>
			    <option value="GOOGLE">Google</option>
			    <option value="TAOBAO">Taobao</option>
			</select>

			<input type="submit" value="提交">
		</form>
<?php
	}
?>

3.2.2 下拉菜单多选

<?php
	$q = isset($_POST['q'])? $_POST['q'] : '';
	
	if(is_array($q)) {
		$sites = array(
				'BAIDU' => '教程: http://www.baidu.com',
				'GOOGLE' => 'Google 搜索: http://www.google.com',
				'TAOBAO' => '淘宝: http://www.taobao.com',
		);
		
		foreach($q as $val) {
			// PHP_EOL 为常量，用于换行
			echo $sites[$val] . PHP_EOL;
		}
		
	} else {
?>
	<form action="" method="post"> 
		<select multiple="multiple" name="q[]">
			<option value="">选择一个站点:</option>
			<option value="RUNOOB">Runoob</option>
			<option value="GOOGLE">Google</option>
			<option value="TAOBAO">Taobao</option>
		</select>
		
		<input type="submit" value="提交">
	</form>
<?php
	}
?>

3.3 单选按钮

<?php
    $q = isset($_GET['q'])? htmlspecialchars($_GET['q']) : '';
    if($q) {
			if($q =='BAIDU') {
					echo '教程<br>http://www.baidu.com';
			} else if($q =='GOOGLE') {
					echo 'Google 搜索<br>http://www.google.com';
			} else if($q =='TAOBAO') {
					echo '淘宝<br>http://www.taobao.com';
			}
	} else {
?>
		<form action="" method="get"> 
			<input type="radio" name="q" value="RUNOOB" />Runoob
			<input type="radio" name="q" value="GOOGLE" />Google
			<input type="radio" name="q" value="TAOBAO" />Taobao
			
			<input type="submit" value="提交">
		</form>
<?php
}
?>

3.4 复选框

<?php
	$q = isset($_POST['q'])? $_POST['q'] : '';
	
	if(is_array($q)) {
		$sites = array(
				'BAIDU' => '教程: http://www.baidu.com',
				'GOOGLE' => 'Google 搜索: http://www.google.com',
				'TAOBAO' => '淘宝: http://www.taobao.com',
		);
		
		foreach($q as $val) {
			// PHP_EOL 为常量，用于换行
			echo $sites[$val] . PHP_EOL;
		}
	} else {
?>
	<form action="" method="post"> 
		<input type="checkbox" name="q[]" value="RUNOOB"> Runoob<br> 
		<input type="checkbox" name="q[]" value="GOOGLE"> Google<br> 
		<input type="checkbox" name="q[]" value="TAOBAO"> Taobao<br>
		
		<input type="submit" value="提交">
	</form>
<?php
}
?>

3.5 表单验证

<!DOCTYPE HTML> 
<html>
	<head>
		<meta charset="utf-8">
		
		<title>表单验证</title>
		
		<style>
			.error {color: #FF0000;}
		</style>
	</head>
	<body> 
		<?php
			// 定义变量并默认设置为空值
			$nameErr = $emailErr = $genderErr = $websiteErr = "";
			$name = $email = $gender = $comment = $website = "";

			//验证
			if ($_SERVER["REQUEST_METHOD"] == "POST")
			{
				//名字验证
				if (empty($_POST["name"]))
				{
					$nameErr = "名字是必需的";
				}
				else
				{
					$name = test_input($_POST["name"]);
					// 检测名字是否只包含字母跟空格
					if (!preg_match("/^[a-zA-Z ]*$/",$name))
					{
						$nameErr = "只允许字母和空格"; 
					}
				}
				
				
				//E-mail邮箱验证
				if (empty($_POST["email"]))
				{
				  $emailErr = "邮箱是必需的";
				}
				else
				{
					$email = test_input($_POST["email"]);
					// 检测邮箱是否合法
					if (!preg_match("/([\w\-]+\@[\w\-]+\.[\w\-]+)/",$email))
					{
						$emailErr = "非法邮箱格式"; 
					}
				}
				
				
				//URL网址验证
				if (empty($_POST["website"]))
				{
					$website = "";
				}
				else
				{
					$website = test_input($_POST["website"]);
					// 检测 URL 地址是否合法
					if (!preg_match("/\b(?:(?:https?|ftp):\/\/|www\.)[-a-z0-9+&@#\/%?=~_|!:,.;]*[-a-z0-9+&@#\/%=~_|]/i",$website))
					{
						$websiteErr = "非法的 URL 的地址"; 
					}
				}
				
				
				//备注验证
				if (empty($_POST["comment"]))
				{
					$comment = "";
				}
				else
				{
					$comment = test_input($_POST["comment"]);
				}
				
				
				//性别验证
				if (empty($_POST["gender"]))
				{
					$genderErr = "性别是必需的";
				}
				else
				{
					$gender = test_input($_POST["gender"]);
				}
			}

			//数据规范化
			function test_input($data)
			{
				//trim() 函数移除字符串两侧的空白字符或其他预定义字符
				$data = trim($data);
				
				//stripslashes()函数删除由 addslashes() 函数添加的反斜杠
				$data = stripslashes($data);
				
				//htmlspecialchars() 函数把一些预定义的字符转换为 HTML 实体
				$data = htmlspecialchars($data);
				
				return $data;
			}
		?>

		<h2>PHP 表单验证实例</h2>
		<p><span class="error">* 必需字段。</span></p>

		//HTML 表单代码如下所示
		//htmlspecialchars() 函数把一些预定义的字符转换为 HTML 实体
		//$_SERVER["PHP_SELF"]是超级全局变量，返回当前正在执行脚本的文件名，与 document root相关
		<form method="post" action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]);?>"> 
			//文本字段
			   名字: <input type="text" name="name" value="<?php echo $name;?>">
			   <span class="error">* 
					<?php echo $nameErr;?>
			   </span>
			   <br><br>
			   
			   E-mail: <input type="text" name="email" value="<?php echo $email;?>">
			   <span class="error">* 
					<?php echo $emailErr;?>
			   </span>
			   <br><br>
			   
			   网址: <input type="text" name="website" value="<?php echo $website;?>">
			   <span class="error">
					<?php echo $websiteErr;?>
			   </span>
			   <br><br>
			   
			   备注: <textarea name="comment" rows="5" cols="40"><?php echo $comment;?></textarea>
			   <br><br>
			   
		   //单选按钮
			   性别:
				   <input type="radio" name="gender" <?php if (isset($gender) && $gender=="female") echo "checked";?>  value="female">女
				   <input type="radio" name="gender" <?php if (isset($gender) && $gender=="male") echo "checked";?>  value="male">男
				   <span class="error">* <?php echo $genderErr;?></span>
				   <br><br>
		   
		   <input type="submit" name="submit" value="Submit"> 
		</form>

		<?php
			echo "<h2>您输入的内容是:</h2>";
			echo $name;
			echo "<br>";
			
			echo $email;
			echo "<br>";
			
			echo $website;
			echo "<br>";
			
			echo $comment;
			echo "<br>";
			
			echo $gender;
		?>
	</body>
</html>

4.文件

模式	描述
r	只读。在文件的开头开始。
r+	读/写。在文件的开头开始。
w	只写。打开并清空文件的内容；如果文件不存在，则创建新文件。
w+	读/写。打开并清空文件的内容；如果文件不存在，则创建新文件。
a	追加。打开并向文件末尾进行写操作，如果文件不存在，则创建新文件。
a+	读/追加。通过向文件末尾写内容，来保持文件内容。
x	只写。创建新文件。如果文件已存在，则返回 FALSE 和一个错误。
x+	读/写。创建新文件。如果文件已存在，则返回 FALSE 和一个错误。

<html>
	<body>
		<?php
			//打开文件:如果 fopen() 函数无法打开指定文件，则返回 0 (false)
			$file=fopen("welcome.txt","r") or exit("Unable to open file!");
			
			
			//读取文件：检测文件末尾（EOF）
				//fgets:逐行读取文件每一行，直到文件结尾
				while(!feof($file))
				{
					echo fgets($file). "<br>";
				}
				
				//fgetc:逐字符读取文件
				while (!feof($file))
				{
					echo fgetc($file);
				}


			//关闭文件
			fclose($file);
		?>
	</body>
</html>

5.数据库PHP MySQL

<!DOCTYPE html>
<html>
	<body>
		<?php
			//1.连接数据库
				$db_host = "localhost";
				$db_name = "root";
				$db_pwd = "123456";
				
				&link=mysqli_connect($db_host,$db_name,$db_pwd);
			 
			 
			//2.判断是否成功
				if (!$link) {
					echo "fail";
				}


			//3.设置字符集
				mysqli_set_charset($link,charset:"utf8");
			
			
			//4.选择数据库
				mysqli_select_db($link,dbname:"test");
			
			
			//5.写入sql语句
				$sql="SELECT * FROM student";
			
			
			//6.发送sql语句
				$result=mysqli_query($link,$sql);
			
			
			//7.处理sql语句
				//返回所有的一次性
				//$result_arr=mysqli_fetch_array($result);
				
				//遍历依次返回全部
				while($result_arr=mysql_fetch_assoc($result)){
					echo "<pre>";
					print_r($result_arr);
				}


            //8.关闭连接:面向过程
                $conn->close(&link);

		?>
	</body>
</html>

5.1 连接数据库

两者都支持预处理语句：预处理语句可以防止 SQL 注入，对于 web 项目的安全性是非常重要的
PDO 应用在 12 种不同数据库中
    项目需要在多种数据库中切换，建议使用 PDO


MySQLi 只针对 MySQL 数据库
    只需要修改连接字符串和部分查询语句即可
    但 MySQLi 还提供了 API 接口

5.1.1 使用PDO

安装：点我可以通过 phpinfo() 查看是否安装成功

代码

<!DOCTYPE html>
<html>
	<body>
		<?php
			$servername = "localhost";
			$username = "username";
			$password = "password";
			
            // 创建连接
			try {
				$conn = new PDO("mysql:host=$servername;", $username, $password);
				echo "连接成功"; 
			}
			catch(PDOException $e)
			{
				echo $e->getMessage();
			}

            // 关闭连接
            $conn = null;
		?>
	</body>
</html>

5.1.2 使用MySQLi

安装：点我可以通过 phpinfo() 查看是否安装成功

代码

<!DOCTYPE html>
<html>
	<body>
		<?php
			$servername = "localhost";
			$username = "username";
			$password = "password";
			 
			// 创建连接
				$conn = new mysqli($servername, $username, $password);
			 
			// 检测连接:面向对象)
				if ($conn->connect_error) {
					die("连接失败: " . $conn->connect_error);
				} 
				echo "连接成功";
				
				
				/*
					需要兼容更早版本
					// 检测连接
					if (mysqli_connect_error()) {
						die("数据库连接失败: " . mysqli_connect_error());
					}
				*/
			
			// 检测连接:面向过程
				if (!$conn) {
					die("Connection failed: " . mysqli_connect_error());
				}

           // 关闭连接:面向对象
                $conn->close();


           // 关闭连接:面向过程
           mysqli_close($conn);

		?>
	</body>
</html>

5.2 创建 MySQL 数据库

创建了一个名为 "myDB" 的数据库

5.2.1 MySQLi 面向对象

<?php
$servername = "localhost";
$username = "username";
$password = "password";
 
// 创建连接
$conn = new mysqli($servername, $username, $password);
// 检测连接
if ($conn->connect_error) {
    die("连接失败: " . $conn->connect_error);
} 
 
// 创建数据库
$sql = "CREATE DATABASE myDB";
if ($conn->query($sql) === TRUE) {
    echo "数据库创建成功";
} else {
    echo "Error creating database: " . $conn->error;
}
 
$conn->close();
?>

5.2.2 MySQLi 面向过程

<?php
$servername = "localhost";
$username = "username";
$password = "password";
 
// 创建连接
$conn = mysqli_connect($servername, $username, $password);
// 检测连接
if (!$conn) {
    die("连接失败: " . mysqli_connect_error());
}
 
// 创建数据库
$sql = "CREATE DATABASE myDB";
if (mysqli_query($conn, $sql)) {
    echo "数据库创建成功";
} else {
    echo "Error creating database: " . mysqli_error($conn);
}
 
mysqli_close($conn);
?>

5.2.3 PDO

<?php
$servername = "localhost";
$username = "username";
$password = "password";

try {
    $conn = new PDO("mysql:host=$servername", $username, $password);

    // 设置 PDO 错误模式为异常
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    // 创建数据库
    $sql = "CREATE DATABASE myDBPDO";

    // 使用 exec() ，因为没有结果返回
    $conn->exec($sql);

    echo "数据库创建成功<br>";
}
catch(PDOException $e)
{
    echo $sql . "<br>" . $e->getMessage();
}

$conn = null;
?>

5.3 创建 MySQL 表

一个数据表有一个唯一名称，并有行和列组成

使用 use myDB 来选择要操作的数据库

5.3.1 MySQLi 面向对象

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";
 
// 创建连接
$conn = new mysqli($servername, $username, $password, $dbname);
// 检测连接
if ($conn->connect_error) {
    die("连接失败: " . $conn->connect_error);
} 
 
// 使用 sql 创建数据表
$sql = "CREATE TABLE MyGuests (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY, 
firstname VARCHAR(30) NOT NULL,
lastname VARCHAR(30) NOT NULL,
email VARCHAR(50),
reg_date TIMESTAMP
)";
 
if ($conn->query($sql) === TRUE) {
    echo "Table MyGuests created successfully";
} else {
    echo "创建数据表错误: " . $conn->error;
}
 
$conn->close();
?>

5.3.2 MySQLi 面向过程

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";
 
// 创建连接
$conn = mysqli_connect($servername, $username, $password, $dbname);
// 检测连接
if (!$conn) {
    die("连接失败: " . mysqli_connect_error());
}
 
// 使用 sql 创建数据表
$sql = "CREATE TABLE MyGuests (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY, 
firstname VARCHAR(30) NOT NULL,
lastname VARCHAR(30) NOT NULL,
email VARCHAR(50),
reg_date TIMESTAMP
)";
 
if (mysqli_query($conn, $sql)) {
    echo "数据表 MyGuests 创建成功";
} else {
    echo "创建数据表错误: " . mysqli_error($conn);
}
 
mysqli_close($conn);
?>

5.3.3 PDO

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDBPDO";
 
try {
    $conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
    // 设置 PDO 错误模式，用于抛出异常
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 
    // 使用 sql 创建数据表
    $sql = "CREATE TABLE MyGuests (
    id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY, 
    firstname VARCHAR(30) NOT NULL,
    lastname VARCHAR(30) NOT NULL,
    email VARCHAR(50),
    reg_date TIMESTAMP
    )";
 
    // 使用 exec() ，没有结果返回 
    $conn->exec($sql);
    echo "数据表 MyGuests 创建成功";
}
catch(PDOException $e)
{
    echo $sql . "<br>" . $e->getMessage();
}
 
$conn = null;
?>

5.4 增insert

5.4.1 MySQLi 面向对象

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";
 
// 创建连接
$conn = new mysqli($servername, $username, $password, $dbname);
// 检测连接
if ($conn->connect_error) {
    die("连接失败: " . $conn->connect_error);
} 
 
$sql = "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('John', 'Doe', 'john@example.com')";
 
if ($conn->query($sql) === TRUE) {
    echo "新记录插入成功";
} else {
    echo "Error: " . $sql . "<br>" . $conn->error;
}
 
$conn->close();
?>

插入多条数据

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";
 
// 创建链接
$conn = new mysqli($servername, $username, $password, $dbname);
// 检查链接
if ($conn->connect_error) {
    die("连接失败: " . $conn->connect_error);
} 
 
$sql = "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('John', 'Doe', 'john@example.com');";
$sql .= "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('Mary', 'Moe', 'mary@example.com');";
$sql .= "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('Julie', 'Dooley', 'julie@example.com')";
 
if ($conn->multi_query($sql) === TRUE) {
    echo "新记录插入成功";
} else {
    echo "Error: " . $sql . "<br>" . $conn->error;
}
 
$conn->close();
?>

5.4.2 MySQLi 面向过程

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";
 
// 创建连接
$conn = mysqli_connect($servername, $username, $password, $dbname);
// 检测连接
if (!$conn) {
    die("Connection failed: " . mysqli_connect_error());
}
 
$sql = "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('John', 'Doe', 'john@example.com')";
 
if (mysqli_query($conn, $sql)) {
    echo "新记录插入成功";
} else {
    echo "Error: " . $sql . "<br>" . mysqli_error($conn);
}
 
mysqli_close($conn);
?>

插入多条数据

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";
 
// 创建链接
$conn = mysqli_connect($servername, $username, $password, $dbname);
// 检查链接
if (!$conn) {
    die("连接失败: " . mysqli_connect_error());
}
 
$sql = "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('John', 'Doe', 'john@example.com');";
$sql .= "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('Mary', 'Moe', 'mary@example.com');";
$sql .= "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('Julie', 'Dooley', 'julie@example.com')";
 
if (mysqli_multi_query($conn, $sql)) {
    echo "新记录插入成功";
} else {
    echo "Error: " . $sql . "<br>" . mysqli_error($conn);
}
 
mysqli_close($conn);
?>

5.4.3 PDO

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDBPDO";
 
try {
    $conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
    // 设置 PDO 错误模式，用于抛出异常
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    $sql = "INSERT INTO MyGuests (firstname, lastname, email)
    VALUES ('John', 'Doe', 'john@example.com')";
    // 使用 exec() ，没有结果返回 
    $conn->exec($sql);
    echo "新记录插入成功";
}
catch(PDOException $e)
{
    echo $sql . "<br>" . $e->getMessage();
}
 
$conn = null;
?>

插入多条数据

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDBPDO";
 
try {
    $conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
    // set the PDO error mode to exception
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 
    // 开始事务
    $conn->beginTransaction();
    // SQL 语句
    $conn->exec("INSERT INTO MyGuests (firstname, lastname, email) 
    VALUES ('John', 'Doe', 'john@example.com')");
    $conn->exec("INSERT INTO MyGuests (firstname, lastname, email) 
    VALUES ('Mary', 'Moe', 'mary@example.com')");
    $conn->exec("INSERT INTO MyGuests (firstname, lastname, email) 
    VALUES ('Julie', 'Dooley', 'julie@example.com')");
 
    // 提交事务
    $conn->commit();
    echo "新记录插入成功";
}
catch(PDOException $e)
{
    // 如果执行失败回滚
    $conn->rollback();
    echo $sql . "<br>" . $e->getMessage();
}
 
$conn = null;
?>

5.5 删delete

<?php
$con=mysqli_connect("localhost","username","password","database");
// 检测连接
if (mysqli_connect_errno())
{
    echo "连接失败: " . mysqli_connect_error();
}

mysqli_query($con,"DELETE FROM Persons WHERE LastName='Griffin'");

mysqli_close($con);
?>

5.6 改update

<?php
$con=mysqli_connect("localhost","username","password","database");
// 检测连接
if (mysqli_connect_errno())
{
        echo "连接失败: " . mysqli_connect_error();
}

mysqli_query($con,"UPDATE Persons SET Age=36 WHERE FirstName='Peter' AND LastName='Griffin'");

mysqli_close($con);
?>

5.7 查select

<?php
$con=mysqli_connect("localhost","username","password","database");
// 检测连接
if (mysqli_connect_errno())
{
    echo "连接失败: " . mysqli_connect_error();
}

$result = mysqli_query($con,"SELECT * FROM Persons WHERE FirstName='Peter'");

while($row = mysqli_fetch_array($result))
{
    echo $row['FirstName'] . " " . $row['LastName'];
    echo "<br>";
}
?>

5.8 数据库 ODBC

ODBC 是一种应用程序编程接口（Application Programming Interface，API），使我们有能力连接到某个数据源（比如一个 MS Access 数据库）

代码

<html>
	<body>
	<?php
		//创建 ODBC 连接
		/*
			这是创建到达 MS Access 数据库的 ODBC 连接的方法：
				1.在控制面板中打开管理工具图标
				2.双击其中的数据源(ODBC)图标
				3.选择系统 DSN 选项卡
				4.点击系统 DSN 选项卡中的添加
				5.选择Microsoft Access Driver。点击完成
				6.在下一个界面，点击选择来定位数据库
				7.为数据库起一个数据源名(DSN)
				8.点击确定
		*/
		
		
		//连接到 ODBC
			$conn=odbc_connect('northwind','','');
			if (!$conn)
			{
				exit("连接失败: " . $conn);
			}

			$sql="SELECT * FROM customers";
			$rs=odbc_exec($conn,$sql);

			if (!$rs)
			{
				exit("SQL 语句错误");
			}
			
			
		echo "<table><tr>";
		echo "<th>Companyname</th>";
		echo "<th>Contactname</th></tr>";

		//取回记录:odbc_fetch_row() 函数用于从结果集中返回记录
			while (odbc_fetch_row($rs))
			{
				//odbc_result() 函数用于从记录中读取字段
				$compname=odbc_result($rs,"CompanyName");
				$conname=odbc_result($rs,"ContactName");

				echo "<tr><td>$compname</td>";
				echo "<td>$conname</td></tr>";
			}
			
		//关闭 ODBC 连接
			odbc_close($conn);
			
		echo "</table>";
	?>
	</body>
</html>