php手册笔记.doc

1.查看某个表达式的值和类型，用 var_dump()。
2.想得到一个易读懂的类型的表达方式用于调试，用 gettype()。
3.查看某个类型，不要用 gettype()，而用 is_type 函数。
pe($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";
}
?>

4.要将一个变量强制转换为某类型，可以对其使用强制转换或者 settype() 函数。

5.当转换为 boolean 时，以下值被认为是 FALSE：

■the 布尔值 FALSE 自身
■the 整型值 0 (零)
■the 浮点型值 0.0 (零)
■空 字符串, 以及 字符串 "0"
■不包括任何元素的数组
■不包括任何成员变量的对象（仅PHP 4.0 适用）
■特殊类型 NULL (包括尚未设定的变量)
■从没有任何标记（tags）的XML文档生成的SimpleXML 对象
所有其它值都被认为是 TRUE（包括任何资源）。

6.Warning
如果向八进制数传递了一个非法数字（即 8 或 9），则后面其余数字会被忽略。

Example #2 八进制数的怪事

7.整数溢出
如果给定的一个数超出了 integer 的范围，将会被解释为 float。同样如果执行的运算结果超出了 integer 范围，也会返回 float。

8.array( key => value
, ...
)
// 键(key) 可是是一个 整数(integer) 或 字符串(string)
// 值(value) 可以是任意类型的值p
$arr = array("foo" => "bar", 12 => true);

echo $arr["foo"]; // bar
echo $arr[12]; // 1
?>
key 可以是 integer 或者 string。如果key是一个 integer 的标准表示，则被解释为整数（例如 "8" 将被解释为 8，而 "08" 将被解释为 "08"）。key 中的浮点数被取整为 integer。在 PHP 中索引数组与关联 数组 是相同的，它们都可以同时包含 整型 和 字符串 的下标。

9.要删除一个键名／值对，要对它用 unset()。

php
$arr = array(5 => 1, 12 => 2);

$arr[] = 56; // This is the same as $arr[13] = 56;
// at this point of the script

$arr["x"] = 42; // This adds a new element to
// the array with key "x"

unset($arr[5]); // This removes the element from the array

unset($arr); // This deletes the whole array
?>

10.在下列情况下一个变量被认为是 NULL：

■被赋值为 NULL。

■尚未被赋值。

■被 unset()。

NULL 类型只有一个值，就是大小写不敏感的关键字 NULL（你可以写成NULL，也可以写成null）。

11.Callback 函数不仅可以是一个简单的函数，它还可以是一个对象的方法，包括静态类的方法。

Example #1 回调函数(callback)示例

的回调函数
function my_callback_function() {
echo 'hello world!';
}

// 回调方法
class MyClass {
static function myCallbackMethod() {
echo 'Hello World!';
}
}

// Type 1: Simple callback
call_user_func('my_callback_function');

// Type 2: Static class method call
call_user_func(array('MyClass', 'myCallbackMethod'));

// Type 3: Object method call
$obj = new MyClass();
call_user_func(array($obj, 'myCallbackMethod'));

// Type 4: Static class method call (As of PHP 5.2.3)
call_user_func('MyClass::myCallbackMethod');

// Type 5: Relative static class method call (As of PHP 5.3.0)
class A {
public static function who() {
echo "A\n";
}
}

class B extends A {
public static function who() {
echo "B\n";
}
}

call_user_func(array('B', 'parent::who')); // A
?>

12.变量范围
变量的范围即它定义的上下文背景（也就是它的生效范围）。大部分的 PHP 变量只有一个单独的范围。这个单独的范围跨度同样包含了 include 和 require 引入的文件。例如：

这里变量 $a 将会在包含文件 b.inc 中生效。但是，在用户自定义函数中，一个局部函数范围将被引入。任何用于函数内部的变量按缺省情况将被限制在局部函数范围内。例如：

t();
?>
这个脚本不会有任何输出，因为 echo 语句引用了一个局部版本的变量 $a，而且在这个范围内，它并没有被赋值。你可能注意到 PHP 的全局变量和 C 语言有一点点不同，在 C 语言中，全局变量在函数中自动生效，除非被局部变量覆盖。这可能引起一些问题，有些人可能不小心就改变了一个全局变量。PHP 中全局变量在函数中使用时必须申明为global。

13.常量和变量有如下不同：

■常量前面没有美元符号（$）；
■常量只能用 define() 函数定义，而不能通过赋值语句；
■常量可以不用理会变量的作用域而在任何地方定义和访问；
■常量一旦定义就不能被重新定义或者取消定义；
■常量的值只能是标量。

14. PHP 支持一个错误控制运算符：@。当将其放置在一个 PHP 表达式之前，该表达式可能产生的任何错误信息都被忽略掉。

如果激活了 track_errors 特性，表达式所产生的任何错误信息都被存放在变量 $php_errormsg 中。此变量在每次出错时都会被覆盖，所以如果想用它的话就要尽早检查。

ile: error was '$php_errormsg'");

// this works for any expression, not just functions:
$value = @$cache[$key];
// will not issue a notice if the index $key doesn't exist.

?>

Note: @ 运算符只对表达式有效。对新手来说一个简单的规则就是：如果能从某处得到值，就能在它前面加上 @ 运算符。例如，可以把它放在变量，函数和 include() 调用，常量，等等之前。不能把它放在函数或类的定义之前，也不能用于条件结构例如 if 和 foreach 等。

15. instanceof 用于确定一个 PHP 变量是否属于某一类 class 的实例：

Example #1 instanceof 使用示例

上例将输出：

bool(true)
bool(false)

instanceof　也可用来确定一个变量是不是继承自某一父类的子类的实例

上例将输出：

bool(true)
bool(true)

16. 伪变量 $this 可以在当一个方法在对象内部调用时使用。$this 是一个到调用对象（通常是方法所属于的对象，但也可以是另一个对象，如果该方法是从第二个对象内静态调用的话）的引用。看下面例子：

Example #1 面向对象语言中的 $this 变量

"\$this is not defined.\n";
}
}
}

class B
{
function bar()
{
A::foo();
}
}

$a = new A();
$a->foo();
A::foo();
$b = new B();
$b->bar();
B::bar();
?>
上例将输出：

$this is defined (a)
$this is not defined.
$this is defined (b)
$this is not defined

17. 一个类可以在声明中用 extends 关键字继承另一个类的方法和成员。不能扩展多个类，只能继承一个基类。

被继承的方法和成员可以通过用同样的名字重新声明被覆盖，除非父类定义方法时使用了 final 关键字。可以通过 parent:: 来访问被覆盖的方法或成员。

Example #6 简单的类继承

"Extending class\n";
parent::displayVar();
}
}

$extended = new ExtendClass();
$extended->displayVar();
?>
上例将输出：

Extending class
a default value

18.自动加载对象
很多开发者写面向对象的应用程序时对每个类的定义建立一个 PHP 源文件。一个很大的烦恼是不得不在每个脚本（每个类一个文件）开头写一个长长的包含文件列表。

在 PHP 5 中，不再需要这样了。可以定义一个 __autoload 函数，它会在试图使用尚未被定义的类时自动调用。通过调用此函数，脚本引擎在 PHP 出错失败前有了最后一个机会加载所需的类。
Example #1 Autoload 例子

本例尝试分别从 MyClass1.php 和 MyClass2.php 文件中加载 MyClass1 和 MyClass2 类。

19.访问控制
对属性或方法的访问控制，是通过在前面添加关键字 public、protected 或 private 来实现的。由 public 所定义的类成员可以在任何地方被访问；由 protected 所定义的类成员则可以被其所在类的子类和父类访问（当然，该成员所在的类也可以访问）；而由 private 定义的类成员则只能被其所在类访问。

对类成员的访问控制
类成员都必须使用关键字public、protected 或 private 进行定义

Example #1 声明类成员

ass MyClass
{
public $public = 'Public';
protected $protected = 'Protected';
private $private = 'Private';

function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}

$obj = new MyClass();
echo $obj->public; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private

/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// 可以对 public 和 protected 进行重定义，但 private 而不能
protected $protected = 'Protected2';

function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}

$obj2 = new MyClass2();
echo $obj->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello() // 输出 Public、Protected2，但不会输出 Private

class Bar
{
public function test() {
$this->testPrivate();
$this->testPublic();
}

public function testPublic() {
echo "Bar::testPublic\n";
}

private function testPrivate() {
echo "Bar::testPrivate\n";
}
}

class Foo extends Bar
{
public function testPublic() {
echo "Foo::testPublic\n";
}

private function testPrivate() {
echo "Foo::testPrivate\n";
}
}

$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate
// Foo::testPublic
?>

20.Example #1 在类的外部使用 :: 操作符

self 和 parent 这两个特殊的关键字是用于在类的内部对成员或方法进行访问的。

Example #2 :: from inside the class definition

ss
{
public static $my_static = 'static var';

public static function doubleColon() {
echo parent::CONST_VALUE . "\n";
echo self::$my_static . "\n";
}
}

OtherClass::doubleColon();
?>
当一个子类覆盖其父类中的方法时，PHP 不会再执行父类中已被覆盖的方法，直到子类中调用这些方法为止。这种机制也作用于 构造函数和析构函数、重载 及 魔术 函数。

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

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

用::方式调用一个非静态方法会导致一个E_STRICT级别的错误。

就像其它所有的PHP静态变量一样，静态属性只能被初始化为一个字符值或一个常量，不能使用表达式。 所以你可以把静态属性初始化为整型或数组，但不能指向另一个变量或函数返回值，也不能指向一个对象。

PHP5.3.0之后，我们可以用一个变量来动态调用类。但该变量的值不能为关键字self, parent 或static。

Example #1 静态成员代码示例

o = new Foo();
print $foo->staticValue() . "\n";
print $foo->my_static . "\n"; // Undefined "Property" my_static

print $foo::$my_static . "\n";
$classname = 'Foo';
print $classname::$my_static . "\n"; // PHP 5.3.0之后可以动态调用

print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";
?>
Example #2 静态方法代码示例

22. 对象复制
在多数情况下，我们并不需要完全复制一个对象来获得其中属性。但有一个情况下确实需要：如果你有一个 GTK窗口对象，该对象持有窗口相关的资源。你可能会想复制一个新的窗口，保持所有属性与原来的窗口相同， 但必须是一个新的对象（因为如果不是新的对象，那么一个窗口中的改变就会影响到另一个窗口）。还有一种情况： 如果对象A中保存着对象B的引用，当你复制对象A时，你想其中使用的对象不再是对象B而是B的一个副本，那么 你必须得到对象A的一个副本。

对象复制可以通过clone关键字来完成（如果对象中存在__clone()方法，会先被调用）。对象中的 __clone()方法不能直接调用。

$copy_of_object = clone $object;
当对象被复制后，PHP5会对对象的所有属性执行一个“浅复制”（shallow copy）。所有的属性中的引用 仍然不变，指向原来的变量。如果定义了__clone()方法，则新创建的对象（复制生成的对象）中的__clone()方法会被调用， 可用于修改属性的值（如果有必要的话）。

Example #1 复制一个对象

instance = ++self::$instances;
}

public function __clone() {
$this->instance = ++self::$instances;
}
}

class MyCloneable
{
public $object1;
public $object2;

function __clone()
{

// 强制复制一份this->object， 否则仍然指向同一个对象
$this->object1 = clone $this->object1;
}
}

$obj = new MyCloneable();

$obj->object1 = new SubObject();
$obj->object2 = new SubObject();

$obj2 = clone $obj;

print("Original Object:\n");
print_r($obj);

print("Cloned Object:\n");
print_r($obj2);

?>
以上例程会输出：

Original Object:
MyCloneable Object
(
[object1] => SubObject Object
(
[instance] => 1
)

[object2] => SubObject Object
(
[instance] => 2
)

)
Cloned Object:
MyCloneable Object
(
[object1] => SubObject Object
(
[instance] => 3
)

[object2] => SubObject Object
(
[instance] => 2
)

)

23. ”后期绑定“的意思是说，static::不再被解析为定义当前方法所在的类，而是在实际运行时计算的。也可以称之为”静态绑定“，因为它可以用于（但不限于）静态方法的调用。

self:: 的限制
使用self:: 或者 __CLASS__对当前类的静态引用，取决于定义当前方法所在的类：

Example #1 self:: 用法

ublic static function who() {
echo __CLASS__;
}
public static function test() {
self::who();
}
}

class B extends A {
public static function who() {
echo __CLASS__;
}
}

B::test();
?>
以上例程会输出：

A
后期静态绑定的用法
后期静态绑定试图通过引入一个关键字表示运行时最初调用的类来绕过限制。简单地说，这个关键字能够让你在上述例子中调用test()时引用的类是B而不是A。最终决定不引入新的关键字，而是使用已经预留的static关键字。

Example #2 static:: 简单用法

以上例程会输出：

B
Note:

static:: 在处理静态方法时与 $this 是不同的。 $this-> 会遵循继承规则，但是 static:: 不会。