1.1 代码#

1
<?php
2
PHP代码;
3
?>

需要加 ;

1.2 注释#

• 单行

1
//
2

3
#

• 多行

1
/* ... */

• 文档

1
/** ... */

2.1 规则#

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

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

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

7
- 变量名不能包含空格
8

9
- 变量名是区分大小写的（$y 和 $Y 是两个不同的变量）
10

11
-----------------------------------------------------------------------------
12

13
- 没有声明变量的命令，变量在第一次赋值时被创建
14

15
- 若赋值文本值，则两边加引号
16

17
- PHP是弱类型语言，不必声明该变量的数据类型，会自动转换

2.2 作用域#

• 四种变量作用域

1
local
2

3
global
4

5
static
6

7
parameter

• 全局作用域

在所有函数外部定义的变量，拥有全局作用域。除了函数外，全局变量可以被脚本中的任何部分访问，要在一个函数中访问一个全局变量，需要使用 global 关键字

1
<?php
2
$x=5;
3
$y=10;
4

5
function myTest()
6
{
7
    global $x,$y;
8
    $y=$x+$y;
9
}
10

11
myTest();
12
echo $y; // 输出 15
13
?>

• 局部作用域

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

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

4
function myTest()
5
{
6
    $y=10; // 局部变量
7
    echo "<p>测试函数内变量:<p>";
8
    echo "变量 x 为: $x";
9
    echo "<br>";
10
    echo "变量 y 为: $y";
11
}
12

13
myTest();
14

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

• Static作用域

当一个函数完成时，它的所有变量通常都会被删除，若要指定某个局部变量不被删除，可使用 static 关键字

1
<?php
2
function test() {
3
    static $a = 0;
4
    $a++;
5
    echo "当前值：" . $a . "<br>";
6
}
7

8
test();
9
test();
10
test();
11
?>

• 参数作用域

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

2.3 超级全局变量#

PHP中预定义了几个超级全局变量（superglobals） ，这意味着它们在一个脚本的全部作用域中都可用，且不需提取说明

1
- $GLOBALS
2

3
- $_SERVER
4

5
- $_REQUEST
6

7
- $_POST
8

9
- $_GET
10

11
- $_FILES
12

13
- $_ENV
14

15
- $_COOKIE
16

17
- $_SESSION

1
<?php
2
$x = 75;
3
$y = 25;
4

5
function addition()
6
{
7
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y'];
8
}
9

10
addition();
11
echo $z;
12
?>

3.1 echo#

echo 或 echo()

3.2 print#

print 或 print()

3.3 区别#

• echo 可以输出一个或多个字符串
• print 只允许输出一个字符串，返回值总为 1
• echo 输出的速度比 print 快， echo 没有返回值，print有返回值1

print_r&vat_dump#

1
**3.print_r**
2

3
打印关于变量的易于理解的信息,如果给出的是 string、integer 或 float，将打印变量值本身。如果给出的是 array，将会按照一定格式显示键和元素。object 与数组类似。 记住，print_r() 将把数组的指针移到最后边。使用 reset() 可让指针回到开始处。
4

5
**4.var_dump**
6

7
此函数显示关于一个或多个表达式的结构信息，包括表达式的类型与值。数组将递归展开值，通过缩进显示其结构。
8

9
**5.var_dump 和 print_r 的区别**
10

11
var_dump 返回表达式的类型与值而 print_r 仅返回结果，相比调试代码使用 var_dump 更便于阅读。

5.1 数据类型#

1
String（字符串）
2

3
Integer（整型）
4

5
Float（浮点型）
6

7
Boolean（布尔型）
8

9
Array（数组）
10

11
Object（对象）
12

13
NULL（空值）
14

15
Resource（资源类型）

1
<?php
2
$x = "Hello world!";
3
echo $x;
4
echo "<br>";
5
$x = 'Hello world!';
6
echo $x;
7
?>

1
- 整数必须至少有一个数字 (0-9)
2
- 整数不能包含逗号或空格
3
- 整数是没有小数点的
4
- 整数可以是正数或负数
5
- 整型可以用三种格式来指定：十进制， 十六进制（ 以 0x 为前缀）或八进制（前缀为 0）

1
<?php
2
$cars=array("Volvo","BMW","Toyota");
3
var_dump($cars);
4
?>

1
<?php
2
class Car
3
{
4
  var $color;
5
  function __construct($color="green") {
6
    $this->color = $color;
7
  }
8
  function what_color() {
9
    return $this->color;
10
  }
11
}
12
?>

1
get_resource_type(resource $handle): string

5.2 类型比较#

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

6.1 特性#

• 不变性: 常量一旦定义，其值不能改变。
• 全局作用域: 常量在定义后，可以在整个脚本的任何地方使用，无需使用 global 关键字。
• 数据类型: 常量的值可以是标量数据类型（如布尔值、整数、浮点数、字符串）或数组（PHP 7 及以上版本）。
• 区分大小写: 常量名称默认是区分大小写的。如果需要定义大小写不敏感的常量，可以在 define() 函数的第三个参数设置为 true。
• 常量是一个简单值的标识符，该值在脚本中不能改变
• 一个常量由英文字母、下划线、和数字组成，但数字不能作为首字母出现。 (常量名不需要加 $ 修饰符)

6.2 设置常量#

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

1
# 区分大小写
2
<?php
3
// 区分大小写的常量名
4
define("GREETING", "欢迎访问 Runoob.com");
5
echo GREETING;    // 输出 "欢迎访问 Runoob.com"
6
echo '<br>';
7
echo greeting;   // 输出 "greeting"，但是有警告信息，表示该常量未定义
8
?>
9

10
# 不区分大小写
11
<?php
12
// 不区分大小写的常量名
13
define("GREETING", "欢迎访问 Runoob.com", true);
14
echo greeting;  // 输出 "欢迎访问 Runoob.com"
15
?>

1
const CONSTANT_NAME = "value";

1
const SITE_URL = "https://www.runoob.com";
2
echo SITE_URL; // 输出 "https://www.runoob.com"

6.3 预定义常量#

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

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

6.4 常量数组#

在 PHP 7 及以上版本中，常量也可以是数组。

7.1 字符串变量#

前面5.1.1中有讲解

7.2 并置运算符#

并置运算符  .  用于把两个字符串值连接起来

1
<?php
2
$txt1="Hello world!";
3
$txt2="What a nice day!";
4
echo $txt1 . " " . $txt2;
5
?>

输出：Hello world! What a nice day!

7.3 strlen() 函数#

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

1
<?php
2
echo strlen("Hello world!");
3
?>

7.4 strpos() 函数#

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

1
<?php
2
echo strpos("Hello world!","world");
3
?>

输出：6 //字符串中第一个字符的位置是 0，而不是 1

8.1 算数运算符#

8.2 赋值运算符#

8.3 递增/递减运算符#

8.4 比较运算符#

8.5 逻辑运算符#

8.6 数组运算符#

8.7 三元运算符#

1
(expr1) ? (expr2) : (expr3)

对 expr1 求值为 TRUE 时的值为 expr2，在 expr1 求值为 FALSE 时的值为 expr3。

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

1
<?php
2
// 普通写法
3
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';
4
echo $username, PHP_EOL;
5

6
// PHP 5.3+ 版本写法
7
$username = $_GET['user'] ?: 'nobody';
8
echo $username, PHP_EOL;
9
?>

8.8 组合比较符#

PHP7+

1
$c = $a <=> $b;

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

优先级#

数组运算符 > 递增 / 递减运算符 > 算术运算符 > 比较运算符 > 组合比较符 > 逻辑运算符 > 三元运算符 > 赋值运算符

9.1 If…Else#

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

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

1
if (条件) {
2
    条件成立时执行的代码;
3
} else {
4
    条件不成立时执行的代码;
5
}

1
if (条件) {
2
    if 条件成立时执行的代码;
3
} elseif (条件) {
4
    elseif 条件成立时执行的代码;
5
} else {
6
    条件不成立时执行的代码;
7
}

9.2 switch语句#

1
<?php
2
switch (expression) {
3
    case value1:
4
        // 代码块1
5
        break;
6
    case value2:
7
        // 代码块2
8
        break;
9
    // 更多的 case 语句
10
    default:
11
        // 如果没有匹配的值
12
}
13
?>

• expression 是要被比较的表达式。
• case value: 是可能的值，如果 expression 的值等于某个 case 的值，就执行相应的代码块。
• break; 用于终止 switch 语句，防止继续执行下一个 case。
• default: 是可选的，用于指定当没有匹配的 case 时执行的代码块。 工作原理：首先对一个简单的表达式 n（通常是变量）进行一次计算。将表达式的值与结构中每个 case 的值进行比较。如果存在匹配，则执行与 case 关联的代码。代码执行后，使用 break 来阻止代码跳入下一个 case 中继续执行。default 语句用于不存在匹配（即没有 case 为真）时执行。

10.1 创建#

1
array();

10.2 类型#

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

1
$cars=array("Volvo","BMW","Toyota");

1
$cars[0]="Volvo";
2
$cars[1]="BMW";
3
$cars[2]="Toyota";

1
<?php
2
$cars=array("Volvo","BMW","Toyota");
3
$arrlength=count($cars);
4

5
for($x=0;$x<$arrlength;$x++)
6
{
7
    echo $cars[$x];
8
    echo "<br>";
9
}
10
?>

1
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
2

3
or:
4

5
$age['Peter']="35";
6
$age['Ben']="37";
7
$age['Joe']="43";

1
<?php
2
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
3

4
foreach($age as $x=>$x_value)
5
{
6
    echo "Key=" . $x . ", Value=" . $x_value;
7
    echo "<br>";
8
}
9
?>

1
array (
2
    array (elements...),
3
    array (elements...),
4
    ...
5
)

1
array (
2
    array (
3
        array (elements...),
4
        array (elements...),
5
        ...
6
    ),
7
    array (
8
        array (elements...),
9
        array (elements...),
10
        ...
11
    ),
12
    ...
13
)

10.3 排序#

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

11.1 while循环#

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

1
while (条件)
2
{
3
    要执行的代码;
4
}

11.2 do…while语句#

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

1
do
2
{
3
    要执行的代码;
4
}
5
while (条件);

11.3 for循环#

for 循环需要预先知道脚本需要运行的次数

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

• 初始值：主要是初始化一个变量值，用于设置一个计数器（但可以是任何在循环的开始被执行一次的代码）
• 条件：循环执行的限制条件。如果为 TRUE，则循环继续。如果为 FALSE，则循环结束
• 增量：主要用于递增计数器（但可以是任何在循环的结束被执行的代码） 注释：上面的初始值和增量参数可为空，或者有多个表达式（用逗号分隔）

11.4 foreach循环#

foreach 循环用于遍历数组

1
foreach ($array as $value)
2
{
3
    要执行代码;
4
}

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

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

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

12.1 Array函数#

12.2 创建#

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

1
<?php
2
function functionName()
3
{
4
    // 要执行的代码
5
}
6
?>

• 函数的名称应该提示出它的功能
• 函数名称以字母或下划线开头（不能以数字开头）

12.3 添加参数#

为了给函数添加更多的功能，我们可以添加参数，参数类似变量。 参数就在函数名称后面的一个括号内指定。

1
//下面的实例将输出不同的名字，但姓是相同的
2
<?php
3
function writeName($fname)
4
{
5
    echo $fname . " Refsnes.<br>";
6
}
7

8
echo "My name is ";
9
writeName("Kai Jim");
10
echo "My sister's name is ";
11
writeName("Hege");
12
echo "My brother's name is ";
13
writeName("Stale");
14
?>

输出

1
My name is Kai Jim Refsnes.
2
My sister's name is Hege Refsnes.
3
My brother's name is Stale Refsnes.

12.4 返回值#

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

1
<?php
2
function add($x,$y)
3
{
4
    $total=$x+$y;
5
    return $total;
6
}
7

8
echo "1 + 16 = " . add(1,16);
9
?>

输出：1 + 16 = 17

12.5 变量函数#

变量函数是指在 PHP 中，将一个变量作为函数名来调用的函数

__LINE__#

文件中的当前行号

1
<?php
2
echo '这是第 " '  . __LINE__ . ' " 行';
3
?>

输出：这是第 “ 2 ” 行

__FILE__#

文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名。 自 PHP 4.0.2 起，FILE 总是包含一个绝对路径（如果是符号连接，则是解析后的绝对路径），而在此之前的版本有时会包含一个相对路径

1
<?php
2
echo '该文件位于 " '  . __FILE__ . ' " ';
3
?>

输出：该文件位于 “ E:\wamp\www\test\index.php ”

__DIR__#

文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。 它等价于 dirname(FILE)。除非是根目录，否则目录中名不包括末尾的斜杠。（PHP 5.3.0中新增）

1
<?php
2
echo '该文件位于 " '  . __DIR__ . ' " ';
3
?>

输出：该文件位于 “ E:\wamp\www\test ”

__FUNCTION__#

函数名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该函数被定义时的名字（区分大小写）。在 PHP 4 中该值总是小写字母的。

1
<?php
2
function test() {
3
    echo  '函数名为：' . __FUNCTION__ ;
4
}
5
test();
6
?>

输出：函数名为：test

__CLASS__#

类的名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该类被定义时的名字（区分大小写）。 在 PHP 4 中该值总是小写字母的。类名包括其被声明的作用区域（例如 Foo\Bar）。注意自 PHP 5.4 起 CLASS 对 trait 也起作用。当用在 trait 方法中时，CLASS 是调用 trait 方法的类的名字。

1
<?php
2
class test {
3
    function _print() {
4
        echo '类名为：'  . __CLASS__ . "<br>";
5
        echo  '函数名为：' . __FUNCTION__ ;
6
    }
7
}
8
$t = new test();
9
$t->_print();
10
?>

输出：

1
类名为：test
2
函数名为：_print

__TRAIT__#

Trait 的名字（PHP 5.4.0 新加）。自 PHP 5.4.0 起，PHP 实现了代码复用的一个方法，称为 traits。 Trait 名包括其被声明的作用区域（例如 Foo\Bar）。 从基类继承的成员被插入的 SayWorld Trait 中的 MyHelloWorld 方法所覆盖。其行为 MyHelloWorld 类中定义的方法一致。优先顺序是当前类中的方法会覆盖 trait 方法，而 trait 方法又覆盖了基类中的方法。

1
<?php
2
class Base {
3
    public function sayHello() {
4
        echo 'Hello ';
5
    }
6
}
7

8
trait SayWorld {
9
    public function sayHello() {
10
        parent::sayHello();
11
        echo 'World!';
12
    }
13
}
14

15
class MyHelloWorld extends Base {
16
    use SayWorld;
17
}
18

19
$o = new MyHelloWorld();
20
$o->sayHello();
21
?>

输出：Hello World!

__METHOD__#

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

1
<?php
2
function test() {
3
    echo  '函数名为：' . __METHOD__ ;
4
}
5
test();
6
?>

输出：函数名为：test

14.1 对象三特征#

• 对象的行为：对象可以执行的操作，比如：开灯，关灯就是行为。
• 对象的形态：对对象不同的行为是如何响应的，比如：颜色，尺寸，外型。
• 对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。

14.2 面向对象编程三编程#

• 封装（Encapsulation）：指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装。

• 继承（Inheritance）：指可以创建一个新的类，该类继承了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。

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

14.3 面向对象内容#

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

• 对象 − 是类的实例。

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

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

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

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

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

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

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

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

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

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

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

14.4 PHP类定义class var#

1
<?php
2
class phpClass {
3
  var $var1;
4
  var $var2 = "constant string";
5

6
  function myfunc ($arg1, $arg2) {
7
     [..]
8
  }
9
  [..]
10
}
11
?>

• 类使用 class 关键字后加上类名定义。

• 类名后的一对大括号({})内可以定义变量和方法。

• 类的变量使用 var 来声明, 变量也可以初始化值。

• 函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。

14.5 PHP创建对象new#

1
$runoob = new Site;
2
$taobao = new Site;
3
$google = new Site;

14.6 PHP构造函数#

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

1
PHP 5 允许开发者在一个类中定义一个方法作为构造函数，语法格式如下：
2

3
void __construct ([ mixed $args [, $... ]] )
4

5
在上面的例子中我们就可以通过构造方法来初始化 $url 和 $title 变量：
6

7
function __construct( $par1, $par2 ) {
8
   $this->url = $par1;
9
   $this->title = $par2;
10
}

14.7 析构函数#

析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。 PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言，其语法格式如下：

1
void __destruct ( void )

14.8 继承#

PHP 使用关键字 extends 来继承一个类，PHP 不支持多继承，格式如下：

1
class Child extends Parent {
2
   // 代码部分
3
}

子类继承父类的属性和方法，也就是说子类拥有父类所有的东西，包括 public(公有)、protected(保护)和private(私有)的。但是父类私有的属性和方法不能让子类直接调用，并不是说没有继承过来，而是继承过来了，但是要调用父类的私有属性和方法的话还是需要通过父类的 public、protected 方法调用

14.9 方法重写#

如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。 实例中重写了 getUrl 与 getTitle 方法：

1
function getUrl() {
2
   echo $this->url . PHP_EOL;
3
   return $this->url;
4
}
5

6
function getTitle(){
7
   echo $this->title . PHP_EOL;
8
   return $this->title;
9
}

14.10 接口#

使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。

接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。

接口中定义的所有方法都必须是公有，这是接口的特性。

要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。

1
<?php
2

3
// 声明一个'iTemplate'接口
4
interface iTemplate
5
{
6
    public function setVariable($name, $var);
7
    public function getHtml($template);
8
}
9

10

11
// 实现接口
12
class Template implements iTemplate
13
{
14
    private $vars = array();
15

16
    public function setVariable($name, $var)
17
    {
18
        $this->vars[$name] = $var;
19
    }
20

21
    public function getHtml($template)
22
    {
23
        foreach($this->vars as $name => $value) {
24
            $template = str_replace('{' . $name . '}', $value, $template);
25
        }
26

27
        return $template;
28
    }
29
}

14.11 抽象类#

任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。

定义为抽象的类不能被实例化。

被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。

继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。

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

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

14
class ConcreteClass1 extends AbstractClass
15
{
16
    protected function getValue() {
17
        return "ConcreteClass1";
18
    }
19

20
    public function prefixValue($prefix) {
21
        return "{$prefix}ConcreteClass1";
22
    }
23
}
24

25
class ConcreteClass2 extends AbstractClass
26
{
27
    public function getValue() {
28
        return "ConcreteClass2";
29
    }
30

31
    public function prefixValue($prefix) {
32
        return "{$prefix}ConcreteClass2";
33
    }
34
}
35

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

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

14.12 static关键字#

声明类属性或方法为 static(静态)，就可以不实例化类而直接访问。

静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。

由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。

静态属性不可以由对象通过 -> 操作符来访问。

自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字 self，parent 或 static。

1
<?php
2
class Foo {
3
  public static $my_static = 'foo';
4

5
  public function staticValue() {
6
     return self::$my_static;
7
  }
8
}
9

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

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

执行以上程序，输出结果为：

1
foo
2
foo

14.13 Final 关键字#

PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

14.14 调用父类构造方法#

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

3.1 打开文件fopen()#

fopen() 函数用于在 PHP 中打开文件。 此函数的第一个参数含有要打开的文件的名称，第二个参数规定了使用哪种模式来打开文件：

1
<html>
2
<body>
3

4
<?php
5
$file=fopen("welcome.txt","r");
6
?>
7

8
</body>
9
</html>

文件可能通过下列模式来打开：

3.2 关闭文件fclose()#

fclose() 函数用于关闭打开的文件：

1
<?php
2
$file = fopen("test.txt","r");
3

4
//执行一些代码
5

6
fclose($file);
7
?>

3.3 检测文件末尾(EOF)#

feof() 函数检测是否已到达文件末尾（EOF）。 在循环遍历未知长度的数据时，feof() 函数很有用。 注释：在 w 、a 和 x 模式下，您无法读取打开的文件！

1
if (feof($file)) echo "文件结尾";

3.4 逐行读取文件fgets()#

fgets() 函数用于从文件中逐行读取文件。 注释：在调用该函数之后，文件指针会移动到下一行。

3.5 逐字符读取文件fgetc()#

fgetc() 函数用于从文件中逐字符地读取文件。 注释：在调用该函数之后，文件指针会移动到下一个字符。

4.1 创建setcookie()#

setcookie() 函数用于设置 cookie。

注释：setcookie() 函数必须位于<html>标签之前。

1
setcookie(name, value, expire, path, domain);

4.2 取回Cookie值#

PHP 的$_COOKIE变量用于取回 cookie 的值。

4.3 删除 Cookie#

当删除 cookie 时，您应当使过期日期变更为过去的时间点。 删除的实例：

1
<?php
2
// 设置 cookie 过期时间为过去 1 小时
3
setcookie("user", "", time()-3600);
4
?>

5.1 开始 PHP Session#

在把用户信息存储到 PHP session 中之前，首先必须启动会话。 注释：session_start() 函数必须位于<html>标签之前：

1
<?php session_start(); ?>
2
<html>
3
<body>
4

5
</body>
6
</html>

上面的代码会向服务器注册用户的会话，以便您可以开始保存用户信息，同时会为用户会话分配一个 UID

5.2 存储 Session 变量#

存储和取回 session 变量的正确方法是使用 PHP $_SESSION 变量：

1
<?php
2
session_start();
3
// 存储 session 数据
4
$_SESSION['views']=1;
5
?>
6

7
<html>
8
<head>
9
<meta charset="utf-8">
10
<title>菜鸟教程(runoob.com)</title>
11
</head>
12
<body>
13

14
<?php
15
// 检索 session 数据
16
echo "浏览量：". $_SESSION['views'];
17
?>
18

19
</body>
20
</html>

输出：

1
浏览量：1

在下面的实例中，我们创建了一个简单的 page-view 计数器。isset() 函数检测是否已设置 “views” 变量。如果已设置 “views” 变量，我们累加计数器。如果 “views” 不存在，则创建 “views” 变量，并把它设置为 1：

1
<?php
2
session_start();
3

4
if(isset($_SESSION['views']))
5
{
6
    $_SESSION['views']=$_SESSION['views']+1;
7
}
8
else
9
{
10
    $_SESSION['views']=1;
11
}
12
echo "浏览量：". $_SESSION['views'];
13
?>

5.3 销毁 Session#

如果希望删除某些 session 数据，可以使用 unset() 或 session_destroy() 函数。

• unset() 函数用于释放指定的 session 变量

1
<?php
2
session_start();
3
if(isset($_SESSION['views']))
4
{
5
    unset($_SESSION['views']);
6
}
7
?>

您也可以通过调用 session_destroy() 函数彻底销毁 session：

1
<?php
2
session_destroy();
3
?>

注释：session_destroy() 将重置 session，您将失去所有已存储的 session 数据。

6.1 mail函数#

用于从脚本中发送电子邮件

1
mail(to,subject,message,headers,parameters)

6.2 ez_mail#

1
<?php
2
$to = "someone@example.com";         // 邮件接收者
3
$subject = "参数邮件";                // 邮件标题
4
$message = "Hello! 这是邮件的内容。";  // 邮件正文
5
$from = "someonelse@example.com";   // 邮件发送者
6
$headers = "From:" . $from;         // 头部信息设置
7
mail($to,$subject,$message,$headers);
8
echo "邮件已发送";
9
?>

6.3 E-mail注入#

1
<html>
2
<head>
3
<meta charset="utf-8">
4
<title>菜鸟教程(runoob.com)</title>
5
</head>
6
<body>
7

8
<?php
9
if (isset($_REQUEST['email'])) { // 如果接收到邮箱参数则发送邮件
10
    // 发送邮件
11
    $email = $_REQUEST['email'] ;
12
    $subject = $_REQUEST['subject'] ;
13
    $message = $_REQUEST['message'] ;
14
    mail("someone@example.com", $subject,
15
    $message, "From:" . $email);
16
    echo "邮件发送成功";
17
} else { // 如果没有邮箱参数则显示表单
18
    echo "<form method='post' action='mailform.php'>
19
    Email: <input name='email' type='text'><br>
20
    Subject: <input name='subject' type='text'><br>
21
    Message:<br>
22
    <textarea name='message' rows='15' cols='40'>
23
    </textarea><br>
24
    <input type='submit'>
25
    </form>";
26
}
27
?>
28

29
</body>
30
</html>

以上代码存在的问题是，未经授权的用户可通过输入表单在邮件头部插入数据。

假如用户在表单中的输入框内加入如下文本到电子邮件中，会出现什么情况呢？

1
someone@example.com%0ACc:person2@example.com
2
%0ABcc:person3@example.com,person3@example.com,
3
anotherperson4@example.com,person5@example.com
4
%0ABTo:person6@example.com

与往常一样，mail() 函数把上面的文本放入邮件头部，那么现在头部有了额外的 Cc:、Bcc: 和 To: 字段。当用户点击提交按钮时，这封 e-mail 会被发送到上面所有的地址！

防御 最好方法是对输入进行验证

7.1 die()#

1
<?php
2
$file=fopen("welcome.txt","r");
3
?>

如果文件不存在，会得到类似这样的错误

1
Warning: fopen(welcome.txt) [function.fopen]: failed to open stream:
2
No such file or directory in /www/runoob/test/test.php on line 2

为了避免用户得到类似上面的错误消息，我们在访问文件之前检测该文件是否存在：

1
<?php
2
if(!file_exists("welcome.txt"))
3
{
4
    die("文件不存在");
5
}
6
else
7
{
8
    $file=fopen("welcome.txt","r");
9
}
10
?>

现在，如果文件不存在，您会得到类似这样的错误消息：

1
文件不存在

7.2 自定义错误和错误触发器#

• 创建自定义错误处理器

1
error_function(error_level,error_message,
2
error_file,error_line,error_context)

• 错误报告级别

• 触发错误 在脚本中用户输入数据的位置，当用户的输入无效时触发错误是很有用的。在 PHP 中，这个任务由 trigger_error() 函数完成。

1
//在本例中，如果 "test" 变量大于 "1"，就会发生错误：
2
<?php
3
$test=2;
4
if ($test>1)
5
{
6
    trigger_error("变量值必须小于等于 1");
7
}
8
?>

以上代码的输出如下所示：

1
Notice: 变量值必须小于等于 1
2
in /www/test/runoob.php on line 5

可以在脚本中任何位置触发错误，通过添加的第二个参数，能够规定所触发的错误类型。 可能的错误类型：

• E_USER_ERROR - 致命的用户生成的 run-time 错误。错误无法恢复。脚本执行被中断。

• E_USER_WARNING - 非致命的用户生成的 run-time 警告。脚本执行不被中断。

• E_USER_NOTICE - 默认。用户生成的 run-time 通知。在脚本发现可能有错误时发生，但也可能在脚本正常运行时发生。

• 错误记录 在默认的情况下，根据在 php.ini 中的 error_log 配置，PHP 向服务器的记录系统或文件发送错误记录。通过使用 error_log() 函数，您可以向指定的文件或远程目的地发送错误记录。 通过电子邮件向您自己发送错误消息，是一种获得指定错误的通知的好办法。

8.1 外部数据#

• 来自表单的输入数据
• Cookies
• Web services data
• 服务器变量
• 数据库查询结果

8.2 函数和过滤器#

• filter_var() - 通过一个指定的过滤器来过滤单一的变量
• filter_var_array() - 通过相同的或不同的过滤器来过滤多个变量
• filter_input - 获取一个输入变量，并对它进行过滤
• filter_input_array - 获取多个输入变量，并通过相同的或不同的过滤器对它们进行过滤

8.3 Validating 和 Sanitizing#

Validating 过滤器：

• 用于验证用户输入
• 严格的格式规则（比如 URL 或 E-Mail 验证）
• 如果成功则返回预期的类型，如果失败则返回 FALSE

Sanitizing 过滤器：

• 用于允许或禁止字符串中指定的字符
• 无数据格式规则
• 始终返回字符串