PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。
PHP Hypertext Preprocessor
通过 PHP，您可以不受限于只输出 HTML。您还能够输出图像、PDF 文件、甚至 Flash 影片。您也可以输出任何文本，比如 XHTML 和 XML。
PHP 脚本可放置于文档中的任何位置。
PHP 脚本以 结尾：
<?php// 此处是 PHP 代码?>
PHP 文件的默认文件扩展名是 ".php"。
PHP 文件通常包含 HTML 标签以及一些 PHP 脚本代码。
<?php// 这是单行注释# 这也是单行注释/*这是多行注释块它横跨了多行*/?>
不过在 PHP 中，所有变量都对大小写敏感。
变量是存储信息的容器
PHP 有三种不同的变量作用域：
通常，当函数完成/执行后，会删除所有变量。不过，有时我需要不删除某个局部变量。实现这一点需要更进一步的工作。
要完成这一点，请在您首次声明变量时使用 static 关键词
在 PHP 中，有两种基本的输出方法：echo 和 print。
echo 和 print 之间的差异：
提示：echo 比 print 稍快，因为它不返回任何值。
<?phpecho "<h2>PHP is fun!</h2>";echo "Hello world!<br>";echo "This", " string", " was", " made", " with multiple parameters.";?>
<?phpprint "<h2>PHP is fun!</h2>";print "I'm about to learn PHP!";?>
<?php $cars=array("Volvo","BMW","SAAB");var_dump($cars);?>
特殊的 NULL 值表示变量无值。NULL 是数据类型 NULL 唯一可能的值。
NULL 值标示变量是否为空。也用于区分空字符串与空值数据库。
可以通过把值设置为 NULL，将变量清空
常量类似变量，但是常量一旦被定义就无法更改或撤销定义。 有效的常量名以字符或下划线开头（常量名称前面没有 $ 符号）。与变量不同，常量贯穿整个脚本是自动全局的。
如需设置常量，请使用 define() 函数 - 它使用三个参数：
创建了一个对大小写敏感的常量，值为 "Welcome to W3School.com.cn!"：
<?phpdefine("GREETING", "Welcome to W3School.com.cn!", true);echo greeting;?><?php $x=10; $y=6;echo ($x + $y); // 输出 16echo ($x - $y); // 输出 4echo ($x * $y); // 输出 60echo ($x / $y); // 输出 1.6666666666667echo ($x % $y); // 输出 4?>
| . | 串接 | $txt1 = "Hello" $txt2 = $txt1 . " world!" | 现在 $txt2 包含 "Hello world!" |
| .= | 串接赋值 | $txt1 = "Hello" $txt1 .= " world!" | 现在 $txt1 包含 "Hello world!" |
| ++$x | 前递增 | $x 加一递增，然后返回 $x |
| $x++ | 后递增 | 返回 $x，然后 $x 加一递增 |
| --$x | 前递减 | $x 减一递减，然后返回 $x |
| $x-- | 后递减 | 返回 $x，然后 $x 减一递减 |
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。 |
| and | 与 | $x and $y | 如果 $x 和 $y 都为 true，则返回 true。 |
| or | 或 | $x or $y | 如果 $x 和 $y 至少有一个为 true，则返回 true。 |
| xor | 异或 | $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 + $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 中，我们可以使用以下条件语句：
在 PHP 中，我们有以下循环语句：
foreach 循环只适用于数组，并用于遍历数组中的每个键/值对。
<?php $colors = array("red","green","blue","yellow"); foreach ($colors as $value) { echo "$value <br>";}?>
页面加载时函数不会立即执行。
函数只有在被调用时才会执行。
<?phpfunction setHeight($minheight=50) { echo "The height is : $minheight <br>";}setHeight(350);setHeight(); // 将使用默认值 50setHeight(135);setHeight(80);?>
在 PHP 中， array() 函数用于创建数组：
array();
在 PHP 中，有三种数组类型：
索引是自动分配的（索引从 0 开始）：
$cars=array("Volvo","BMW","SAAB");或者：$cars[0]="Volvo";$cars[1]="BMW";$cars[2]="SAAB";count() 函数用于返回数组的长度（元素数）
<?php$cars=array("Volvo","BMW","SAAB");$arrlength=count($cars);for($x=0;$x<$arrlength;$x++) { echo $cars[$x]; echo "<br>";}?>关联数组是使用您分配给数组的指定键的数组。
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"4");或者：$age['Peter']="35";$age['Ben']="37";$age['Joe']="4";<?php$age=array("Bill"=>"35","Steve"=>"37","Peter"=>"43");foreach($age as $x=>$x_value) { echo "Key=" . $x . ", Value=" . $x_value; echo "<br>";}?>
PHP 中的许多预定义变量都是“超全局的”，这意味着它们在一个脚本的全部作用域中都可用。在函数或方法中无需执行 global $variable; 就可以访问它们。
这些超全局变量是：
$GLOBALS 这种全局变量用于在 PHP 脚本中的任意位置访问全局变量（从函数或方法中均可）。
$_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'];?>
PHP $_REQUEST 用于收集 HTML 表单提交的数据。
PHP $_POST 广泛用于收集提交 method="post" 的 HTML 表单后的表单数据。$_POST 也常用于传递变量。
PHP $_GET 也可用于收集提交 HTML 表单 (method="get") 之后的表单数据。$_GET 也可以收集 URL 中的发送的数据。
PHP 超全局变量 $_GET 和 $_POST 用于收集表单数据（form-data）。
$_GET 是通过 URL 参数传递到当前脚本的变量数组。
$_POST 是通过 HTTP POST 传递到当前脚本的变量数组。
通过 GET 方法从表单发送的信息对任何人都是可见的（所有变量名和值都显示在 URL 中）。GET 对所发送信息的数量也有限制。限制在大于 2000 个字符。不过，由于变量显示在 URL 中，把页面添加到书签中也更为方便。
GET 可用于发送非敏感的数据。
通过 POST 方法从表单发送的信息对其他人是不可见的（所有名称/值会被嵌入 HTTP 请求的主体中），并且对所发送信息的数量也无限制。
此外 POST 支持高阶功能，比如在向服务器上传文件时进行 multi-part 二进制输入。
提示：开发者偏爱 POST 来发送表单数据。
$_SERVER["PHP_SELF"] 是一种超全局变量，它返回当前执行脚本的文件名。
因此，$_SERVER["PHP_SELF"] 将表单数据发送到页面本身，而不是跳转到另一张页面。这样，用户就能够在表单页面获得错误提示信息。
htmlspecialchars() 函数把特殊字符转换为 HTML 实体。---------------------------------------------------------------------------------------------------------------
PHP 支持 8 种原始数据类型。
四种标量类型：
两种复合类型：
最后是两种特殊类型：
为了确保代码的易读性，本手册还介绍了一些伪类型：
以及伪变量 $...。
Note: 如果想查看某个表达式的值和类型，用 var_dump() 函数。
如果只是想得到一个易读懂的类型的表达方式用于调试，用 gettype() 函数。要查看某个类型，不要用 gettype()，而用 is_type 函数
$a_bool = TRUE; // a boolean
$a_str = "foo"; // a string
$a_str2 = 'foo'; // a string
$an_int = 12; // an integer
echo gettype($a_bool); // prints out: boolean
echo gettype($a_str); // prints out: string
// If this is an integer, increment it by four
if (is_int($an_int)) {
$an_int += 4;
}
// If $bool is a string, print it out
// (does not print out anything)
if (is_string($a_bool)) {
echo "String: $a_bool";
}
?>
如果要将一个变量强制转换为某类型，可以对其使用强制转换或者 settype() 函数。
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)
?>
要使用八进制表达，数字前必须加上 0（零）。要使用十六进制表达，数字前必须加上 0x。要使用二进制表达，数字前必须加上 0b。
$a = 1234; // 十进制数
$a = -123; // 负数
$a = 0123; // 八进制数 (等于十进制 83)
$a = 0x1A; // 十六进制数 (等于十进制 26)
?>
Integer 值的字长可以用常量 PHP_INT_SIZE来表示，自 PHP 4.4.0 和 PHP 5.0.5后，最大值可以用常量 PHP_INT_MAX 来表示。
Warning 如果向八进制数传递了一个非法数字（即 8 或 9），则后面其余数字会被忽略。
var_dump(01090); // 八进制 010 = 十进制 8
?>
如果给定的一个数超出了 integer 的范围，将会被解释为 float。同样如果执行的运算结果超出了 integer 范围，也会返回 float。
PHP 中没有整除的运算符。1/2 产生出 float0.5。值可以舍弃小数部分强制转换为 integer，或者使用 round() 函数可以更好地进行四舍五入。
var_dump(25/7); // float(3.5714285714286)
var_dump((int) (25/7)); // int(3)
var_dump(round(25/7)); // float(4)
?>
Warning 决不要将未知的分数强制转换为 integer，这样有时会导致不可预料的结果。
echo (int) ( (0.1+0.7) * 10 ); // 显示 7!
?>
所以永远不要相信浮点数结果精确到了最后一位，也永远不要比较两个浮点数是否相等。如果确实需要更高的精度。
比较浮点数迂回的方法：
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;
if(abs($a-$b) < $epsilon) {
echo "true";
}
?>
某些数学运算会产生一个由常量 NAN所代表的结果。此结果代表着一个在浮点数运算中未定义或不可表述的值。任何拿此值与其它任何值进行的松散或严格比较的结果都是 FALSE。由于 NAN 代表着任何不同值，不应拿 NAN 去和其它值进行比较，包括其自身，应该用 is_nan() 来检查。
PHP 只能支持 256 的字符集，因此不支持 Unicode 。 Note: string 最大可以达到 2GB。
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';
?>
用双引号定义的字符串最重要的特征是变量会被解析
第三种表达字符串的方法是用 heredoc 句法结构：<<<。在该运算符之后要提供一个标识符，然后换行。接下来是字符串 string 本身，最后要用前面定义的标识符作为结束标志。
Note:不象 heredoc 结构，nowdoc 结构可以用在任意的静态数据环境中，最典型的示例是用来初始化类的属性或常量：
当字符串用双引号或 heredoc 结构定义时，其中的变量将会被解析。
Array：
key 可以是 integer 或者 string。value 可以是任意类型。
PHP 数组可以同时含有 integer 和 string 类型的键名，因为 PHP 实际并不区分索引数组和关联数组。
仅对部分单元指定键名
$array = array(
"a",
"b",
6 => "c",
"d",
);
var_dump($array);
?>
Note:试图访问一个未定义的数组键名与访问任何未定义变量一样：会导致 E_NOTICE 级别错误信息，其结果为 NULL。
要修改某个值，通过其键名给该单元赋一个新值。要删除某键值对，对其调用 unset() 函数。
$arr = array(5 => 1, 12 => 2);
$arr[] = 56; // This is the same as $arr[13] = 56;
$arr["x"] = 42; // This adds a new element to
unset($arr[5]); // This removes the element from the array
unset($arr); // This deletes the whole array
?>
例子：
// 创建一个简单的数组
$array = array(1, 2, 3, 4, 5);
print_r($array);
// 现在删除其中的所有元素，但保持数组本身不变:
foreach ($array as $i => $value) {
unset($array[$i]);
}
print_r($array);
// 添加一个单元（注意新的键名是 5，而不是你可能以为的 0）
$array[] = 6;
print_r($array);
// 重新索引：
$array = array_values($array);
$array[] = 7;
print_r($array);
?>
以上例程会输出：
Array( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5)Array()Array( [5] => 6)Array( [0] => 6 [1] => 7)
Note:unset() 函数允许删除数组中某个键。要注意数组将不会重建索引。如果需要删除后重建索引，可以用 array_values() 函数。
$a = array(1 => 'one', 2 => 'two', 3 => 'three');
unset($a[2]);
/* will produce an array that would have been defined as
$a = array(1 => 'one', 3 => 'three');
and NOT
$a = array(1 => 'one', 2 =>'three');
*/
$b = array_values($a);
// Now $b is array(0 => 'one', 1 =>'three')
?>
foreach 控制结构是专门用于数组的。它提供了一个简单的方法来遍历数组。
对于任意 integer，float，string，boolean和 resource 类型，如果将一个值转换为数组，将得到一个仅有一个元素的数组，其下标为 0，该元素即为此标量的值。换句话说，(array)$scalarValue 与 array($scalarValue) 完全一样。
将 NULL 转换为 array 会得到一个空的数组。
可以用 array_diff() 和数组运算符来比较数组。
如果将一个对象转换成对象，它将不会有任何变化。如果其它任何类型的值被转换成对象，将会创建一个内置类 stdClass 的实例。如果该值为 NULL，则新的实例为空。数组转换成对象将使键名成为属性名并具有相对应的值。对于任何其它的值，名为scalar 的成员变量将包含该值。
$obj = (object) 'ciao';
echo $obj->scalar; // outputs 'ciao'
?>
资源 resource是一种特殊变量，保存了到外部资源的一个引用。资源是通过专门的函数来建立和使用的
特殊的 NULL 值表示一个变量没有值。NULL 类型唯一可能的值就是 NULL。
在下列情况下一个变量被认为是 NULL：被赋值为 NULL。尚未被赋值。被 unset()。
使用 (unset) $var 将一个变量转换为 null将不会删除该变量或 unset 其值。仅是返回 NULL 值而已。
一些函数如 call_user_func() 或 usort() 可以接受用户自定义的回调函数作为参数。回调函数不止可以是简单函数，还可以是对象的方法，包括静态类方法。
mixed 说明一个参数可以接受多种不同的（但不一定是所有的）类型。
例如 gettype() 可以接受所有的 PHP 类型，str_replace() 可以接受字符串和数组。
number 说明一个参数可以是 integer 或者 float。
void 作为返回类型意味着函数的返回值是无用的。void作为参数列表意味着函数不接受任何参数
在函数原型中，$... 表示等等的意思。当一个函数可以接受任意个参数时使用此变量名。
$foo = "0"; // $foo 是字符串 (ASCII 48)
$foo += 2; // $foo 现在是一个整数 (2)
$foo = $foo + 1.3; // $foo 现在是一个浮点数 (3.3)
$foo = 5 + "10 Little Piggies"; // $foo 是整数 (15)
$foo = 5 + "10 Small Pigs"; // $foo 是整数 (15)
?>
$a = 'car'; // $a is a string
$a[0] = 'b'; // $a is still a string
echo $a; // bar
?>
PHP 中的类型强制转换和 C 中的非常像：在要转换的变量之前加上用括号括起来的目标类型。
$foo = 10; // $foo is an integer
$bar = (boolean) $foo; // $bar is a boolean
?>
允许的强制转换有：
注意在括号内允许有空格和制表符，所以下面两个例子功能相同：
$foo = (int) $bar;
$foo = ( int ) $bar;
?>
将字符串文字和变量转换为二进制字符串：
$binary = (binary)$string;
$binary = b"binary string";
?>
可以将变量放置在双引号中的方式来代替将变量转换成字符串：
$foo = 10; // $foo 是一个整数
$str = "$foo"; // $str 是一个字符串
$fst = (string) $foo; // $fst 也是一个字符串
// 输出 "they are the same"
if ($fst === $str) {
echo "they are the same";
}
?>
常量只能包含标量数据（boolean，integer，float和 string）。可以定义 resource 常量，但应尽量避免，因为会造成不可预料的结果。
常量和变量有如下不同：
Note:和使用 define() 来定义常量相反的是，使用 const关键字定义常量必须处于最顶端的作用区域，因为用此方法是在编译时定义的。这就意味着不能在函数内，循环内以及 if 语句之内用 const 来定义常量。
PHP 向它运行的任何脚本提供了大量的预定义常量。不过很多常量都是由不同的扩展库定义的，只有在加载了这些扩展库时才会出现，或者动态加载后，或者在编译时已经包括进去了。
有八个魔术常量它们的值随着它们在代码中的位置改变而改变。例如 __LINE__ 的值就依赖于它在脚本中所处的行来决定。这些特殊的常量不区分大小写，如下：
几个 PHP 的"魔术常量"| __LINE__ | 文件中的当前行号。 |
| __FILE__ | 文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名。自 PHP 4.0.2 起，__FILE__总是包含一个绝对路径（如果是符号连接，则是解析后的绝对路径），而在此之前的版本有时会包含一个相对路径。 |
| __DIR__ | 文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。它等价于 dirname(__FILE__)。除非是根目录，否则目录中名不包括末尾的斜杠。（PHP 5.3.0中新增）= |
| __FUNCTION__ | 函数名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该函数被定义时的名字（区分大小写）。在 PHP 4 中该值总是小写字母的。 |
| __CLASS__ | 类的名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该类被定义时的名字（区分大小写）。在 PHP 4 中该值总是小写字母的。类名包括其被声明的作用区域（例如 Foo\Bar）。注意自 PHP 5.4 起 __CLASS__ 对 trait 也起作用。当用在 trait 方法中时，__CLASS__ 是调用 trait 方法的类的名字。 |
| __TRAIT__ | Trait 的名字（PHP 5.4.0 新加）。自 PHP 5.4 起此常量返回 trait 被定义时的名字（区分大小写）。Trait 名包括其被声明的作用区域（例如 Foo\Bar）。 |
| __METHOD__ | 类的方法名（PHP 5.0.0 新加）。返回该方法被定义时的名字（区分大小写）。 |
| __NAMESPACE__ | 当前命名空间的名称（区分大小写）。此常量是在编译时定义的（PHP 5.3.0 新增）。 |
PHP 支持可变函数的概念。这意味着如果一个变量名后有圆括号，PHP 将寻找与变量的值同名的函数，并且尝试执行它。可变函数可以用来实现包括回调函数，函数表在内的一些用途。
对象赋值
$instance = new SimpleClass();
$assigned = $instance;
$reference =& $instance;
$instance->var = '$assigned will have this value';
$instance = null; // $instance and $reference become null
var_dump($instance);
var_dump($reference);
var_dump($assigned);
?>
NULLNULLobject(SimpleClass)#1 (1) { ["var"]=> string(30) "$assigned will have this value"}
class Test{
static public function getNew(){
return new static;
}
}
class Child extends Test
{}
$obj1 = new Test();
$obj2 = new $obj1;
var_dump($obj1 !== $obj2);
$obj3 = Test::getNew();
var_dump($obj3 instanceof Test);
$obj4 = Child::getNew();
var_dump($obj4 instanceof Child);
?>
bool(true)bool(true)bool(true)
namespace NS {
class ClassName {
}
echo ClassName::class;
}
?>
以上例程会输出：
NS\ClassName
在类的成员方法里面，可以用 ->（对象运算符）：$this->property（其中 property 是该属性名）这种方式来访问非静态属性。静态属性则是用 ::（双冒号）：self::$property来访问。
定义和使用一个类常量
class MyClass{
const constant = 'constant value';
function showConstant() {
echo self::constant . "\n";
}
}
echo MyClass::constant . "\n";
$classname = "MyClass";
echo $classname::constant . "\n"; // 自 5.3.0 起
$class = new MyClass();
$class->showConstant();
echo $class::constant."\n"; // 自 PHP 5.3.0 起
?>
自动加载示例
分别从 MyClass1.php和 MyClass2.php 文件中加载 MyClass1 和 MyClass2 类。
function __autoload($class_name) {
require_once $class_name . '.php';
}
$obj = new MyClass1();
$obj2 = new MyClass2();
?>
具有构造函数的类会在每次创建新对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作。
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
