PHP 学习准备

学习路线

1.熟悉HTML/CSS/JS等网页基本元素，完成阶段可自行制作简单的网页，对元素属性相对熟悉

2.理解动态语言的概念和运做机制，熟悉基本的PHP语法

3.学习如何将PHP与HTML结合起来，完成简单的动态页面

4.接触学习MySQL，开始设计数据库

5.不断巩固PHP语法，熟悉大部分的PHP常用函数，理解面向对象编程，MySQL优化，以及一些模板和框架

6.最终完成一个功能齐全的动态站点

开发工具

PHP服务器组件: WampServer,这也是目前window平台上使用最广泛的，操作也非常简单

PHP的IDE: Eclipse for PHP

MySql管理工具: Navicat for Mysql，Navicat for MySQL是一套专为MySQL设计的强大数据库管理及开发工具

文本编辑器: Notepad++

在线编辑器

PHP在线编辑器

PHP 简介

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

PHP 脚本在服务器上执行

文件

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

PHP 代码在服务器上执行，结果以纯 HTML 形式返回给浏览器

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

作用

PHP 可以生成动态页面内容

PHP 可以创建、打开、读取、写入、关闭服务器上的文件

PHP 可以收集表单数据

PHP 可以发送和接收 cookies

PHP 可以添加、删除、修改您的数据库中的数据

PHP 可以限制用户访问您的网站上的一些页面

PHP 可以加密数据

优点

PHP 可在不同的平台上运行（Windows、Linux、Unix、Mac OS X 等）

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

PHP 提供了广泛的数据库支持

PHP 是免费的

PHP 易于学习

PHP 语法

PHP 脚本在服务器上执行，然后将纯 HTML 结果发送回浏览器

基本的PHP语法

PHP 脚本以 <?php 开始，以 ?> 结束

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

PHP 文件通常包含 HTML 标签和一些 PHP 脚本代码

PHP 中的每个代码行都必须以分号结束

输出文本的基础指令：echo 和 print

<!DOCTYPE html>
<html>
<body>
<h1>My first PHP page</h1>
<?php
echo "Hello World!"; // hello World!
?>  
</body>
</html>

注释

<!DOCTYPE html>
<html>
<body>
  
<?php
// 这是单行注释
# 这也是单行注释
/*
这是多行注释
多行注释
多行注释
*/
echo "Hello World!"; // hello World!
?>
  
</body>
</html>

PHP 变量

变量以$符号开始，后面跟着变量的名称

变量名必须以字母或者下划线字符开始

变量名只能包含字母数字字符以及下划线

变量名不能包含空格

变量名是区分大小写的

<?php 
$x=5; 
$y=6; 
$z=$x+$y; 
echo $z; // 11
?>

声明PHP变量

PHP没有声明变量的命令

变量在您第一次赋值给它的时候被创建

<?php 
$txt="Hello world!"; 
$x=5; 
$y=10.5; 
echo $txt; // Hello world!
?>

弱类型语言

PHP会根据变量的值，自动把变量转换为正确的数据类型

在强类型的编程语言中，我们必须在使用变量前先声明变量的类型和名称

变量作用域

PHP有四种不同的变量作用域

global
local
static
parameter

global全局作用域

global关键字用于函数内访问全局变量

在函数内调用函数外定义的全局变量，我们需要在函数中的变量前加上global关键字

<?php 
$x=5; 
$y=10; 
function myTest() 
{ 
    global $x,$y; 
    $y=$x+$y; 
} 
myTest(); 
echo $y; // 15 
?>

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

<?php 
$x=5; 
$y=10; 
function myTest() 
{ 
    $GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y']; 
}  
myTest(); 
echo $y;  // 15
?>

local局部作用域

在PHP函数内部声明的变量是局部变量，仅能在函数内部访问

<?php 
$x=5; // 全局变量 
function myTest() 
{ 
    $y=10; // 局部变量 
    echo "<p>测试函数内变量:<p>"; 
    echo "变量 x 为: $x"; 
    echo "<br>"; 
    echo "变量 y 为: $y"; 
}  
myTest(); // x:  y:10
echo "<p>测试函数外变量:<p>"; 
echo "变量 x 为: $x"; 
echo "<br>"; 
echo "变量 y 为: $y"; // x:5 y:
?>

Static静态作用域

函数完成时，它的所有变量会被删除,要做到这一点，在第一次声明变量时,使用 static 关键字,即局部变量不会被删除

<?php 
function myTest() 
{ 
    static $x=0; 
    echo $x; 
    $x++; 
} 
myTest(); 
myTest(); 
myTest(); 
?>

parameter参数作用域

参数是通过调用代码将值传递给函数的局部变量

参数是在参数列表中声明的，作为函数声明的一部分

<?php
function myTest($x)
{
    echo $x;
}
myTest(5);
?>

PHPecho/print语句

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

echo语句

echo 命令输出字符串（字符串可以包含 HTML 标签）

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

echo 命令输出变量和字符串

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

pring语句

print 命令输出字符串（字符串可以包含 HTML 标签）

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

print 命令输出变量和字符串

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

PHP EOF(heredoc)

PHP EOF(heredoc)是一种在命令行shell（如sh、csh、ksh、bash、PowerShell和zsh）和程序语言（像Perl、PHP、Python和Ruby）里定义一个字串的方法

注意

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

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

在 heredoc 中，变量不需要用连接符 . 或 , 来拼接

<?php
$name="runoob";
$a= <<<EOF
    "abc"$name
    "123"
EOF;
// 结束需要独立一行且前后不能空格
echo $a;
?>

PHP 数据类型

String（字符串）
Integer（整型）
Float（浮点型）
Boolean（布尔型）
Array（数组）
Object（对象）
NULL（空值）

PHP字符串

一个字符串是一串字符的序列，就像 “Hello world!”

<!DOCTYPE html>
<html>
<body>
<?php 
$x = "Hello world!"; 
echo $x;//Hello world!
echo "<br>"; 
$x = 'Hello world!';//Hello world!
echo $x;
?>
</body>
</html>

PHP整型

整型是一个没有小数的数字

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

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

PHP浮点型

浮点数是带小数部分的数字，或是指数形式

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

PHP布尔型

布尔型可以是 TRUE 或 FALSE

1 2	$x=true; $y=false;

PHP数组

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

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

PHP对象

对象数据类型也可以用于存储数据,在 PHP 中，对象必须声明

首先，你必须使用class关键字声明类对象。类是可以包含属性和方法的结构

然后我们在类中定义数据类型，然后在实例化的类中使用数据类型

//PHP关键字this就是指向当前对象实例的指针，不指向任何其他对象或类
<!DOCTYPE html>
<html>
<body>
<?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);//herbie: Properties color = white
?>  
</body>
</html>

PHPNULL值

NULL值表示变量没有值,NULL是数据类型为NULL的值

NULL 值指明一个变量是否为空值。同样可用于数据空值和NULL值的区别。

可以通过设置变量值为 NULL 来清空变量数据

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

PHP常量

常量值被定义后，在脚本的其他任何地方都不能被改变

PHP常量

常量是一个简单值的标识符。该值在脚本中不能改变

一个常量由英文字母、下划线、和数字组成,但数字不能作为首字母出现。 (常量名不需要加 $ 修饰符)

常量在整个脚本中都可以使用

设置PHP常量

设置常量，使用 define() 函数,该函数有三个参数:

name：必选参数，常量名称，即标志符。
value：必选参数，常量的值。
case_insensitive ：可选参数，如果设置为 TRUE，该常量则大小写不敏感。默认是大小写敏感的

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

常量是全局的

常量在定义后，默认是全局变量，可以在整个运行的脚本的任何地方使用

//函数内使用常量，即便常量定义在函数外也可以正常使用常量
<?php
define("GREETING", "欢迎访问 Runoob.com");
 
function myTest() {
    echo GREETING;
}
 
myTest();    // 输出 "欢迎访问 Runoob.com"
?>

PHP字符串

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

<?php 
$txt="Hello world!"; 
echo $txt; // "Hello world!
?>

PHP并置运算符

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

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

PHPstrlen()函数

strlen()函数返回字符串的长度

1
2
3

<?php 
echo strlen("Hello world!");  // 12
?>

PHPstrpos()函数

strpos() 函数用于在字符串内查找一个字符或一段指定的文本

如果在字符串中找到匹配，该函数会返回第一个匹配的字符位置。如果未找到匹配，则返回 FALSE

1
2
3

<?php 
echo strpos("Hello world!","world"); //6
?>

PHP运算符

PHP算术运算符

x + y,x 和 y 的和
x - y,x 和 y 的差
x * y,x 和 y 的积
x / y,x 和 y 的商
x % y,x 除以 y 的余数
(-x),x 取反
a . b,连接两个字符串

<?php 
$x=10; 
$y=6;
echo ($x + $y); // 输出16
echo '<br>';  // 换行
echo ($x - $y); // 输出4
echo '<br>';  // 换行
echo ($x * $y); // 输出60
echo '<br>';  // 换行
echo ($x / $y); // 输出1.6666666666667
echo '<br>';  // 换行
echo ($x % $y); // 输出4
echo '<br>';  // 换行
echo -$x;
?>

PHP赋值运算符

x = y,左操作数被设置为右侧表达式的值
x += y,等同于x = x + y
x -= y,等同于x = x - y
x = y,等同于x = x y
x /= y,等同于x = x / y
x %= y,等同于x = x % y
x .= y,等同于x = x . y

<?php 
$x=10; 
echo $x; // 输出10
 
$y=20; 
$y += 100;
echo $y; // 输出120
 
$z=50;
$z -= 25;
echo $z; // 输出25
 
$i=5;
$i *= 6;
echo $i; // 输出30
 
$j=10;
$j /= 5;
echo $j; // 输出2
 
$k=15;
$k %= 4;
echo $k; // 输出3
?>
$a = "Hello";
$b = $a . " world!";
echo $b; // 输出Hello world! 
 
$x="Hello";
$x .= " world!";
echo $x; // 输出Hello world!

PHP递增/递减运算符

++ x,x 加 1，然后返回 x
x ++,返回 x，然后 x 加 1
(– x),x 减 1，然后返回 x
x –,返回 x，然后 x 减 1

<?php
$x=10; 
echo ++$x; // 输出11
 
$y=10; 
echo $y++; // 输出10
 
$z=5;
echo --$z; // 输出4
 
$i=5;
echo $i--; // 输出5
?>

PHP 比较运算符

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
x > y ,如果 x 大于 y，则返回 true
x < y,如果 x 小于 y，则返回 true
x >= y,如果 x 大于或者等于 y，则返回 true
x <= y,如果 x 小于或者等于 y，则返回 true

<?php
$x=100; 
$y="100";
var_dump($x == $y); //bool(true)
var_dump($x === $y); //bool(false)
var_dump($x != $y); //bool(false) 
var_dump($x !== $y); //bool(true)
$a=50;
$b=90;
var_dump($a > $b); //bool(false) 
echo "<br>";
var_dump($a < $b); //bool(true)
?>

PHP逻辑运算符

x and y,如果 x 和 y 都为 true，则返回 true
x or y,如果 x 和 y 至少有一个为 true，则返回 true
x xor y,如果 x 和 y 有且仅有一个为 true，则返回 true
x && y,如果 x 和 y 都为 true，则返回 true
x || y,如果 x 和 y 至少有一个为 true，则返回 true
! x,如果 x 不为 true，则返回 true

<?php
$x=6; 
$y=3;
var_dump($x < 10 and $y > 1); //bool(true)
var_dump($x==6 or $y==5); //bool(true)
var_dump($x==6 xor $y==3); //bool(false)
var_dump($x < 10 && $y > 1); //bool(true)
var_dump($x==5 || $y==5); //bool(false)
var_dump(!($x==$y)); //bool(true)
?>

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

三元运算符

通过判断 $_GET 请求中含有 user 值，如果有返回 $_GET[‘user’]，否则返回 nobody

<?php
$test = '菜鸟教程';
// 普通写法
$username = isset($test) ? $test : 'nobody';
echo $username, PHP_EOL;
 
// PHP 5.3+ 版本写法
$username = $test ?: 'nobody';
echo $username, PHP_EOL;
?>

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

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

组合比较符(PHP7+)

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

运算符优先级

运算符优先级中，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 
?>

括号的使用

括号的配对来明确标明运算顺序,通常能够增加代码的可读性

<?php
// 括号优先运算
 
$a = 1;
$b = 2;
$c = 3;
$d = $a + $b * $c;
echo $d; //7
echo "\n";
$e = ($a + $b) * $c;  // 使用括号
echo $e; //9
echo "\n";
?>

PHP if…Else 语句

if 语句 - 在条件成立时执行代码
if…else 语句 - 在条件成立时执行一块代码，条件不成立时执行另一块代码
if…elseif….else 语句 - 在若干条件之一成立时执行一个代码块

PHP - if 语句

if 语句用于仅当指定条件成立时执行代码

// 如果当前时间小于 20，输出 "Have a good day!"
<?php
$t=date("H");
if ($t<"20")
{
    echo "Have a good day!";
}
?>

PHP - if…else 语句

在条件成立时执行一块代码，条件不成立时执行另一块代码

// 如果当前时间小于 20，输出 "Have a good day!"，否则输出 "Have a good night!"
<?php
$t=date("H");
if ($t<"20")
{
    echo "Have a good day!";
}
else
{
    echo "Have a good night!";
}
?>

PHP - if…elseif….else 语句

在若干条件之一成立时执行一个代码块，请使用 if….elseif…else 语句

// 如果当前时间小于 10，输出 "Have a good morning!"，如果当前时间不小于 10 且小于 20，则输出 "Have a good day!"，否则输出 "Have a good night!"
<?php
$t=date("H");
if ($t<"10")
{
    echo "Have a good morning!";
}
elseif ($t<"20")
{
    echo "Have a good day!";
}
else
{
    echo "Have a good night!";
}
?>

PHP Switch 语句

switch 语句用于根据多个不同条件执行不同动作

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

PHP 数组

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

<?php
$cars=array("Volvo","BMW","Toyota");
echo "I like " . $cars[0] . ", " . $cars[1] . " and " . $cars[2] . ".";
?>

在 PHP 中创建数组

array() 函数用于创建数组

在 PHP 中，有三种类型的数组

数值数组 - 带有数字 ID 键的数组
关联数组 - 带有指定的键的数组，每个键关联一个值
多维数组 - 包含一个或多个数组的数组

PHP 数值数组

两种创建数值数组的方法

$cars=array("Volvo","BMW","Toyota");
$cars=array();
$cars[0]="Volvo";
$cars[1]="BMW";
$cars[2]="Toyota";

count()函数

count() 函数用于返回数组的长度

<?php
$cars=array("Volvo","BMW","Toyota");
echo count($cars); // 3
?>

遍历数值数组

遍历并打印数值数组中的所有值，您可以使用 for 循环

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

PHP 关联数组

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

两种创建关联数组的方法

$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
$age['Peter']="35";
$age['Ben']="37";
$age['Joe']="43";

遍历关联数组

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

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

PHP 数组排序

数组中的元素可以按字母或数字顺序进行降序或升序排列

sort() - 对数组进行升序排列
rsort() - 对数组进行降序排列
asort() - 根据关联数组的值，对数组进行升序排列
ksort() - 根据关联数组的键，对数组进行升序排列
arsort() - 根据关联数组的值，对数组进行降序排列
krsort() - 根据关联数组的键，对数组进行降序排列

sort() - 对数组进行升序排列

$cars 数组中的元素按照字母升序排列

<?php 
$cars=array("Volvo","BMW","Toyota");  
sort($cars);  
print_r($cars); 
?>
// 输出
Array
(
    [0] => BMW
    [1] => Toyota
    [2] => Volvo
)

$numbers 数组中的元素按照数字升序排列

<?php 
$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 数组中的元素按照字母降序排列

<?php
$cars=array("Volvo","BMW","Toyota");
rsort($cars);
?>
// 输出
Array
(
    [0] => Volvo
    [1] => Toyota
    [2] => BMW
)

$numbers 数组中的元素按照数字降序排列

<?php
$numbers=array(4,6,2,22,11);
rsort($numbers);
?>
//输出
Array
(
    [0] => 22
    [1] => 11
    [2] => 6
    [3] => 4
    [4] => 2
)

asort() - 根据数组的值，对数组进行升序排列

根据数组的值，对关联数组进行升序排列

<?php
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
asort($age);
?>
//输出
Array
(
    [Peter] => 35
    [Ben] => 37
    [Joe] => 43
)

ksort() - 根据数组的键，对数组进行升序排列

根据数组的键，对关联数组进行升序排列：

<?php
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
ksort($age);
?>
//输出
Array
(
    [Ben] => 37
    [Joe] => 43
    [Peter] => 35
)

arsort() - 根据数组的值，对数组进行降序排列

根据数组的值，对关联数组进行降序排列

<?php
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
arsort($age);
?>
//输出
Array
(
    [Joe] => 43
    [Ben] => 37
    [Peter] => 35
)

krsort() - 根据数组的键，对数组进行降序排列

根据数组的键，对关联数组进行降序排列

<?php
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
krsort($age);
?>
// 输出
Array
(
    [Peter] => 35
    [Joe] => 43
    [Ben] => 37
)

PHP 超级全局变量

PHP中预定义了几个超级全局变量，这意味着它们在一个脚本的全部作用域中都可用

$GLOBALS
$_SERVER
$_REQUEST
$_POST
$_GET
$_FILES
$_ENV
$_COOKIE
$_SESSION

PHP $GLOBALS

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

// z 是一个$GLOBALS数组中的超级全局变量，该变量同样可以在函数外访问
<?php 
$x = 75; 
$y = 25;
 
function addition() 
{ 
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y']; 
}
 
addition(); 
echo $z; 
?>

PHP $_SERVER

$_SERVER 是一个包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组

<?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'];
?>
// 输出
/try/demo_source/demo_global_server.php
www.runoob.com
www.runoob.com
http://www.runoob.com/try/showphp.php?filename=demo_global_server
Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3472.3 Safari/537.36
/try/demo_source/demo_global_server.php

PHP $_REQUEST

PHP $_REQUEST 用于收集HTML表单提交的数据

//使用超级全局变量 $_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>

PHP $_POST

PHP $_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>

PHP $_GET

PHP $_GET 同样被广泛应用于收集表单数据，在HTML form标签的指定该属性：”method=”get”

// 当用户点击链接 "Test $GET", 参数 "subject" 和 "web" 将发送至"test_get.php",
// 在 "test_get.php" 文件中使用 $_GET 变量来获取这些数据
<html>
<body>
<a href="test_get.php?subject=PHP&web=runoob.com">Test $GET</a>
</body>
</html>
// "test_get.php" 文件的代码
<html>
<body>
<?php 
echo "Study " . $_GET['subject'] . " at " . $_GET['web'];
?>
</body>
</html>

PHP While 循环

相同的代码块一次又一次地重复运行。我们可以在代码中使用循环语句

while - 只要指定的条件成立，则循环执行代码块
do…while - 首先执行一次代码块，然后在指定的条件成立时重复这个循环

while 循环

while 循环将重复执行代码块，直到指定的条件不成立

// 变量 i 的值为 1 ($i=1;)
// 只要 i 小于或者等于 5，while 循环将继续运行
// 循环每运行一次，i 就会递增 1
<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

do…while 语句

do…while 语句会至少执行一次代码，然后检查条件，只要条件成立，就会重复进行循环

// 变量 i 的值为 1 ($i=1;)
// 开始 do...while 循环。循环将变量 i 的值递增 1，然后输出
// 先检查条件（i 小于或者等于 5），只要 i 小于或者等于 5，循环将继续运行
<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

PHP For 循环

for - 循环执行代码块指定的次数
foreach - 根据数组中每个元素来循环代码块

for 循环

for 循环用于您预先知道脚本需要运行的次数的情况

参数:

初始值：主要是初始化一个变量值，用于设置一个计数器（但可以是任何在循环的开始被执行一次的代码）。
条件：循环执行的限制条件。如果为 TRUE，则循环继续。如果为 FALSE，则循环结束。
增量：主要用于递增计数器（但可以是任何在循环的结束被执行的代码）

// 定义一个初始值为 i=1 的循环。只要变量 i 小于或者等于 5，循环将继续运行
// 循环每运行一次，变量 i 就会递增 1
<?php
for ($i=1; $i<=5; $i++)
{
    echo "The number is " . $i . "<br>";
}
?>
// 输出
The number is 1
The number is 2
The number is 3
The number is 4
The number is 5

foreach 循环

foreach 循环用于遍历数组

<?php
$x=array("one","two","three");
foreach ($x as $value)
{
    echo $value . "<br>";
}
?>
// 输出
one
two
three

PHP 函数

PHP 的真正威力源自于它的函数

在 PHP 中，提供了超过 1000 个内建的函数

创建 PHP 函数

函数是通过调用函数来执行的

// 一个简单的函数，在其被调用时能输出我的名称
<?php
function writeName()
{
    echo "Kai Jim Refsnes";
}
 
echo "My name is ";
writeName();
?>
// 输出
My name is Kai Jim Refsnes

PHP 函数 - 添加参数

参数就在函数名称后面有一个括号内指定

// 输出不同的名字，但姓是相同的
<?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");
?>
// 输出
My name is Kai Jim Refsnes.
My sister's name is Hege Refsnes.
My brother's name is Stale Refsnes.

函数有两个参数

<?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","?");
?>
// 输出
My name is Kai Jim Refsnes.
My sister's name is Hege Refsnes!
My brother's name is Ståle Refsnes?

PHP 函数 - 返回值

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

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

PHP 魔术常量

PHP 向它运行的任何脚本提供了大量的预定义常量

有八个魔术常量它们的值随着它们在代码中的位置改变而改变

LINE

文件中的当前行号

<?php
echo '这是第 " '  . __LINE__ . ' " 行';
?>
// 输出
这是第 “ 2 ” 行

FILE

文件的完整路径和文件名

<?php
echo '该文件位于 " '  . __FILE__ . ' " ';
?>
// 输出
该文件位于 “ E:\wamp\www\test\index.php ”

DIR

文件所在的目录,等价于 dirname(FILE)

<?php
echo '该文件位于 " '  . __DIR__ . ' " ';
?>
// 输出
该文件位于 “ E:\wamp\www\test ”

FUNCTION

函数名称

<?php
function test() {
    echo  '函数名为：' . __FUNCTION__ ;
}
test();
?>
// 输出
函数名为：test

CLASS

类的名称

<?php
class test {
    function _print() {
        echo '类名为：'  . __CLASS__ . "<br>";
        echo  '函数名为：' . __FUNCTION__ ;
    }
}
$t = new test();
$t->_print();
?>
// 输出
类名为：test
函数名为：_print

TRAIT

Trait 的名字,自 PHP 5.4.0 起，PHP 实现了代码复用的一个方法，称为 traits

Trait 名包括其被声明的作用区域（例如 Foo\Bar）

// 从基类继承的成员被插入的 SayWorld Trait 中的 MyHelloWorld 方法所覆盖
// 其行为 MyHelloWorld 类中定义的方法一致
// 优先顺序是当前类中的方法会覆盖 trait 方法，而 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();
?>
// 输出
Hello World!

METHOD

类的方法名（PHP 5.0.0 新加）。返回该方法被定义时的名字（区分大小写）

<?php
function test() {
    echo  '函数名为：' . __METHOD__ ;
}
test();
?>
// 输出
函数名为：test

NAMESPACE

当前命名空间的名称（区分大小写）

<?php
namespace MyProject;
 
echo '命名空间为："', __NAMESPACE__, '"'; // 输出 "MyProject"
?>
// 输出
命名空间为："MyProject"

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() { /* ... */  }
}
?>

将全局的非命名空间中的代码与命名空间中的代码组合在一起，只能使用大括号形式的语法

全局代码必须用一个不带名称的 namespace 语句加上大括号括起来

<?php
namespace MyProject {
const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */  }
}
namespace { // 全局代码
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>

在声明命名空间之前唯一合法的代码是用于定义源文件编码方式的 declare 语句

<?php
declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码
namespace MyProject {
const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */  }
}
namespace { // 全局代码
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>

以下代码会出现语法错误

<html>
<?php
namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 -　命名空间必须是程序脚本的第一条语句
?>

子命名空间

与目录和文件的关系很像，PHP 命名空间也允许指定层次化的命名空间的名称

// 创建了常量 MyProject\Sub\Level\CONNECT_OK，类 MyProject\Sub\Level\Connection 和函数 MyProject\Sub\Level\Connect
<?php
namespace MyProject\Sub\Level;  //声明分层次的单个命名空间
const CONNECT_OK = 1;
class Connection { /* ... */ }
function Connect() { /* ... */  }
?>

命名空间使用

PHP 命名空间中的类名可以通过三种方式引用

非限定名称，或不包含前缀的类名称

例如 $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 Foo\Bar\subnamespace; 
const FOO = 1;
function foo() {}
class foo
{
    static function staticmethod() {}
}
?>

实例二

<?php
namespace Foo\Bar;
include 'file1.php';
const FOO = 2;
function foo() {}
class foo
{
    static function staticmethod() {}
}
/* 非限定名称 */
foo(); // 解析为函数 Foo\Bar\foo
foo::staticmethod(); // 解析为类 Foo\Bar\foo ，方法为 staticmethod
echo FOO; // 解析为常量 Foo\Bar\FOO
/* 限定名称 */
subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo,
                                  // 以及类的方法 staticmethod
echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO
                                  
/* 完全限定名称 */
\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo
\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod
echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO
?>

实例三

// 注意访问任意全局类、函数或常量，都可以使用完全限定名称
// 例如 \strlen() 或 \Exception 或 \INI_ALL
// 在命名空间内部访问全局类、函数和常量
<?php
namespace Foo;
function strlen() {}
const INI_ALL = 3;
class Exception {}
$a = \strlen('hi'); // 调用全局函数strlen
$b = \INI_ALL; // 访问全局常量 INI_ALL
$c = new \Exception('error'); // 实例化全局类 Exception
?>