php基础教程

PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。

PHP Hypertext Preprocessor

什么是 PHP 文件？

PHP 文件能够包含文本、HTML、CSS 以及 PHP 代码

PHP 代码在服务器上执行，而结果以纯文本返回浏览器

PHP 文件的后缀是 ".php"

PHP 能够做什么？

PHP 能够生成动态页面内容

PHP 能够创建、打开、读取、写入、删除以及关闭服务器上的文件

PHP 能够接收表单数据

PHP 能够发送并取回 cookies

PHP 能够添加、删除、修改数据库中的数据

PHP 能够限制用户访问网站中的某些页面

PHP 能够对数据进行加密

通过 PHP，您可以不受限于只输出 HTML。您还能够输出图像、PDF 文件、甚至 Flash 影片。您也可以输出任何文本，比如 XHTML 和 XML。

基础 PHP 语法

PHP 脚本可放置于文档中的任何位置。

PHP 脚本以 结尾：

PHP 文件的默认文件扩展名是 ".php"。

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

PHP 支持三种注释：

在 PHP 中，所有用户定义的函数、类和关键词（例如 if、else、echo 等等）都对大小写不敏感。

不过在 PHP 中，所有变量都对大小写敏感。

变量是存储信息的容器

PHP 变量规则：

变量以 $ 符号开头，其后是变量的名称

变量名称必须以字母或下划线开头

变量名称不能以数字开头

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

变量名称对大小写敏感（$y 与 $Y 是两个不同的变量）

PHP 是一门类型松散的语言

PHP 有三种不同的变量作用域：

local（局部）

global（全局）

static（静态）

PHP static 关键词

通常，当函数完成/执行后，会删除所有变量。不过，有时我需要不删除某个局部变量。实现这一点需要更进一步的工作。

要完成这一点，请在您首次声明变量时使用 static 关键词

在 PHP 中，有两种基本的输出方法：echo 和 print。

echo 和 print 之间的差异：

echo - 能够输出一个以上的字符串

print - 只能输出一个字符串，并始终返回 1

提示：echo 比 print 稍快，因为它不返回任何值。

PHP is fun!";echo "Hello world!
";echo "This", " string", " was", " made", " with multiple parameters.";?>

PHP is fun!";print "I'm about to learn PHP!";?>

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

运行结果：array(3) { [0]=> string(5) "Volvo" [1]=> string(3) "BMW" [2]=> string(4) "SAAB" }

PHP NULL 值

特殊的 NULL 值表示变量无值。NULL 是数据类型 NULL 唯一可能的值。

NULL 值标示变量是否为空。也用于区分空字符串与空值数据库。

可以通过把值设置为 NULL，将变量清空

常量类似变量，但是常量一旦被定义就无法更改或撤销定义。

有效的常量名以字符或下划线开头（常量名称前面没有 $ 符号）。与变量不同，常量贯穿整个脚本是自动全局的。

设置 PHP 常量

如需设置常量，请使用 define() 函数 - 它使用三个参数：

1. 首个参数定义常量的名称
2. 第二个参数定义常量的值
3. 可选的第三个参数规定常量名是否对大小写敏感。默认是 false。

创建了一个对大小写敏感的常量，值为 "Welcome to W3School.com.cn!"：

PHP 算数运算符

PHP 字符串运算符

运算符 名称 例子 结果

.	串接	$txt1 = "Hello" $txt2 = $txt1 . " world!"	现在 $txt2 包含 "Hello world!"
.=	串接赋值	$txt1 = "Hello" $txt1 .= " world!"	现在 $txt1 包含 "Hello world!"

PHP 递增/递减运算符

运算符 名称 描述

++$x	前递增	$x 加一递增，然后返回 $x
$x++	后递增	返回 $x，然后 $x 加一递增
--$x	前递减	$x 减一递减，然后返回 $x
$x--	后递减	返回 $x，然后 $x 减一递减

PHP 比较运算符

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

PHP 逻辑运算符

运算符 名称 例子 结果

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 数组运算符

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 中，我们可以使用以下条件语句：

if 语句 - 如果指定条件为真，则执行代码

if...else 语句 - 如果条件为 true，则执行代码；如果条件为 false，则执行另一端代码

if...elseif....else 语句 - 选择若干段代码块之一来执行

switch 语句 - 语句多个代码块之一来执行

在 PHP 中，我们有以下循环语句：

while - 只要指定条件为真，则循环代码块

do...while - 先执行一次代码块，然后只要指定条件为真则重复循环

for - 循环代码块指定次数

foreach - 遍历数组中的每个元素并循环代码块

PHP foreach 循环

foreach 循环只适用于数组，并用于遍历数组中的每个键/值对。

";}?>

PHP 的真正力量来自它的函数：它拥有超过 1000 个内建的函数。

页面加载时函数不会立即执行。

函数只有在被调用时才会执行。

PHP 默认参数值

";}setHeight(350);setHeight(); // 将使用默认值 50setHeight(135);setHeight(80);?>

在 PHP 中创建数组

在 PHP 中， array() 函数用于创建数组：

array();

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

索引数组 - 带有数字索引的数组

关联数组 - 带有指定键的数组

多维数组 - 包含一个或多个数组的数组

索引是自动分配的（索引从 0 开始）：

$cars=array("Volvo","BMW","SAAB");或者：$cars[0]="Volvo";$cars[1]="BMW";$cars[2]="SAAB";

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

count() 函数用于返回数组的长度（元素数）

遍历索引数组

";}?>

PHP 关联数组

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

$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"4");或者：$age['Peter']="35";$age['Ben']="37";$age['Joe']="4";

遍历关联数组

"35","Steve"=>"37","Peter"=>"43");foreach($age as $x=>$x_value) {  echo "Key=" . $x . ", Value=" . $x_value;  echo "
";}?>

PHP - 数组的排序函数

sort() - 以升序对数组排序

rsort() - 以降序对数组排序

asort() - 根据值，以升序对关联数组进行排序

ksort() - 根据键，以升序对关联数组进行排序

arsort() - 根据值，以降序对关联数组进行排序

krsort() - 根据键，以降序对关联数组进行排序

PHP 全局变量 - 超全局变量

PHP 中的许多预定义变量都是“超全局的”，这意味着它们在一个脚本的全部作用域中都可用。在函数或方法中无需执行 global $variable; 就可以访问它们。

这些超全局变量是：

$GLOBALS

$_SERVER

$_REQUEST

$_POST

$_GET

$_FILES

$_ENV

$_COOKIE

$_SESSION

$GLOBALS 这种全局变量用于在 PHP 脚本中的任意位置访问全局变量（从函数或方法中均可）。

PHP $_SERVER

$_SERVER 这种超全局变量保存关于报头、路径和脚本位置的信息。

";echo $_SERVER['SERVER_NAME'];echo "
";echo $_SERVER['HTTP_HOST'];echo "
";echo $_SERVER['HTTP_REFERER'];echo "
";echo $_SERVER['HTTP_USER_AGENT'];echo "
";echo $_SERVER['SCRIPT_NAME'];?>

PHP $_REQUEST

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

PHP $_POST

PHP $_POST 广泛用于收集提交 method="post" 的 HTML 表单后的表单数据。$_POST 也常用于传递变量。

PHP $_GET

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 种原始数据类型。

四种标量类型：

boolean（布尔型）

integer（整型）

float（浮点型，也称作 double)

string（字符串）

两种复合类型：

array（数组）

object（对象）

最后是两种特殊类型：

resource（资源）

NULL（无类型）

为了确保代码的易读性，本手册还介绍了一些伪类型：

mixed（混合类型）

number（数字类型）

callback（回调类型）

以及伪变量 $...。

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) 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 句法结构：

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

允许的强制转换有：

(int), (integer) - 转换为整形 integer

(bool), (boolean) - 转换为布尔类型 boolean

(float), (double), (real) - 转换为浮点型 float

(string) - 转换为字符串 string

(array) - 转换为数组 array

(object) - 转换为对象 object

(unset) - 转换为 NULL (PHP 5)

注意在括号内允许有空格和制表符，所以下面两个例子功能相同：

$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 常量，但应尽量避免，因为会造成不可预料的结果。

常量和变量有如下不同：

常量前面没有美元符号（$）；

常量只能用 define() 函数定义，而不能通过赋值语句；

常量可以不用理会变量的作用域而在任何地方定义和访问；

常量一旦定义就不能被重新定义或者取消定义；

常量的值只能是标量。

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)

使用 ClassName::class 你可以获取一个字符串，包含了类 ClassName 的完全限定名称。

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

具有构造函数的类会在每次创建新对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作。