PHP笔记

什么是PHP

PHP：Hypertext Preprocessor，中文名：“超文本预处理器”是一种通用开源脚本语言。
语法吸收了C语言、java和Perl的特点，利于学习，使用广泛，主要适用于web开发领域。
用PHP做出的动态页面与其他的编程语言相比，PHP是将程序嵌入到HTML（标准通用标记语言下的一个应用）文档中去执行，执行效率比完全生成HTML标记的CGI要高许多；PHP还可以执行编译后代码，编译可以达到加密和优化代码运行，使代码运行更快。
PHP 文件可包含文本、HTML、JavaScript代码和 PHP 代码
PHP 代码在服务器上执行，结果以纯 HTML 形式返回给浏览器
PHP 文件的默认文件扩展名是 .php。

PHP能做什么

PHP基础语法

PHP 脚本以<?php开始，以?>结束
PHP中在浏览器输出文本的基础指令：echo 或 print。

常见的输出语句

echo - 可以输出一个或多个字符串，没有返回值
- echo 是一个语言结构，使用的时候可以不用加括号，也可以加上括号： echo 或 echo()。
  示例

<?php
echo "我要学 PHP!<br>";
echo "这是一个", "字符串，", "使用了", "多个", "参数。";
?>
<?php
$txt1="学习 PHP";
$txt2="RUNOOB.COM";
$cars=array("Volvo","BMW","Toyota");
echo $txt1;
echo "<br>";
echo "在 $txt2 学习 PHP ";
echo "<br>";
echo "我车的品牌是 {$cars[0]}";
?>

print - 只允许输出一个字符串，返回值总为 1
- print 同样是一个语言结构，可以使用括号，也可以不使用括号： print 或 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() - 判断一个变量的类型与长度,并输出变量的数值,如果变量有值输的是变量的值并回返数据类型。此函数显示关于一个或多个表达式的结构信息，包括表达式的类型与值。数组将递归展开值，通过缩进显示其结构。

EOF 使用说明

PHP EOF是一种在命令行shell和程序语言里定义一个字符串的方法

必须后接分号，否则编译通不过。
EOF 可以用任意其它字符代替，只需保证结束标识与开始标识一致。
结束标识必须顶格独自占一行(即必须从行首开始，前后不能衔接任何空白和字符)。
开始标识可以不带引号或带单双引号，不带引号与带双引号效果一致，解释内嵌的变量和转义符号，带单引号则不解释内嵌的变量和转义符号。
当内容需要内嵌引号（单引号或双引号）时，不需要加转义符，本身对单双引号转义，此处相当与q和qq的用法。
示例

<?php
echo <<<EOF
        <h1>我的第一个标题</h1>
        <p>我的第一个段落。</p>
EOF;
// 结束需要独立一行且前后不能空格
?>
<?php
$name="runoob";
$a= <<<EOF
        "abc"$name
        "123"
EOF;
// 结束需要独立一行且前后不能空格
echo $a;
?>

注意

以 <<<EOF 开始标记开始，以 EOF 结束标记结束，结束标记必须顶头写，不能有缩进和空格，且在结束标记末尾要有分号。
开始标记和结束标记相同，比如常用大写的 EOT、EOD、EOF 来表示，但是不只限于那几个(也可以用：JSON、HTML等)，只要保证开始标记和结束标记不在正文中出现即可。
位于开始标记和结束标记之间的变量可以被正常解析，但是函数则不可以。在 heredoc 中，变量不需要用连接符 . 或 , 来拼接

变量

PHP 没有声明变量的命令。
变量在第一次赋值给它的时候被创建
PHP是一种弱类型语言，不必向 PHP 声明该变量的数据类型。PHP 会根据变量的值，自动把变量转换为正确的数据类型。
在强类型的编程语言中，必须在使用变量前先声明（定义）变量的类型和名称。
示例

<?php
$iphone7 = 5880;
$iphone7plus = 6088;
echo $iphone6 + $iphone7plus;  //echo是在PHP里面最常用的一个输出、显示功能的命令
?>

特点

变量名以$开头
变量的首字母不能以数字开始
变量的名字区分大小写
变量不要用特殊符号、中文，_不算特殊符号
变量命名要有意义（别写xxx，aaa，ccc）这种变量名

PHP变量作用域

变量的作用域是脚本中变量可被引用/使用的部分。
PHP 有四种不同的变量作用域：

local
global
static
parameter
在所有函数外部定义的变量，拥有全局作用域。除了函数外，全局变量可以被脚本中的任何部分访问，要在一个函数中访问一个全局变量，需要使用 global 关键字。
在 PHP 函数内部声明的变量是局部变量，仅能在函数内部访问
可以在不同函数中使用相同的变量名称，因为这些函数内定义的变量名是局部变量，只作用于该函数内。

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);
?>

常量

PHP 中的常量是指一旦定义后其值不能被改变的标识符。
常量值被定义后，在脚本的其他任何地方都不能被改变。
常量可以用 define() 函数或 const 关键字来定义。
常量在定义后，可以在整个脚本的任何地方使用，无需使用 global 关键字。
常量名称默认是区分大小写的。如果需要定义大小写不敏感的常量，可以在 define() 函数的第三个参数设置为 true。
常量名不需要加 $ 修饰符
definr()示例：bool define ( string $name , mixed $value [, bool $case_insensitive = false ] )
- 该函数有三个参数:
  - name：必选参数，常量名称，即标志符。
  - value：必选参数，常量的值。
  - case_insensitive ：可选参数，如果设置为 TRUE，该常量则大小写不敏感，默认是大小写敏感的。
- 示例·：define("GREETING", "欢迎访问 Runoob.com");
const关键字示例：const CONSTANT_NAME = "value";
常量也可以是数组
示例：define("FRUITS", ["Apple","Banana","Orange"]);

预定义常量

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

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

echo PHP_VERSION; // 输出 PHP 版本，例如 "7.4.1"
echo PHP_OS;      // 输出操作系统，例如 "Linux"
echo PHP_INT_MAX; // 输出最大的整数值，例如 "9223372036854775807"

特点

常量名可以小写，但是通常大写
常量名可以不加引号，但是通常加上引号
在字符串中调用常量的时候，必须在引号外面
常量名建议只用字母和下划线

注释

//		表示单行注释
#		表示单行注释，用的比较少

/*
多行注释，这里是注释区域代码
*/

基础运算类型

整数型（Integer）

英文简写为int
整型可以用三种格式来指定：十进制，十六进制（以 0x 为前缀）或八进制（前缀为 0）。
示例

<?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);
?>

布尔数据类型（Boolean）

示例

<?php
//声明一个变量（拼音）为布尔
$buer=true;
//声明一个变量(英文)
$bool=false;
?>

字符串数据类型（String）

在PHP语言中声明字符串有三种方式：

用单引号声明

<?php
//声明字符串变量$zifu
$zifu='好好学习吧';
echo $zifu;
?>

用双引号声明

<?php
//声明字符串变量$str
$str="我想好好学习";
echo $str;
?>

用字界符声明
- 在变量后面的等号写三个小于号 <<<
- 然后在<<<后面写上字符（建议英文大写字符）
- 然后换行写上任意想写的字符
- 写完后，顶行。在行最开始处，再写上<<<后面的字符和分号。

<?php
$dingjie = <<<ABC
  如果
      非要在这个测试
    前
        面<br />
       加上一段
    <i>有趣的话</i>
    我想说，<h1>努力学习不好么<h1>
ABC;
echo $dingjie
?>

strlen() 函数

strpos() 函数

strpos() 函数用于在字符串内查找一个字符或一段指定的文本。
如果在字符串中找到匹配，该函数会返回第一个匹配的字符位置。如果未找到匹配，则返回 FALSE。

单引号双引号定界符声明的区别

双引号解析变量，但是单引号不解析变量
在双引号里面插入变量，变量后面如果有英文或中文字符，会把这个字符和变量拼起来，视为一整个变量。一定要在变量后面接上特殊字符，例如空格等分开。
如果在双引号里面插变量的时候，后面不想有空格，可以拿大括号将变量包起来。
双引号解析转义字符，单引号不解析转义字符。
单引号效率高于双引号，尽可能使用单引号
双引号和单引号可以互相嵌套，双引号中可以插入单引号，单引号当中插入变量，这个变量会被解析。
神奇的字符串拼接胶水——（.）点，用来拼接字符串。
一般将定界符声明字符串视为双引号一样的功能来看待。

浮点数（Float）

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

var_dump() 函数用于输出变量的相关信息。显示关于一个或多个表达式的结构信息，包括表达式的类型与值。数组将递归展开值，通过缩进显示其结构。
参考资料

数组（Array）

数组可以在一个变量中存储多个值。
PHP 中，array() 函数用于创建数组
有三种类型的数组：
- 数值数组 - 带有数字 ID 键的数组
  - 自动分配 ID 键（ID 键总是从 0 开始）
    - 示例：$cars=array("Volvo","BMW","Toyota");
  - 人工分配 ID 键
    - $cars[0]="Volvo";$cars[1]="BMW";$cars[2]="Toyota";
- 关联数组 - 带有指定的键的数组，每个键关联一个值
  - 创建：$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
  - 或$age['Peter']="35";$age['Ben']="37";$age['Joe']="43";
- 多维数组 - 包含一个或多个数组的数组
  示例

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

获取数组的长度 - count() 函数

count() 函数用于返回数组的长度（元素的数量）
示例：$cars=array("Volvo","BMW","Toyota"); echo count($cars);

遍历并打印关联数组中的所有值，可以使用 foreach 循环

示例

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

PHP数组排序

数组排序

对象（Objiect）

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

<?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 "\therbie: Properties\n";
print_vars($herbie);
?>

PHP关键字this是指向当前对象实例的指针，不指向任何其他对象或类。

空值（NULL）

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

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

资源类型（Resource）

resource 是一种特殊变量，保存了到外部资源的一个引用。
常见资源数据类型有打开文件、数据库连接、图形画布区域等。
由于资源类型变量保存有为打开文件、数据库连接、图形画布区域等的特殊句柄，因此将其它类型的值转换为资源没有意义。
使用 get_resource_type() 函数可以返回资源（resource）类型
- get_resource_type(resource $handle): string
  示例

<?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数据类型之查看和判断数据类型

查看数据类型：

gettype（传入一个变量）能获得变量的类型
var_dump（传入一个变量）输出变量类型和值

<?php
//声明一个变量88.8,可以自己多做几次实现换成其他类型看看$type输出是多少。
$float = 88.8;
$type = gettype($float);
echo $type;
?>

<?php
//多换几个类型试试
$str = '你喜欢男人还是喜欢女人';
$type = var_dump($str);
echo $type;
?>

类型比较

虽然 PHP 是弱类型语言，但也需要明白变量类型及它们的意义，因为我们经常需要对 PHP 变量进行比较，包含松散和严格比较。

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

0 == false: bool(true)
0 === false: bool(false)

0 == null: bool(true)
0 === null: bool(false)

false == null: bool(true)
false === null: bool(false)

"0" == false: bool(true)
"0" === false: bool(false)

"0" == null: bool(false)
"0" === null: bool(false)

"" == false: bool(true)
"" === false: bool(false)

"" == null: bool(true)
"" === null: bool(false)

其他比较示例

运算符

并置运算符

在 PHP 中，只有一个字符串运算符。并置运算符 (.) 用于把两个字符串值连接起来。
示例

<?php
$txt1="Hello world!";
$txt2="What a nice day!";
echo $txt1 . " " . $txt2;
?>

PHP比较特殊的运算符

-x 设置负数取 x 的相反符号
~x 取反 x 取反，按二进制位进行"取反"运算
a . b 并置连接两个字符串
整除运算符 intdiv()，该函数返回值为第一个参数除于第二个参数的值并取整（向下取整）
- 示例
  - <?php var_dump(intdiv(10, 3));?>

PHP正常比较运算符以外的比较运算符

x <> y 不等于如果 x 不等于 y，则返回 true
x !== y 不绝对等于如果 x 不等于 y，或它们类型不相同，则返回 true

PHP逻辑运算符

PHP数组运算符

运算符	名称	描述
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
示例

<?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);
?>

三元运算符

(expr1) ? (expr2) : (expr3)
自 PHP 5.3 起，可以省略三元运算符中间那部分。表达式 expr1 ?: expr3 在 expr1 求值为 TRUE 时返回 expr1，否则返回 expr3。
示例

<?php
// 普通写法
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';
echo $username, PHP_EOL;
//通过判断 $_GET 请求中含有 user 值，如果有返回 $_GET['user']，否则返回 nobody
// PHP 5.3+ 版本写法
$username = $_GET['user'] ?: 'nobody';
echo $username, PHP_EOL;
?>

在 PHP7+ 版本多了一个 NULL 合并运算符 ??
示例

<?php
// 如果 $_GET['user'] 不存在返回 'nobody'，否则返回 $_GET['user'] 的值
$username = $_GET['user'] ?? 'nobody';
// 类似的三元运算符
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';
?>

组合比较符

也称之为太空船操作符，符号为 <=>。组合比较运算符可以轻松实现两个变量的比较，当然不仅限于数值类数据的比较。

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

优先级

结合方向	运算符	附加信息
无	`clone new`	clone 和 new
左	`[`	array()
右	`++ -- ~ (int) (float) (string) (array) (object) (bool) @`	类型和递增／递减
无	`instanceof`	类型
右	`!`	逻辑运算符
左	`* / %`	算术运算符
左	`+ – .`	算术运算符和字符串运算符
左	`<< >>`	位运算符
无	`== != === !== <>`	比较运算符
左	`&`	位运算符和引用
左	`^`	位运算符
左	`	`
左	`&&`	逻辑运算符
左	`
左	`? :`	三元运算符
右	`= += -= *= /= .= %= &=	= ^= <<= >>= =>`
左	`and`	逻辑运算符
左	`xor`	逻辑运算符
左	`or`	逻辑运算符
左	`,`	多处用到
运算符优先级中，or 和		，&& 和 and 都是逻辑运算符，效果一样，但是其优先级却不一样。
示例

<?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 
?>

括号

通过括号的配对来明确标明运算顺序，而非靠运算符优先级和结合性来决定，通常能够增加代码的可读性

超级全局变量

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

$GLOBALS
- 是一个包含了全部变量的全局组合数组。变量的名字就是数组的键。

<?php 
$x = 75; 
$y = 25;
 
function addition() 
{ 
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y']; 
}
 
addition(); 
echo $z; 
?>

$_SERVER
- 是一个包含了诸如头信息、路径、以及脚本位置等等信息的数组。
- 这个数组中的项目由 Web 服务器创建。不能保证每个服务器都提供全部项目；服务器可能会忽略一些，或者提供一些没有在这里列举出来的项目。
- $_SERVER 变量中的重要元素

<?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'];
?>

$_REQUEST
- 用于收集HTML表单提交的数据
- 下实例显示了一个输入字段（input）及提交按钮(submit)的表单(form)。当用户通过点击 "Submit" 按钮提交表单数据时, 表单数据将发送至
  标签中 action 属性中指定的脚本文件。
- 在这个实例中，我们指定文件来处理表单数据。如果你希望其他的PHP文件来处理该数据，你可以修改该指定的脚本文件名。
- 然后，我们可以使用超级全局变量 $_REQUEST 来收集表单中的 input 字段数据

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

$_POST
- 被广泛应用于收集表单数据，在HTML form标签的指定该属性："method="post"。
- 可以使用超级全局变量 $_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
- 同样被广泛应用于收集表单数据，在HTML form标签的指定该属性："method="get"。
- $_GET 也可以收集URL中发送的数据。
- 示例：<a href="test_get.php?subject=PHP&web=runoob.com">Test $GET</a>
- 当用户点击链接 "Test $GET", 参数 "subject" 和 "web" 将发送至"test_get.php",可以在 "test_get.php" 文件中使用 $_GET 变量来获取这些数据。
- 示例：<?php echo "Study".$_GET['subject'] . " @ " . $_GET['web'];?>

流程控制

if-elseif-else语句使用

示例

<?php
If(判断语句1){
   执行语句体1
}elseif（判断语句2）{
   执行语句体2
} elseif（判断语句n）{
   执行语句体n
}else{
   最后的else语句可选
}
?>

switch语句使用

<?php
switch (expression) {
    case value1:
        // 代码块1
        break;
    case value2:
        // 代码块2
        break;
    // 更多的 case 语句
    default:
        // 如果没有匹配的值
}
?>
<?php
$favcolor="red";
switch ($favcolor)
{
case "red":
    echo "你喜欢的颜色是红色!";
    break;
case "blue":
    echo "你喜欢的颜色是蓝色!";
    break;
case "green":
    echo "你喜欢的颜色是绿色!";
    break;
default:
    echo "你喜欢的颜色不是 红, 蓝, 或绿色!";
}
?>

default: 是可选的，用于指定当没有匹配的 case 时执行的代码块。

while循环语句说明

<?php
//定义需要往返的次数,老外喜欢从0开始计数,所以系统也是从0开始
$count=0;
//while后面接布尔值判断,为真执行,为假停止
//$count小于100的时候执行,也就是$count为0至99的时候执行.
//如果$count不小于100了,循环停止执行后续的代码

//循环开始处
while($count < 100){
    echo "这是王总第 $count 次出差 <br />";
    //每次执行让$count+1,这样的话,就不会产生$count永远小于100的情况了
    $count++;
}
//循环结束
?>

do-while循环

<?php
$i=0;
do {
  echo $i;
}while($i >0);
?>

do…while与while区别

它们的值得检查时机不同.
do…while不论while判断是否成立,先执行一次代码框循环语句,保证会执行一次(表达式的真值在每次循环结束后检查)
while循环会检查布尔判断区域,成立则执行,不成立则不执行.

for循环语句

for(表达式1;表达式2;表达式3)
  需要执行的代码段;
}

foreach循环语句

根据数组中每个元素来循环代码块，用于遍历数组

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

每进行一次循环，当前数组元素的值就会被赋值给 $value 变量（数组指针会逐一地移动），在进行下一次循环时，您将看到数组中的下一个值。

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

每一次循环，当前数组元素的键与值就都会被赋值给 $key 和 $value 变量（数字指针会逐一地移动），在进行下一次循环时，你将看到数组中的下一个键与值。

goto循环语句

<?php
goto wan;
echo '天王盖地虎';
wan:
echo '小鸡炖蘑菇';
?>

<?php
for ($i=0;$i<100;$i++){
    echo '第'.$i.'每周往返北京大连<br />';
    if($i == 17){
        goto end;
    }
}
end:
echo '集团公司要求停止此项';
?>

函数

创建函数
准则：
- 函数的名称应该提示出它的功能
- 函数名称以字母或下划线开头（不能以数字开头）

<?php
function functionName()
{
    // 要执行的代码
}
functionName()//函数调用
?>

添加参数

<?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");
?>

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

函数返回值

如需让函数返回一个值，请使用 return 语句

<?php
function add($x,$y)
{
    $total=$x+$y;
    return $total;
}
 
echo "1 + 16 = " . add(1,16);
?>

变量函数

变量函数是指在 PHP 中，将一个变量作为函数名来调用的函数。
变量函数可以让我们在运行时动态地决定调用哪个函数。

<?php
function foo() {
    echo "In foo()<br />\n";
}

function bar($arg = '')
{
    echo "In bar(); argument was '$arg'.<br />\n";
}

// 使用 echo 的包装函数
function echoit($string)
{
    echo $string;
}

$func = 'foo';
$func();        // 调用 foo()

$func = 'bar';
$func('test');  // 调用 bar()

$func = 'echoit';
$func('test');  // 调用 echoit()
?>

也可以用变量函数的语法来调用一个对象的方法

<?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()

?>

魔术常量

魔术常量是一组特殊的常量，它们可以在任何位置被访问，并且会自动获取当前的值。这些常量通常用于获取脚本的位置、日期时间、操作系统类型等信息。

常用的魔术常量

`__LINE__`	返回当前代码行号
`__FILE__`	返回当前文件的完整路径和文件名
`__DIR__`	返回当前文件所在的目录
`__FUNCTION__`	返回当前函数的名称
`__CLASS__`	返回当前类的名称
`__TRAIT__`	返回当前trait的名称
`__METHOD__`	返回当前类的方法名
`__NAMESPACE__`	返回当前命名空间的名称
`PHP_VERSION`	返回PHP的版本号
`PHP_OS`	返回PHP服务器的操作系统类型
`PHP_SAPI`	返回PHP服务器的SAPI（Server API）名称
`PHP_EOL`	返回当前操作系统的换行符
使用示例

<?php echo '这是第 " '  . __LINE__ . ' " 行'; ?>
<?php echo '该文件位于 " '  . __FILE__ . ' " '; ?>
<?php echo '该文件位于 " '  . __DIR__ . ' " '; ?>
<?php function test() {
    echo  '函数名为：' . __FUNCTION__ ;
}
test(); ?>
<?php  class test {
    function _print() {
        echo '类名为：'  . __CLASS__ . "<br>";
        echo  '函数名为：' . __FUNCTION__ ;
    }
}
$t = new test();
$t->_print();  ?>//注意自 PHP 5.4 起 __CLASS__ 对 trait 也起作用。当用在 trait 方法中时，__CLASS__ 是调用 trait 方法的类的名字。
<?php
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();
?>

ues关键字

用于引入命名空间中的类、函数、常量等，以便在当前命名空间中使用它们而不需要完全限定名称。
这在处理大型项目和避免命名冲突时非常有用
use 关键字后面跟着 as 通常用于为引入的命名空间中的类、函数或常量创建一个别名

new关键字

用于实例化一个类的对象。
当想要创建一个类的实例时，你需要使用 new 关键字，后跟类名和一对括号 ()，括号内可以传递构造函数所需的参数。

命名空间

目的是解决重名问题
可以解决以下两类问题

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

默认情况下，所有常量、类和函数名都放在全局空间下
命名空间通过关键字namespace 来声明。如果一个文件中包含命名空间，它必须在其它所有代码之前声明命名空间
定义命名空间

命名空间的使用

非限定名称，或不包含前缀的类名称，例如 $a=new foo(); 或 foo::staticmethod();。如果当前命名空间是 currentnamespace，foo 将被解析为 currentnamespace\foo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，则 foo 会被解析为foo。

警告：如果命名空间中的函数或常量未定义，则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称。

限定名称,或包含前缀的名称，例如 $a = new subnamespace\foo(); 或 subnamespace\foo::staticmethod();。如果当前的命名空间是 currentnamespace，则 foo 会被解析为 currentnamespace\subnamespace\foo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，foo 会被解析为subnamespace\foo。
完全限定名称，或包含了全局前缀操作符的名称，例如， $a = new \currentnamespace\foo(); 或 \currentnamespace\foo::staticmethod();。在这种情况下，foo 总是被解析为代码中的文字名(literal name)currentnamespace\foo。

访问当前命名空间内部元素

PHP支持两种抽象的访问当前命名空间内部元素的方法

NAMESPACE 魔术常量
- echo __NAMESPACE__
namespace关键字。
- 可用来显式访问当前命名空间或子命名空间中的元素。它等价于类中的 self 操作符。

<?php
namespace MyProject;

use blah\blah as mine; // 引入了 blah\blah 命名空间，并定义了个别名mine

mine\mine(); // 调用函数 blah\blah\mine()
namespace\blah\mine(); // 调用函数 MyProject\blah\mine()

namespace\func(); // 调用函数 MyProject\func()
namespace\sub\func(); // 调用函数 MyProject\sub\func()
namespace\cname::method(); // 调用 MyProject\cname 类的静态方法
$a = new namespace\sub\cname(); // 实例化 MyProject\sub\cname 类的对象
$b = namespace\CONSTANT; // 将常量 MyProject\CONSTANT 的值赋给 $b
?>

使用命名空间：别名/导入

使用use操作符导入/使用别名

<?php
namespace foo;
use My\Full\Classname as Another;

// 下面的例子与 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 对象
?>

一行中包含多个use语句

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化 My\Full\Classname 对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
?>

导入和动态名称

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>

导入和完全限定名称

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化 My\Full\Classname 类
$obj = new \Another; // 实例化 Another 类
$obj = new Another\thing; // 实例化 My\Full\Classname\thing 类
$obj = new \Another\thing; // 实例化 Another\thing 类
?>

使用命名空间：后备全局函数/常量

在一个命名空间中，当 PHP 遇到一个非限定的类、函数或常量名称时，它使用不同的优先策略来解析该名称。
类名称总是解析到当前命名空间中的名称。因此在访问系统内部或不包含在命名空间中的类名称时，必须使用完全限定名称

<?php
namespace A\B\C;
class Exception extends \Exception {}

$a = new Exception('hi'); // $a 是类 A\B\C\Exception 的一个对象
$b = new \Exception('hi'); // $b 是类 Exception 的一个对象

$c = new ArrayObject; // 致命错误, 找不到 A\B\C\ArrayObject 类
?>

对于函数和常量来说，如果当前命名空间中不存在该函数或常量，PHP 会退而使用全局空间中的函数或常量。

命名空间的顺序

全局空间

如果没有定义任何命名空间，所有的类与函数的定义都是在全局空间，与 PHP 引入命名空间概念前一样。在名称前加上前缀 \ 表示该名称是全局空间中的名称，即使该名称位于其它的命名空间中时也是如此。

面向对象

面向对象（Object-Oriented，简称 OO）是一种编程思想和方法，它将程序中的数据和操作数据的方法封装在一起，形成"对象"，并通过对象之间的交互和消息传递来完成程序的功能。
面向对象编程强调数据的封装、继承、多态和动态绑定等特性，使得程序具有更好的可扩展性、可维护性和可重用性。
对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象。
对象的主要三个特性
- 对象的行为：对象可以执行的操作，比如：开灯，关灯就是行为。
- 对象的形态：对对象不同的行为是如何响应的，比如：颜色，尺寸，外型。
- 对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。
面对对象的主要三个特性
- 封装：指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。
  - 通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装。
- 继承：指可以创建一个新的类，该类继承了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。
- 多态：指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象的统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。
  - 在 PHP 中，多态可以通过实现接口和使用抽象类来实现。

面对对象内容

类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
对象 − 是类的实例。
成员变量 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可成为对象的属性。
成员函数 − 定义在类的内部，可用于访问对象的数据。
继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
- 使用关键字 extends 来继承一个类，PHP 不支持多继承
- 示例：class Child extends Parent { // 代码部分 }

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

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

父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
子类 − 一个类继承其他类称为子类，也可称为派生类。
多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
构造函数 − 是一种特殊的方法，主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

创建对象

类创建后，我们可以使用 new 运算符来实例化该类的对象

$mercedes = new Car ();
$bmw = new Car ();
$audi = new Car ();

通过 Car 类创建了三个对象：Mercedes, Bmw, 和 Audi

类定义

<?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;
  }
}
?>

解析

类使用 class 关键字后加上类名定义。
类名后的一对大括号({})内可以定义变量和方法。
类的变量使用 var 来声明, 变量也可以初始化值。
函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。
变量 $this 代表自身的对象。
PHP_EOL 为换行符。

调用成员方法

在实例化对象后，可以使用该对象调用成员方法，该对象的成员方法只能操作该对象的成员变量

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

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

// 调用成员函数，获取标题和URL
$runoob->getTitle();
$taobao->getTitle();
$google->getTitle();

$runoob->getUrl();
$taobao->getUrl();
$google->getUrl();

方法重写

如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖，也称为方法的重写

访问控制

PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。
- public（公有）：公有的类成员可以在任何地方被访问。
- protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
- private（私有）：私有的类成员则只能被其定义所在的类访问。
- 如果没有设置这些关键字，则该方法默认为公有
属性的访问控制
- 类属性必须定义为公有，受保护，私有之一。如果用 var 定义，则被视为公有。

class MyClass
{
    // 声明一个公有的构造函数
    public function __construct() { }

    // 声明一个公有的方法
    public function MyPublic() { }

    // 声明一个受保护的方法
    protected function MyProtected() { }

    // 声明一个私有的方法
    private function MyPrivate() { }

    // 此方法为公有
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

接口

使用接口，可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。
接口是通过 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;
    }
}

抽象类

任何一个类，若它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。
定义为抽象的类不能被实例化。
被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。
继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。
- 例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。

<?php
abstract class AbstractClass
{
 // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . PHP_EOL;
    }
}

class ConcreteClass1 extends AbstractClass
{
    protected function getValue() {
        return "ConcreteClass1";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}

class ConcreteClass2 extends AbstractClass
{
    public function getValue() {
        return "ConcreteClass2";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass2";
    }
}

$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . PHP_EOL;

$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
?>

此外，子类方法可以包含父类抽象方法中不存在的可选参数。
- 例如，子类定义了一个可选参数，而父类抽象方法的声明里没有，则也是可以正常运行的

<?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 在静态方法中不可用。
静态属性不可以由对象通过 -> 操作符来访问。
自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字 self，parent 或 static。

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

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

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

Final 关键字

如果父类中的方法被声明为 final，则子类无法覆盖该方法。
如果一个类被声明为 final，则不能被继承。

<?php
class BaseClass {
   public function test() {
       echo "BaseClass::test() called" . PHP_EOL;
   }
   
   final public function moreTesting() {
       echo "BaseClass::moreTesting() called"  . PHP_EOL;
   }
}

class ChildClass extends BaseClass {
   public function moreTesting() {
       echo "ChildClass::moreTesting() called"  . PHP_EOL;
   }
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>

调用父类构造方法

PHP 不会在子类的构造方法中自动的调用父类的构造方法。\
要执行父类的构造方法，需要在子类的构造方法中调用 parent::__construct() 。

<?php
class BaseClass {
   function __construct() {
       print "BaseClass 类中构造方法" . PHP_EOL;
   }
}
class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();  // 子类构造方法不能自动调用父类的构造方法
       print "SubClass 类中构造方法" . PHP_EOL;
   }
}
class OtherSubClass extends BaseClass {
    // 继承 BaseClass 的构造方法
}

// 调用 BaseClass 构造方法
$obj = new BaseClass();

// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();

// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>

异常

是指程序运行时发生的错误条件，它通常表示程序的某个部分没有按预期执行。
异常可以是由编程错误引起的，比如尝试除以零、数组越界、无效的输入数据等，也可以是由外部事件引起的，比如文件不存在、网络连接失败等
异常处理是程序设计中的一种结构，用于处理程序执行过程中出现的异常情况。它允许程序在发生错误时，不直接崩溃，而是能够优雅地处理错误，提供错误信息，或者尝试恢复到正常状态
- 异常抛出（Throw）：当检测到错误条件时，程序可以主动抛出一个异常。这通常通过使用 throw 语句完成。
- 异常捕获（Catch）：程序可以捕获并处理抛出的异常。这通常通过 try 和 catch 代码块来实现。
- 异常传播（Propagation）：如果一个异常没有在当前作用域内被捕获，它可以被传播到调用栈中的上一层，直到被捕获或者导致程序终止。
- 异常处理（Handling）：这涉及到对异常的响应，比如记录错误日志、清理资源、通知用户等。
- 异常链（Exception Chaining）：当一个异常处理过程中又抛出了另一个异常时，可以保留原始异常的信息，这在调试时非常有用。
- finally块（Finally）：无论是否捕获到异常，finally 块中的代码总是会被执行，通常用于资源清理。

catch关键字

当抛出一个异常并捕获它时，会按照 catch 块的顺序来匹配异常类型。如果一个 catch 块匹配到了抛出的异常类型，那么之后的 catch 块将不会被执行

<?php
class MyException extends Exception
{
}
try {
    throw new MyException('Oops!');
}//尝试抛出一个 MyException 类型的异常,当异常被抛出时，PHP 会从上到下检查 catch 块 
//$e 被用作 catch 块中的异常参数。当异常被捕获时，$e 包含了异常对象，你可以使用这个对象来获取异常的信息，比如异常的消息、代码和回溯信息。
/*try {
    // 一些可能会抛出异常的代码
} catch (Exception $e) {
    // 这里可以访问 $e 来获取异常的详细信息
    echo "Caught an exception: " . $e->getMessage() . "\n";
    echo "Exception code: " . $e->getCode() . "\n";
    echo "Stack trace:\n" . $e->getTraceAsString() . "\n";
}*/
//$e->getMessage() 返回异常的消息，$e->getCode() 返回异常的代码，$e->getTraceAsString() 返回异常的堆栈跟踪信息
catch (Exception $e) {
    echo "Caught Exception\n";
} //第一个 catch 块捕获的是 Exception 类型的异常。由于 MyException 继承自 Exception，这个 catch 块会匹配到抛出的异常
catch (MyException $e) {
    echo "Caught MyException\n";
}
?>

try关键字

try 关键字用于引入一个特殊的代码块，这个代码块中包含可能抛出异常的代码。
try 关键字后面跟着一对花括号 {}，其中包含了需要尝试执行的代码。
如果在 try 代码块中抛出了一个异常，那么这个异常会被立即抛出，并且控制流会跳转到匹配的 catch 块
如果需要，还可以包含一个 finally 块，它总是会被执行，无论是否捕获到异常
使用 try 和 catch 可以帮助处理潜在的错误情况，并且保持代码的清晰和易于维护。通过捕获异常，你可以决定如何响应错误，而不是让程序完全失败

备注

数值字符串作为整数进行比较。
在 PHP 中，数组的键（key）可以是整数、浮点数、字符串，甚至是对象。不过，整数键会被转换成整数，浮点数键会被转换成字符串，因为数组的键总是以字符串形式存储

PHP表单

注：当处理 HTML 表单时，PHP 能把来自 HTML 页面中的表单元素自动变成可供 PHP 脚本使用。

下拉菜单

单选

以下实例我们设置了下拉菜单三个选项，表单使用 GET 方式获取数据，action 属性值为空表示提交到当前脚本，我们可以通过 select 的 name 属性获取下拉菜单的值：

<?php
$q = isset($_GET['q'])? htmlspecialchars($_GET['q']) : '';
if($q) {
        if($q =='RUNOOB') {
                echo '菜鸟教程<br>http://www.runoob.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
}
?>

注：isset($_GET['q'])：这个函数检查$_GET数组中是否存在键名为q的元素。如果存在，返回true；如果不存在，返回false。注：`htmlspecialchars($_GET['q'])`：这个函数用于将特殊字符转换为HTML实体。这样做可以防止跨站脚本攻击（XSS），因为它会转义任何潜在的危险字符，比如<、>、&等

多选

多选需要设置（ multiple="multiple"），可以通过将设置 select name="q[]" 以数组的方式获取数据，以下使用 POST 方式提交，代码如下所示：

<?php
$q = isset($_POST['q'])? $_POST['q'] : '';
if(is_array($q)) {
    $sites = array(
            'RUNOOB' => '菜鸟教程: http://www.runoob.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
}
?>

单选按钮

单选按钮表单中 name 属性的值是一致的，value 值是不同的，代码如下所示：

<?php
$q = isset($_GET['q'])? htmlspecialchars($_GET['q']) : '';
if($q) {
        if($q =='RUNOOB') {
                echo '菜鸟教程<br>http://www.runoob.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
}
?>

多（复）选框

<?php
$q = isset($_POST['q'])? $_POST['q'] : '';
if(is_array($q)) {
    $sites = array(
            'RUNOOB' => '菜鸟教程: http://www.runoob.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
}
?>

PHP表单验证

$_SERVER["PHP_SELF"] 变量

是超级全局变量，返回当前正在执行脚本的文件名，与 document root相关,所以， $_SERVER["PHP_SELF"]会发送表单数据到当前页面，而不是跳转到不同的页面。
$_SERVER["PHP_SELF"]变量有可能会被黑客使用！当黑客使用跨网站脚本的HTTP链接来攻击时，$_SERVER["PHP_SELF"]服务器变量也会被植入脚本。原因就是跨网站脚本是附在执行文件的路径后面的，因此$_SERVER["PHP_SELF"]的字符串就会包含HTTP链接后面的JavaScript程序代码
XSS又叫 CSS (Cross-Site Script) ,跨站脚本攻击。恶意攻击者往Web页面里插入恶意html代码，当用户浏览该页之时，嵌入其中Web里面的html代码会被执行，从而达到恶意用户的特殊目的。

htmlspecialchars()方法

& （和号）成为 &amp;
" （双引号）成为 &quot;
' （单引号）成为 &#039;
< （小于）成为 &lt;
> （大于）成为 &gt;

必需字段

验证邮件和URL（涉及正则表达式）

验证

$_GET变量

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

$_POST变量

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

$_REQUEST变量

预定义的 $_REQUEST 变量包含了 $_GET、$_POST 和 $_COOKIE 的内容。 $_REQUEST 变量可用来收集通过 GET 和 POST 方法发送的表单数据。

posted @ 2024-10-26 21:36 micryfotctf 阅读(7) 评论(0) 编辑收藏举报

刷新页面返回顶部

mycrictfchuyin