基本语法
# 基本语法
# PHP标记分离
<?php $expression = true; if ($expression == true): ?>
第一部分
<?php else: ?>
第二部分
<?php endif; ?>
2
3
4
5
这里会显示第一部分
在一个 PHP 代码段中的最后一行可以不用分号结束。如果后面还有新行，则代码段的结束标记包含了行结束。
<?php echo "Some text"; ?>
No newline
<?= "But newline now" ?>
2
3
# 注释
注释支持单行和多行注释
<?php
echo 'This is a test'; // This is a one-line c++ style comment
/* This is a multi line comment
yet another line of comment */
echo 'This is yet another test';
echo 'One Final Test'; # This is a one-line shell-style comment
?>
2
3
4
5
6
7
# 类型
PHP支持10种原始数据类型
四种标量类型：
- bool（布尔型）
- int（整型）
- float（浮点型，也称作 double)
- string（字符串）
四种复合类型：
- array（数组）
- object（对象）
- callable (opens new window)（可调用）
- iterable (opens new window)（可迭代）
最后是两种特殊类型：
- resource（资源）
- NULL（无类型）
<?php
$a_bool = TRUE; // 布尔值 boolean
$a_str = "foo"; // 字符串 string
$a_str2 = 'foo'; // 字符串 string
$an_int = 12; // 整型 integer
echo gettype($a_bool); // 输出: boolean
echo gettype($a_str); // 输出: string
// 如果是整型，就加上 4
if (is_int($an_int)) {
$an_int += 4;
}
// 如果 $bool 是字符串，就打印出来
// (啥也没打印出来)
if (is_string($a_bool)) {
echo "String: $a_bool";
}
// 输出booleanstring
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# bool类型
我们可以进行强制类型转换
<?php
var_dump((bool) ""); // bool(false)
var_dump((bool) 1); // bool(true)
var_dump((bool) -2); // bool(true)
var_dump((bool) "foo"); // bool(true)
var_dump((bool) 2.3e5); // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array()); // bool(false)
var_dump((bool) "false"); // bool(true)
2
3
4
5
6
7
8
9
# 整数类型
<?php
$a = 1234; // 十进制数
$a = 0123; // 八进制数 (等于十进制 83)
$a = 0x1A; // 十六进制数 (等于十进制 26)
$a = 0b11111111; // 二进制数字 (等于十进制 255)
$a = 1_234_567; // 整型数值 (PHP 7.4.0 以后)
2
3
4
5
6
# 浮点型
<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
$d = 1_234.567; // 从 PHP 7.4.0 开始支持
2
3
4
5
# 字符串类型
单引号输出的内容需要进行转义，且不会输出变量
<?php
echo 'this is a simple string';
// 可以录入多行
echo 'You can also have embedded newlines in
strings this way as it is
okay to do';
// 输出： Arnold once said: "I'll be back"
echo 'Arnold once said: "I\'ll be back"';
// 输出： You deleted C:\*.*?
echo 'You deleted C:\\*.*?';
// 输出： You deleted C:\*.*?
echo 'You deleted C:\*.*?';
// 输出： This will not expand: \n a newline
echo 'This will not expand: \n a newline';
// 输出： Variables do not $expand $either
echo 'Variables do not $expand $either';
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
双引号可以输出变量
<?php
$a = 666;
// 输出测试666
echo "测试$a";
2
3
4
双引号会对下面的特殊符号进行转义
| 序列 | 含义 |
|---|---|
\n | 换行（ASCII 字符集中的 LF 或 0x0A (10)） |
\r | 回车（ASCII 字符集中的 CR 或 0x0D (13)） |
\t | 水平制表符（ASCII 字符集中的 HT 或 0x09 (9)） |
\v | 垂直制表符（ASCII 字符集中的 VT 或 0x0B (11)）（自 PHP 5.2.5 起） |
\e | Escape（ASCII 字符集中的 ESC 或 0x1B (27)）（自 PHP 5.4.0 起） |
\f | 换页（ASCII 字符集中的 FF 或 0x0C (12)）（自 PHP 5.2.5 起） |
\\ | 反斜线 |
\$ | 美元标记 |
\" | 双引号 |
\[0-7]{1,3} | 符合该正则表达式序列的是一个以八进制方式来表达的字符 |
\x[0-9A-Fa-f]{1,2} | 符合该正则表达式序列的是一个以十六进制方式来表达的字符 |
一些复杂的语法
使用 {} 来存放表达式
<?php
$great = 'fantastic';
// 无效，输出: This is { fantastic}
echo "This is { $great}"."<br>";
// 有效，输出： This is fantastic
echo "This is {$great}"."<br>";
echo "This is ${great}"."<br>";
2
3
4
5
6
7
8
9
输出
This is { fantastic} This is fantastic This is fantastic
还可以使用变量来访问对象
<?php
class foo {
var $bar = 'I am bar.';
}
$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo "{$foo->$bar}\n";
echo "{$foo->{$baz[1]}}\n";
2
3
4
5
6
7
8
9
10
输出
I am bar. I am bar.
可以获取类中的静态变量
<?php
// 显示所有错误
error_reporting(E_ALL);
class beers {
const softdrink = 'rootbeer';
public static $ale = 'ipa';
}
$rootbeer = 'A & W';
$ipa = 'Alexander Keith\'s';
// 有效，输出： I'd like an A & W
echo "I'd like an {${beers::softdrink}}\n";
// 也有效，输出： I'd like an Alexander Keith's
echo "I'd like an {${beers::$ale}}\n";
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
当然我们也可以像操作数组一样对字符串进行修改
<?php
// 取得字符串的第一个字符
$str = 'This is a test.';
$first = $str[0];
// 取得字符串的第三个字符
$third = $str[2];
// 取得字符串的最后一个字符
$str = 'This is still a test.';
$last = $str[strlen($str)-1];
// 修改字符串的最后一个字符
$str = 'Look at the sea';
$str[strlen($str)-1] = 'e';
2
3
4
5
6
7
8
9
10
11
12
13
14
15
字符串可以直接转换为字符
<?php
$foo = 1 + "10.5"; // $foo is float (11.5)
$foo = 1 + "-1.3e3"; // $foo is float (-1299)
$foo = 1 + "bob-1.3e3"; // $foo is integer (1)
$foo = 1 + "bob3"; // $foo is integer (1)
$foo = 1 + "10 Small Pigs"; // $foo is integer (11)
$foo = 4 + "10.2 Little Piggies"; // $foo is float (14.2)
$foo = "10.0 pigs " + 1; // $foo is float (11)
$foo = "10.0 pigs " + 1.0; // $foo is float (11)
2
3
4
5
6
7
8
9
# Array数组
PHP 中的数组实际上是一个有序映射。映射是一种把 values 关联到 keys 的类型。此类型在很多方面做了优化，因此可以把它当成真正的数组，或列表（向量），散列表（是映射的一种实现），字典，集合，栈，队列以及更多可能性。由于数组元素的值也可以是另一个数组，树形结构和多维数组也是允许的。
可以当成map使用
<?php
$array = [
"foo" => "bar",
"bar" => "foo",
];
echo $array["foo"].$array["bar"];
2
3
4
5
6
7
输出 barfool
也可以当成数组
<?php
$array = ["666",45];
echo $array[0]."|".$array[1];
2
3
4
输出 666|45
打印数组，我们可以使用var_dump函数
<?php
$array = ["666",45];
var_dump($array);
2
3
4
输出：
array(2) { [0]=> string(3) "666" [1]=> int(45) }
遍历数组
<?php
$colors = array('red', 'blue', 'green', 'yellow');
foreach ($colors as $color) {
echo "Do you like $color?\n";
}
2
3
4
5
6
Do you like red?
Do you like blue?
Do you like green?
Do you like yellow?
2
3
4
删除数组中某一个元素
<?php
$array = ["666",45];
var_dump($array);
unset($array[0]);
var_dump($array);
2
3
4
5
更多参考
PHP: Array 数组 - Manual (opens new window)
# Iterable 可迭代对象
Iterable (opens new window)是 PHP 7.1 中引入的一个伪类型。它接受任何 array 或实现了 Traversable 接口的对象。这些类型都能用 foreach (opens new window) 迭代， 也可以和 生成器 (opens new window) 里的 yield from 一起使用。
这个东西可以作为参数
<?php
function foo(iterable $iterable) {
foreach ($iterable as $value) {
// ...
}
}
2
3
4
5
6
也可以作为返回类型
<?php
function bar(): iterable {
return [1, 2, 3];
}
2
3
4
# object对象
我们可以使用new来进行object对象初始化
<?php
class foo
{
function do_foo()
{
echo "Doing foo.";
}
}
$bar = new foo;
$bar->do_foo();
2
3
4
5
6
7
8
9
10
也可以转换为对象
如果将一个对象转换成对象，它将不会有任何变化。如果其它任何类型的值被转换成对象，将会创建一个内置类 stdClass 的实例。如果该值为 null，则新的实例为空。 array 转换成 object 将使键名成为属性名并具有相对应的值。注意：在这个例子里， 使用 PHP 7.2.0 之前的版本，数字键只能通过迭代访问。
<?php
$obj = (object) array('1' => 'foo');
var_dump(isset($obj->{'1'})); // PHP 7.2.0 后输出 'bool(true)'，之前版本会输出 'bool(false)'
var_dump(key($obj)); // PHP 7.2.0 后输出 'string(1) "1"'，之前版本输出 'int(1)'
2
3
4
# NULL
特殊的 null 值表示一个变量没有值。NULL 类型唯一可能的值就是 null。
在下列情况下一个变量被认为是 null：
- 被赋值为
null。 - 尚未被赋值。
- 被 unset() (opens new window)。
# Callback和callable类型
<?php
// 自己定义的函数
function my_callback_function() {
echo 'hello world!';
}
// 我们可以直接调用函数
call_user_func('my_callback_function');
// 这里我们创建一个对象
class MyClass {
static function myCallbackMethod() {
echo 'Hello World!';
}
}
// 我们调用对象里的方法
call_user_func(array('MyClass', 'myCallbackMethod'));
// 当然我们可以也可以初始化对象然后调用
$obj = new MyClass();
call_user_func(array($obj, 'myCallbackMethod'));
// 也可以这样用
call_user_func('MyClass::myCallbackMethod');
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 变量
变量名与 PHP 中其它的标签一样遵循相同的规则。一个有效的变量名由字母或者下划线开头，后面跟上任意数量的字母，数字，或者下划线。
# 预定义变量
PHP 提供了大量的预定义变量。由于许多变量依赖于运行的服务器的版本和设置，及其它因素，所以并没有详细的说明文档。一些预定义变量在 PHP 以命令行 (opens new window)形式运行时并不生效。 详细参阅预定义变量 (opens new window)一章。
# 变量的范围
默认情况下范围会有一个单独的范围，这里包括了include和require引入的文件
<?php
$a = 1;
include 'b.inc';
2
3
但是下面这种情况就会报错，因为函数里面的$a并没有赋值
<?php
$a = 1; /* global scope */
function Test()
{
echo $a; /* reference to local scope variable */
}
Test();
2
3
4
5
6
7
所以我们需要使用global关键词来使用变量
<?php
$a = 1;
$b = 2;
function Sum()
{
global $a, $b;
$b = $a + $b;
}
Sum();
echo $b;
// 输出3
2
3
4
5
6
7
8
9
10
11
当然我们也可以使用global数组
<?php
$a = 1;
$b = 2;
function Sum()
{
$GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}
Sum();
echo $b;
2
3
4
5
6
7
8
9
还有一个静态变量
<?php
function test()
{
static $a = 0;
echo $a." ";
$a++;
}
for ($i=0;$i<5;$i++){
test();
}
// 输出0 1 2 3 4
2
3
4
5
6
7
8
9
10
11
如果不加static，那么每次输出的都是一样的
# 可变变量
变量不仅可变，变量名也可变的，我们可以使用两个$$
<?php
$a= 'hello';
$$a = '666';
echo ${$a};
2
3
4
比如这里我们打印 666
# PHP之外的变量
这里我们可以获取HTML表单里面的值
PHP<?php
echo '参数为'.$_GET["hello"];
2
还可以设置cookie等等，后续再补充一下
# 常量
我们一般使用define来定义常量
<?php
const FOO = "测试";
define("FOOL","测试");
echo FOO;
2
3
4
# 魔术常量
这个其实就是一些预定义的常量，如下所示
| 名称 | 说明 |
|---|---|
__LINE__ | 文件中的当前行号。 |
__FILE__ | 文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名。 |
__DIR__ | 文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。它等价于 dirname(__FILE__)。除非是根目录，否则目录中名不包括末尾的斜杠。 |
__FUNCTION__ | 当前函数的名称。匿名函数则为 {closure}。 |
__CLASS__ | 当前类的名称。类名包括其被声明的作用区域（例如 Foo\Bar）。注意自 PHP 5.4 起 CLASS 对 trait 也起作用。当用在 trait 方法中时，CLASS 是调用 trait 方法的类的名字。 |
__TRAIT__ | Trait 的名字。Trait 名包括其被声明的作用区域（例如 Foo\Bar）。 |
__METHOD__ | 类的方法名。 |
__NAMESPACE__ | 当前命名空间的名称。 |
ClassName::class | 完整的类名，参见 ::class (opens new window)。 |
# 表达式
这里其实就一个三元运算符 $first ? $second : $third
# 运算符
这里主要是运算符的优先级问题
# 算数运算符
| 例子 | 名称 | 结果 |
|---|---|---|
| +$a | 标识 | 根据情况将 $a 转化为 int 或 float。 |
| -$a | 取反 | $a 的负值。 |
| $a + $b | 加法 | $a 和 $b 的和。 |
| $a - $b | 减法 | $a 和 $b 的差。 |
| $a * $b | 乘法 | $a 和 $b 的积。 |
| $a / $b | 除法 | $a 除以 $b 的商。 |
| $a % $b | 取模 | $a 除以 $b 的余数。 |
| $a ** $b | 求幂 | $a 的 $b次方的值。 |
# 赋值运算符
最基本的赋值就是 =，当然我们还可以使用引用运算符 &，使用“$var = &$othervar;”语法。引用赋值意味着两个变量指向了同一个数据，没有拷贝任何东西。
# 位运算
| 例子 | 名称 | 结果 |
|---|---|---|
$a & $b | And（按位与） | 将把 $a 和 $b 中都为 1 的位设为 1。 |
$a | $b | Or（按位或） | 将把 $a 和 $b 中任何一个为 1 的位设为 1。 |
$a ^ $b | Xor（按位异或） | 将把 $a 和 $b 中一个为 1 另一个为 0 的位设为 1。 |
~ $a | Not（按位取反） | 将 $a 中为 0 的位设为 1，反之亦然。 |
$a << $b | Shift left（左移） | 将 $a 中的位向左移动 $b 次（每一次移动都表示“乘以 2”）。 |
$a >> $b | Shift right（右移） | 将 $a 中的位向右移动 $b 次（每一次移动都表示“除以 2”）。 |
# 比较运算
| 例子 | 名称 | 结果 |
|---|---|---|
| $a == $b | 等于 | true，如果类型转换后 $a 等于 $b。 |
| $a === $b | 全等 | true，如果 $a 等于 $b，并且它们的类型也相同。 |
| $a != $b | 不等 | true，如果类型转换后 $a 不等于 $b。 |
| $a <> $b | 不等 | true，如果类型转换后 $a 不等于 $b。 |
| $a !== $b | 不全等 | true，如果 $a 不等于 $b，或者它们的类型不同。 |
| $a < $b | 小与 | true，如果 $a 严格小于 $b。 |
| $a > $b | 大于 | true，如果 $a 严格大于 $b。 |
| $a <= $b | 小于等于 | true，如果 $a 小于或者等于 $b。 |
| $a >= $b | 大于等于 | true，如果 $a 大于或者等于 $b。 |
| $a <=> $b | 太空船运算符（组合比较符） | 当$a小于、等于、大于 $b时 分别返回一个小于、等于、大于0的 int 值。 |
# 错误控制
@ 符号，当将其放置在一个 PHP 表达式之前，该表达式可能产生的任何错误信息都被忽略掉。
# 执行运算
反引号（``）。注意这不是单引号！PHP 将尝试将反引号中的内容作为 shell 命令来执行，并将其输出信息返回（即，可以赋给一个变量而不是简单地丢弃到标准输出）
<?php
$output = `dir`;
echo $output;
2
3
不过好像打印结果有乱码~
# 递增和递减运算
| 例子 | 名称 | 效果 |
|---|---|---|
| ++$a | 前加 | $a 的值加一，然后返回 $a。 |
| $a++ | 后加 | 返回 $a，然后将 $a 的值加一。 |
| --$a | 前减 | $a 的值减一， 然后返回 $a。 |
| $a-- | 后减 | 返回 $a，然后将 $a 的值减一。 |
# 逻辑运算
| 例子 | 名称 | 结果 |
|---|---|---|
| $a and $b | And（逻辑与） | true，如果 $a 和 $b 都为 true。 |
| $a or $b | Or（逻辑或） | true，如果 $a 或 $b 任一为 true。 |
| $a xor $b | Xor（逻辑异或） | true，如果 $a 或 $b 任一为 true，但不同时是。 |
| ! $a | Not（逻辑非） | true，如果 $a 不为 true。 |
| $a && $b | And（逻辑与） | true，如果 $a 和 $b 都为 true。 |
| $a || $b | Or（逻辑或） | true，如果 $a 或 $b 任一为 true。 |
# 字符串运算符
有两个字符串（string）运算符。第一个是连接运算符（“.”），它返回其左右参数连接后的字符串。第二个是连接赋值运算符（“.=”），它将右边参数附加到左边的参数之后。
# 数组运算
| 例子 | 名称 | 结果 |
|---|---|---|
| $a + $b | 联合 | $a 和 $b 的联合。 |
| $a == $b | 相等 | 如果 $a 和 $b 具有相同的键／值对则为 true。 |
| $a === $b | 全等 | 如果 $a 和 $b 具有相同的键／值对并且顺序和类型都相同则为 true。 |
| $a != $b | 不等 | 如果 $a 不等于 $b 则为 true。 |
| $a <> $b | 不等 | 如果 $a 不等于 $b 则为 true。 |
| $a !== $b | 不全等 | 如果 $a 不全等于 $b 则为 true。 |
# 类型运算
使用 instanceof 来判断变量类型是否相等
<?php
class MyClass
{
}
$a = new MyClass;
var_dump(!($a instanceof stdClass));
2
3
4
5
6
这里会输出 true
# 流程控制
这个其实就比较简单了，这里就简单过一下
# if-else语句
<?php
if ($a > $b) {
echo "a is bigger than b";
} elseif ($a == $b) {
echo "a is equal to b";
} else {
echo "a is smaller than b";
}
2
3
4
5
6
7
8
# 流程控制的替代语法
替代语法的基本形式是把左花括号（{）换成冒号（:），把右花括号（}）分别换成 endif;，endwhile;，endfor;，endforeach; 以及 endswitch;。
比如下面这样
<?php
if ($a == 5):
echo "a equals 5";
echo "...";
elseif ($a == 6):
echo "a equals 6";
echo "!!!";
else:
echo "a is neither 5 nor 6";
endif;
2
3
4
5
6
7
8
9
10
# while和do while
<?php
/* while的第一个例子 */
$i = 1;
while ($i <= 10) {
echo $i++;
}
/* while的第二个例子 */
$i = 1;
while ($i <= 10):
print $i;
$i++;
endwhile;
/*do while 只能这样用 */
$i = 0;
do {
echo $i;
} while ($i > 0);
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# for和for-each
for循环的几种写法
<?php
/* example 1 */
for ($i = 1; $i <= 10; $i++) {
echo $i;
}
/* example 2 */
for ($i = 1; ; $i++) {
if ($i > 10) {
break;
}
echo $i;
}
/* example 3 */
$i = 1;
for (;;) {
if ($i > 10) {
break;
}
echo $i;
$i++;
}
/* example 4 */
for ($i = 1, $j = 0; $i <= 10; $j += $i, print $i, $i++);
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
foreach用于遍历数组
<?php
$arr = array(1, 2, 3, 4);
foreach ($arr as &$value) {
$value = $value * 2;
}
// $arr is now array(2, 4, 6, 8)
unset($value); // 最后取消掉引用
2
3
4
5
6
7
常见的五种用法
<?php
/* foreach example 1: value only */
$a = array(1, 2, 3, 17);
foreach ($a as $v) {
echo "Current value of \$a: $v.\n";
}
/* foreach example 2: value (with its manual access notation printed for illustration) */
$a = array(1, 2, 3, 17);
$i = 0; /* for illustrative purposes only */
foreach ($a as $v) {
echo "\$a[$i] => $v.\n";
$i++;
}
/* foreach example 3: key and value */
$a = array(
"one" => 1,
"two" => 2,
"three" => 3,
"seventeen" => 17
);
foreach ($a as $k => $v) {
echo "\$a[$k] => $v.\n";
}
/* foreach example 4: multi-dimensional arrays */
$a = array();
$a[0][0] = "a";
$a[0][1] = "b";
$a[1][0] = "y";
$a[1][1] = "z";
foreach ($a as $v1) {
foreach ($v1 as $v2) {
echo "$v2\n";
}
}
/* foreach example 5: dynamic arrays */
foreach (array(1, 2, 3, 4, 5) as $v) {
echo "$v\n";
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
直接遍历二维数组
<?php
$array = [
[1, 2],
[3, 4],
];
foreach ($array as list($a, $b)) {
// $a contains the first element of the nested array,
// and $b contains the second element.
echo "A: $a; B: $b\n";
}
2
3
4
5
6
7
8
9
10
# break和continue的区别
这个和其他语言一样。不过 continue 接受一个可选的数字参数来决定跳过几重循环到循环结尾。默认值是 1，即跳到当前循环末尾。
<?php
while (list ($key, $value) = each($arr)) {
if (!($key % 2)) { // skip odd members
continue;
}
do_something_odd($value);
}
$i = 0;
while ($i++ < 5) {
echo "Outer<br />\n";
while (1) {
echo "Middle<br />\n";
while (1) {
echo "Inner<br />\n";
continue 3;
}
echo "This never gets output.<br />\n";
}
echo "Neither does this.<br />\n";
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# switch语句
switch 语句类似于具有同一个表达式的一系列 if 语句。很多场合下需要把同一个变量（或表达式）与很多不同的值比较，并根据它等于哪个值来执行不同的代码。这正是 switch 语句的用途。
最简单的用法
<?php
switch ($i) {
case "apple":
echo "i is apple";
break;
case "bar":
echo "i is bar";
break;
case "cake":
echo "i is cake";
b
2
3
4
5
6
7
8
9
10
11
# match
这个其实就有点像kotlin里面的when（这个是PHP8里面的），可以根据不同的值设置内容，不过建议目前不用这个
<?php
$result = match ($x) {
foo() => ...,
$this->bar() => ..., // bar() isn't called if foo() === $x
$this->baz => beep(), // beep() isn't called unless $x === $this->baz
// etc.
};
2
3
4
5
6
7
# declare
declare 结构用来设定一段代码的执行指令。declare 的语法和其它流程控制结构相似：
<?php
// 两者相等：
// 可以这样用：
declare(ticks=1) {
// 这里写完整的脚本
}
// 也可以这样用：
declare(ticks=1);
// 这里写完整的脚本
2
3
4
5
6
7
8
9
Tick（时钟周期）是一个在 declare 代码段中解释器每执行 N 条可计时的低级语句就会发生的事件。N 的值是在 declare 中的 directive 部分用 ticks=N 来指定的。
declare也可以指定脚本编码
<?php
declare(encoding='ISO-8859-1');
// 在这里写代码
2
3
# return
这个我就不说了，就是返回对应的值
# require和include
这个两个用于引入外部的PHP文件
require 和 include (opens new window) 几乎完全一样，除了处理失败的方式不同之外。require 在出错时产生 E_COMPILE_ERROR 级别的错误。换句话说将导致脚本中止而 include (opens new window) 只产生警告（E_WARNING），脚本会继续运行。
基本用法
vars.php
<?php
$color = 'green';
$fruit = 'apple';
?>
test.php
<?php
echo "A $color $fruit"; // A
include 'vars.php';
echo "A $color $fruit"; // A green apple
2
3
4
5
6
7
8
9
10
11
include和return语句
return.php
<?php
$var = 'PHP';
return $var;
?>
noreturn.php
<?php
$var = 'PHP';
?>
testreturns.php
<?php
$foo = include 'return.php';
echo $foo; // prints 'PHP'
$bar = include 'noreturn.php';
echo $bar; // prints 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# require_once和require_once
require_once 语句和 require (opens new window) 语句完全相同，唯一区别是 PHP 会检查该文件是否已经被包含过，如果是则不会再次包含。
include_once 语句在脚本执行期间包含并运行指定文件。此行为和 include (opens new window) 语句类似，唯一区别是如果该文件中已经被包含过，则不会再次包含，且 include_once 会返回 true。 如同此语句名字暗示的那样，该文件只会包含一次。
include_once 可以用于在脚本执行期间同一个文件有可能被包含超过一次的情况下，想确保它只被包含一次以避免函数重定义，变量重新赋值等问题。
# goto
PHP支持goto，该目标位置可以用目标名称加上冒号来标记，而跳转指令是 goto 之后接上目标位置的标记。PHP 中的 goto 有一定限制，目标位置只能位于同一个文件和作用域，也就是说无法跳出一个函数或类方法，也无法跳入到另一个函数。也无法跳入到任何循环或者 switch 结构中。可以跳出循环或者 switch，通常的用法是用 goto 代替多层的 break。
<?php
goto a;
echo 'Foo';
a:
echo 'Bar';
2
3
4
5
6