本文目录一览:
- 1、php4与php5区别具体有哪些?
- 2、PHP里$_SERVER['HTTP_HOST']和$_SERVER['PHP_SELF']区别
- 3、请详细说明一下php5中的魔术方法
- 4、如何运用PHP函数array
- 5、PHP $this返回对象
- 6、php 中的魔术函数都有哪些?
php4与php5区别具体有哪些?
新的对象模式
PHP5 中的对象已经进行了较系统、较全面的调整,现在的样子可能看起来会有些类似于 Java。本小节着重讲述 PHP5 中新的对象模式,并举了一些较简易的例子来说明。就让本节成为你的 PHP5 之旅的一个新起点吧。:)
* 构造函数和析构函数
* 对象的引用
* 对象的克隆
* 对象中的私有、公共及受保护模式
* 接口 (Interfaces)
* 抽象类
* __call
* __set 和 __get
* 静态成员
构造函数和析构函数
在 PHP4 中,当函数与对象同名时,这个函数将成为该对象的构造函数,并且在 PHP4 中没有析构函数的概念。
在 PHP5 中,构造函数被统一命名为 __construct,并且引入了析构函数的概念,被统一命名为 __destruct。
例一:构造函数和析构函数
?php
class foo {
var $x;
function __construct($x) {
$this-x = $x;
}
function display() {
print($this-x);
}
function __destruct() {
print("bye bye");
}
}
$o1 = new foo(4);
$o1-display();
?
在上面的例子中,当你终止调用 foo 类的时候,其析构函数将会被调用,上例中会输出 “bye bye”。
对象的引用
众所周知,在PHP4 中,传递变量给一个函数或方法,实际是把这个变量做了一次复制,也就意味着你传给函数或方法的是这个变量的一个副本,除非你使用了引用符号 “” 来声明是要做一个引用,而不是一个 Copy。在 PHP5 中,对象总是以引用的形式存在的,对象中的赋值操作同样也都是一个引用操作。
例二:对象的引用
?php
class foo {
var $x;
function setX($x) {
$this-x = $x;
}
function getX() {
return $this-x;
}
}
$o1 = new foo;
$o1-setX(4);
$o2 = $o1;
$o1-setX(5);
if($o1-getX() == $o2-getX()) print("Oh my god!");
?
对象的克隆
如上所述,当一个对象始终以引用的形式来被调用时,如果我想得到该对象的一个副本,该怎么办呢?PHP5 提供了一个新的功能,就是对象的克隆,语法为 __clone。
例三:对象的克隆
?php
class foo {
var $x;
function setX($x) {
$this-x = $x;
}
function getX() {
return $this-x;
}
}
$o1 = new foo;
$o1-setX(4);
$o2 = $o1-__clone();
$o1-setX(5); if($o1-getX() != $o2-getX()) print("Copies are independant");
?
对象克隆的方法在其它很多应用程序语言中都是存在的,所以你不必担心它的稳定性。:)
对象中的私有、公共及保护模式
PHP4 中,一个对象的所有方法和变量都是公共的,这意味着你可以在一个对象的外部操作其中的任意一个变量和方法。PHP5 引入了三种新的用来控制这种存取权限的模式,它们是:公共的(Public)、受保护的(Protected)及私有的(Private)。
公共模式(Public):允许在对象外部进行操作控制。
私有模式(Private):只允许本对象内的方法对其进行操作控制。
受保护模式(Protected):允许本对象及其父对象对其进行操作控制。
例四: 对象中的私有、公共及受保护模式
?php
class foo {
private $x;
public function public_foo() {
print("I'm public");
}
protected function protected_foo() {
$this-private_foo(); //Ok because we are in the same class we can call private methods
print("I'm protected");
}
private function private_foo() {
$this-x = 3;
print("I'm private");
}
}
class foo2 extends foo {
public function display() {
$this-protected_foo();
$this-public_foo();
// $this-private_foo(); // Invalid! the function is private in the base class
}
} $x = new foo();
$x-public_foo();
//$x-protected_foo(); //Invalid cannot call protected methods outside the class and derived classes
//$x-private_foo(); //Invalid private methods can only be used inside the class $x2 = new foo2();
$x2-display();
?
提示:对象中的变量总是以私有形式存在的,直接操作一个对象中的变量不是一个好的面向对象编程的习惯,更好的办法是把你想要的变量交给一个对象的方法去处理。
接口 (Interfaces)
众所周知,PHP4 中的对象支持继承,要使一个对象成为另一个对象的派生类,你需要使用类似 “class foo extends parent” 的代码来控制。 PHP4 和 PHP5 中,一个对象都仅能继承一次,多重继承是不被支持的。不过,在 PHP5 中产生了一个新的名词:接口,接口是一个没有具体处理代码的特殊对象,它仅仅定义了一些方法的名称及参数,此后的对象就可以方便的使用 'implement' 关键字把需要的接口整合起来,然后再加入具体的执行代码。
例五:接口
?php
interface displayable {
function display();
}
interface printable {
function doprint();
}
class foo implements displayable,printable {
function display() {
// code
} function doprint() {
// code
}
}
?
这对提高代码的可读性及通俗性有很大的帮助,通过上面的例子可以看到,对象 foo 包含了 displayable 和 printable 两个接口,这时我们就可以清楚的知道,对象 foo 一定会有一个 display() 方法和一个 print() 方法,只需要去了解接口部分,你就可以轻易的操作该对象而不必去关心对象的内部是如何运作的。
抽象类
抽象类不能被实例化。
抽象类与其它类一样,允许定义变量及方法。
抽象类同样可以定义一个抽象的方法,抽象类的方法不会被执行,不过将有可能会在其派生类中执行。
例六:抽象类
?php
abstract class foo {
protected $x;
abstract function display();
function setX($x) {
$this-x = $x;
}
}
class foo2 extends foo {
function display() {
// Code
}
}
?
__call
PHP5 的对象新增了一个专用方法 __call(),这个方法用来监视一个对象中的其它方法。如果你试着调用一个对象中不存在的方法,__call 方法将会被自动调用。
例七:__call
?php
class foo {
function __call($name,$arguments) {
print("Did you call me? I'm $name!");
}
} $x = new foo();
$x-doStuff();
$x-fancy_stuff();
?
这个特殊的方法可以被用来实现“过载(overloading)”的动作,这样你就可以检查你的参数并且通过调用一个私有的方法来传递参数。
例八:使用 __call 实现“过载”动作
?php
class Magic {
function __call($name,$arguments) {
if($name=='foo') {
if(is_int($arguments[0])) $this-foo_for_int($arguments[0]);
if(is_string($arguments[0])) $this-foo_for_string($arguments[0]);
}
} private function foo_for_int($x) {
print("oh an int!");
} private function foo_for_string($x) {
print("oh a string!");
}
} $x = new Magic();
$x-foo(3);
$x-foo("3");
?
__set 和 __get
这是一个很棒的方法,__set 和 __get 方法可以用来捕获一个对象中不存在的变量和方法。
例九: __set 和 __get
?php
class foo {
function __set($name,$val) {
print("Hello, you tried to put $val in $name");
}
function __get($name) {
print("Hey you asked for $name");
}
}
$x = new foo();
$x-bar = 3;
print($x-winky_winky);
?
类型指示
在 PHP5 中,你可以在对象的方法中指明其参数必须为另一个对象的实例。
例十:类型指示
?php
class foo {
// code ...
}
class bar {
public function process_a_foo(foo $foo) {
// Some code
}
}
$b = new bar();
$f = new foo();
$b-process_a_foo($f);
?
可以看出,我们可以显性的在参数前指明一个对象的名称,PHP5 会识别出这个参数将会要是一个对象实例。
静态成员
静态成员和静态方法在面象对象编程的术语中被称作 “对象方法(class methods)” 和 “对象变量(class variables)”。
“对象方法” 在一个对象没有实例化前允许被调用。同样,“对象变量” 在一个对象没有实例化前可以被独立操作控制(不需要用一个对象的方法来控制)。
例十一:对象方法和对象变量
?php
class calculator {
static public $pi = 3.14151692;
static public function add($x,$y) {
return $x + $y;
}
}
$s = calculator::$pi;
$result = calculator::add(3,7);
print("$result");
?
异常处理
异常处理是公认的处理程序错误的理想方法,在 Java 及 C++ 中都有这个概念,我们欣喜的看到,在 PHP5 已经加入了这方面的应用。你可以尝试使用 “try” 和 “catch” 来控制程序的错误。
例十二:异常处理
?php
class foo {
function divide($x,$y) {
if($y==0) throw new Exception("cannot divide by zero");
return $x/$y;
}
}
$x = new foo();
try {
$x-divide(3,0);
} catch (Exception $e) {
echo $e-getMessage();
echo "n
n";
// Some catastrophic measure here
}
?
上例中,我们使用了 “try” 来执行花括号中的语句,当有错误发生的时候,代码会把错误交给 “catch” 子句来处理,在 “catch” 子句中,你需要指明要把错误交给某个对象处理,这样做可以使代码结构看起来更清晰,因为现在我们可以把所有的错误信息交给一个对象来处理。
自定义错误处理
你可以很方便的用自定义的处理错误的代码来控制你的程序中的意外。你仅仅需要从异常类中派生出一个自己的错误控制类,在你自己的错误控制类中,你需要有一个构造函数和一个 getMessage 方法,以下是一个例子。
例十三:自定义错误处理
?php
class WeirdProblem extends Exception {
private $data;
function WeirdProblem($data) {
parent::exception();
$this-data = $data;
}
function getMessage() {
return $this-data . " caused a weird exception!";
}
}
?
现在我们可以使用 “throw new WeirdProblem($foo)” 来抛出一个错误句柄,如果错误在 “try” 的代码块中发生,PHP5 会自动把错误交给 “catch” 部分来处理。
名称空间
名称空间对类的分组或函数分组很有用。它可以把一些相关的类或函数给组合到一起,方便以后调用。
例十四:名称空间
?php
namespace Math {
class Complex {
//...code...
function __construct() {
print("hey");
}
}
} $m = new Math::Complex();
?
注意你需要在何种情况下使用名称空间,在实际运用中,你可能会需要声明两个或多个名称一样的对象来做不同的事情,那么你就可以把他们分别放到不同的名称空间中去(但接口是要相同的)。
PHP里$_SERVER['HTTP_HOST']和$_SERVER['PHP_SELF']区别
两者的区别在于含义不同:
假如命令行的地址是:xxx
那么:$_SERVER['HTTP_HOST']==''$_SERVER['PHP_SELF']=='/index.php'所以前者是主机地址,后者是脚本文件的绝对路径。
扩展资料:
1、新对象模式
*构造函数和析构函数 * 对象的引用 * 对象的克隆 * 对象中的私有、公共及受保护模式 * 接口 (Interfaces)
* 抽象类 * __call * __set 和 __get * 静态成员
2、构造函数和析构函数
在 PHP4 中,当函数与对象同名时,这个函数将成为该对象的构造函数,并且在 PHP4 中没有析构函数的概念。
在 PHP5 中,构造函数被统一命名为 __construct,并且引入了析构函数的概念,被统一命名为 __destruct。
3、对象的引用
在PHP4中,传递变量给一个函数或方法,实际是把这个变量做了一次复制,也就意味着你传给函数或方法的是这个变量的一个副本,除非你使用了引用符号“;” 来声明是要做一个引用,而不是一个 Copy。在 PHP5中,对象总是以引用的形式存在的,对象中的赋值操作同样也都是一个引用操作。
4、对象的克隆
当一个对象始终以引用的形式来被调用时,如果我想得到该对象的一个副本,该怎么办呢?PHP5 提供了一个新的功能,就是对象的克隆,语法为 __clone。
5、抽象类
抽象类不能被实例化。
抽象类与其它类一样,允许定义变量及方法。
抽象类同样可以定义一个抽象的方法,抽象类的方法不会被执行,不过将有可能会在其派生类中执行。
6、__call
PHP5 的对象新增了一个专用方法 __call(),这个方法用来监视一个对象中的其它方法。如果你试着调用一个对象中不存在的方法,__call 方法将会被自动调用。
参考资料:百度百科——PHP
请详细说明一下php5中的魔术方法
PHP处理对象部分的内核完全重新开发过,提供更多功能的同时也提高了性能。在以前版本的php中,处理对象和处理基本类型(数字,字符串)的方式是一样的。这种方式的缺陷是:当将对象赋值给一个变量时,或者通过参数传递对象时,对象将被完全拷贝一份。在新的版本里,上述操作将传递引用(可以把引用理解成对象的标识符),而非值。
很多PHP程序员可能甚至没有察觉到老的对象处理方式。事实上,大多数的php应用都可以很好地运行。或者仅仅需要很少的改动。
私有和受保护成员
PHP5引入了私有和受保护成员变量的概念。我们可以用它来定义类成员的可见性。
例子
受保护成员可以被子类访问, 而私有成员只能被类本身访问。
代码:--------------------------------------------------------------------------------
?php
class MyClass {
private $Hello = "Hello, World!\n";
protected $Bar = "Hello, Foo!\n";
protected $Foo = "Hello, Bar!\n";
function printHello() {
print "MyClass::printHello() " . $this-Hello;
print "MyClass::printHello() " . $this-Bar;
print "MyClass::printHello() " . $this-Foo;
}
}
class MyClass2 extends MyClass {
protected $Foo;
function printHello() {
MyClass::printHello(); /* Should print */
print "MyClass2::printHello() " . $this-Hello; /* Shouldn't print out anything */
print "MyClass2::printHello() " . $this-Bar; /* Shouldn't print (not declared)*/
print "MyClass2::printHello() " . $this-Foo; /* Should print */
}
}
$obj = new MyClass();
print $obj-Hello; /* Shouldn't print out anything */
print $obj-Bar; /* Shouldn't print out anything */
print $obj-Foo; /* Shouldn't print out anything */
$obj-printHello(); /* Should print */
$obj = new MyClass2();
print $obj-Hello; /* Shouldn't print out anything */
print $obj-Bar; /* Shouldn't print out anything */
print $obj-Foo; /* Shouldn't print out anything */
$obj-printHello();
?
--------------------------------------------------------------------------------
私有方法和受保护方法
PHP5也引入了私有方法和受保护方法的概念。
例子:
代码:--------------------------------------------------------------------------------
?php
class Foo {
private function aPrivateMethod() {
echo "Foo::aPrivateMethod() called.\n";
}
protected function aProtectedMethod() {
echo "Foo::aProtectedMethod() called.\n";
$this-aPrivateMethod();
}
}
class Bar extends Foo {
public function aPublicMethod() {
echo "Bar::aPublicMethod() called.\n";
$this-aProtectedMethod();
}
}
$o = new Bar;
$o-aPublicMethod();
?
--------------------------------------------------------------------------------
以前的不使用类的老代码,没有访问修饰符(public, protected, private)的代码可以不经改动运行。
抽象类和抽象方法
Php5也引入了抽象类和抽象方法的概念。抽象方法只是声明了方法的签名并不提供它的实现。包含抽象方法的类必须被声明成抽象类。
例子:
代码:--------------------------------------------------------------------------------
?php
abstract class AbstractClass {
abstract public function test();
}
class ImplementedClass extends AbstractClass {
public function test() {
echo "ImplementedClass::test() called.\n";
}
}
$o = new ImplementedClass;
$o-test();
?
--------------------------------------------------------------------------------
抽象类不能被实例化。以前的不使用抽象类的老代码可以不经改动运行。
接口
Php5引入了接口。一个类可以实现多个接口。
例子:
代码:--------------------------------------------------------------------------------
?php
interface Throwable {
public function getMessage();
}
class MyException implements Throwable {
public function getMessage() {
// ...
}
}
?
--------------------------------------------------------------------------------
以前的不使用接口的老代码可以不经改动运行
类的型别提示
PHP5依然是弱类型的,不过在定义函数参数时,可以使用类的型别提示来声明期望传入的对象类型
Example
代码:--------------------------------------------------------------------------------
?php
interface Foo {
function a(Foo $foo);
}
interface Bar {
function b(Bar $bar);
}
class FooBar implements Foo, Bar {
function a(Foo $foo) {
// ...
}
function b(Bar $bar) {
// ...
}
}
$a = new FooBar;
$b = new FooBar;
$a-a($b);
$a-b($b);
?
--------------------------------------------------------------------------------
和其他强类型语言一样,php5类的型别提示在运行期间检查而非编译期间检查。即:
代码:--------------------------------------------------------------------------------
?php
function foo(ClassName $object) {
// ...
}
?
和下面的代码是一样的:
?php
function foo($object) {
if (!($object instanceof ClassName)) {
die("Argument 1 must be an instance of ClassName");
}
}
?
--------------------------------------------------------------------------------
这个语法只适用于类,不适用于内建类型。
Final
PHP 5 引入了final关键字来声明final成员和final方法。final成员和final方法不能被子类覆盖。
Example
代码:--------------------------------------------------------------------------------
?php
class Foo {
final function bar() {
// ...
}
}
?
--------------------------------------------------------------------------------
更进一步,可以把类声明成final。将类声明成final可以阻止这个类被继承。final类里面的方法缺省地都是final的,无需再声明一次。
Example
代码:--------------------------------------------------------------------------------
?php
final class Foo {
// class definition
}
// the next line is impossible
// class Bork extends Foo {}
?
--------------------------------------------------------------------------------
属性不能定义成为final.
以前的不使用final的老代码可以不经改动运行.
对象克隆
Php4没有提供一种机制来让用户自己定义复制构造子(copy constructor)控制对象的复制过程。Php4做二进制的拷贝,因而很精确地复制了对象的所有属性。
精确地复制对象的所有属性可能并不是我们一直想要的。有个例子可以很好地说明我们确实需要复制构造子:比如一个GTK Window的对象 a。 a持有它所需要的全部资源。当复制的这个GTK Window到对象b时候,我们更希望b持有新的资源对象。再举个例子:对象a包含了一个对象c, 当你把对象a 复制到对象c的时候。我们可能更希望对象b包含一个新的对象c的copy, 而不是一个对象c的引用。(译者注:这里所说的就是浅克隆和深克隆。)
对象的复制是通过clone这个关键字达到的(Clone调用被克隆对象的__clone()方法)。对象的__clone方法不能够直接被调用。
代码:--------------------------------------------------------------------------------
?php
$copy_of_object = clone $object;
?
--------------------------------------------------------------------------------
当developer创建对象的一份拷贝的时候,php5将会检查 __clone()方法是否存在。如果不存在,那么它就会呼叫缺省的__clone()方法,复制对象的所有属性。如果__clone()方法已经定义过,那么_clone()方法就会负责设置新对象的属性。为了方便起见,Engine会缺省地复制所有的属性。所以在__clone()方法中,只需要覆盖那些需要更改的属性就可以了。如下:
Example
代码:--------------------------------------------------------------------------------
?php
class MyCloneable {
static $id = 0;
function MyCloneable() {
$this-id = self::$id++;
}
function __clone() {
$this-address = "New York";
$this-id = self::$id++;
}
}
$obj = new MyCloneable();
$obj-name = "Hello";
$obj-address = "Tel-Aviv";
print $obj-id . "\n";
$obj_cloned = clone $obj;
print $obj_cloned-id . "\n";
print $obj_cloned-name . "\n";
print $obj_cloned-address . "\n";
?
--------------------------------------------------------------------------------
统一构造函数
Php5允许开发者声明一个类的构造方法。拥有构造方法的类在每次创建新的对象的时候都会呼叫这个方法,因此构造方法适合对象在被使用之前的初始化工作
Php4中,构造方法的名称和类的名称一样。考虑到从子类构造方法呼叫父类构造方法的情况是非常普遍的,而将类从一个继承体系中搬迁引起的父类变更就常常导致需要更改类的构造方法,php4的做法显然是不太合理的。
Php5引入了一个声明构建函数的标准方法: __construct().如下:
Example
代码:--------------------------------------------------------------------------------
?php
class BaseClass {
function __construct() {
print "In BaseClass constructor\n";
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct();
print "In SubClass constructor\n";
}
}
$obj = new BaseClass();
$obj = new SubClass();
?
--------------------------------------------------------------------------------
为保持向后的兼容性,如果php5不能够找到 __construct(),它会寻找老式的构造方法,即与类同名的方法。简单的说,只有当老代码里包含了一个__construct()方法的时候,才存在一个兼容性的问题。
析构方法
对于面向对象的编程来说,可以定义析构方法是非常有用的一个功能。析构方法可以用来记录调试信息,关闭数据库连接等等一些清除收尾的工作。Php4中没有析构方法,尽管php4已经支持可以注册一个函数以便请求结束的时候被调用。
Php5引进的析构方法的概念和其他面向对象的语言(比如java)是一致的。当指向这个对象的最后一个引用被销毁的时候,析构方法被调用,调用完成后释放内存。注意:析构方法不接受任何参数。
Example
代码:--------------------------------------------------------------------------------
?php
class MyDestructableClass {
function __construct() {
print "In constructor\n";
$this-name = "MyDestructableClass";
}
function __destruct() {
print "Destroying " . $this-name . "\n";
}
}
$obj = new MyDestructableClass();
?
--------------------------------------------------------------------------------
和构建方法一样,父类的析构方法也不会被隐含调用。子类可以在自己的析构方法通过调用parent::__destruct()来显式地调用它。
Constants
Php5引入了class级别的常量。
代码:--------------------------------------------------------------------------------
?php
class Foo {
const constant = "constant";
}
echo "Foo::constant = " . Foo::constant . "\n";
?
--------------------------------------------------------------------------------
老的没有使用const的代码仍然正常运行。
Exceptions
Php4没有异常控制。Php5引入了和其它语言(java)相似的异常控制模式。应该注意的是php5里面支持捕捉全部异常,但是不支持finally子句。
在catch语句块里面,可以重新抛出异常。也可以有多个catch语句,在这种情况下,被捕捉到的异常从上往下依次比较和catch语句比较异常,第一个类型匹配的catch语句将会被执行。如果一直搜索到底还没有发现匹配的catch子句,则寻找下一个try/catch语句。最后不能捕捉的异常将被显示出来。如果异常被捕捉,那么程序会接着catch语句块的下面开始执行。
Example
代码:--------------------------------------------------------------------------------
?php
class MyException {
function __construct($exception) {
$this-exception = $exception;
}
function Display() {
print "MyException: $this-exception\n";
}
}
class MyExceptionFoo extends MyException {
function __construct($exception) {
$this-exception = $exception;
}
function Display() {
print "MyException: $this-exception\n";
}
}
try {
throw new MyExceptionFoo('Hello');
}
catch (MyException $exception) {
$exception-Display();
}
catch (Exception $exception) {
echo $exception;
}
?
--------------------------------------------------------------------------------
上面的例子表明可以定义一个并不继承自 Exception的异常类,但是,最好还是从Exception继承并定义自己的异常。这是因为系统内建的Exception类能够收集到很多有用的信息, 而不继承它的异常类是得不到这些信息的。下面的php代码模仿了系统内建Exception类。每个属性后面都加了注释。每个属性都有一个getter,由于这些getter方法经常被系统内部处理调用,所以这些方法被标明了final。
Example
代码:--------------------------------------------------------------------------------
?php
class Exception {
function __construct(string $message=NULL, int code=0) {
if (func_num_args()) {
$this-message = $message;
}
$this-code = $code;
$this-file = __FILE__; // of throw clause
$this-line = __LINE__; // of throw clause
$this-trace = debug_backtrace();
$this-string = StringFormat($this);
}
protected $message = 'Unknown exception'; // exception message
protected $code = 0; // user defined exception code
protected $file; // source filename of exception
protected $line; // source line of exception
private $trace; // backtrace of exception
private $string; // internal only!!
final function getMessage() {
return $this-message;
}
final function getCode() {
return $this-code;
}
final function getFile() {
return $this-file;
}
final function getTrace() {
return $this-trace;
}
final function getTraceAsString() {
return self::TraceFormat($this);
}
function _toString() {
return $this-string;
}
static private function StringFormat(Exception $exception) {
// ... a function not available in PHP scripts
// that returns all relevant information as a string
}
static private function TraceFormat(Exception $exception) {
// ... a function not available in PHP scripts
// that returns the backtrace as a string
}
}
?
--------------------------------------------------------------------------------
如果我们定义的一异常类都是继承自Exception基类
无兼容性问题。老的代码不会受到这一特性的影响。
Dereferencing objects returned from functions
Php4中不能再次引用函数返回的对象以进一步呼叫返回对象的方法,而php5是可以的。
代码:--------------------------------------------------------------------------------
?php
class Circle {
function draw() {
print "Circle\n";
}
}
class Square {
function draw() {
print "Square\n";
}
}
function ShapeFactoryMethod($shape) {
switch ($shape) {
case "Circle":
return new Circle();
case "Square":
return new Square();
}
}
ShapeFactoryMethod("Circle")-draw();
ShapeFactoryMethod("Square")-draw();
?
--------------------------------------------------------------------------------
静态成员变量能够被初始化。
Example
代码:--------------------------------------------------------------------------------
?php
class foo {
static $my_static = 5;
public $my_prop = 'bla';
}
print foo::$my_static;
$obj = new foo;
print $obj-my_prop;
?
--------------------------------------------------------------------------------
静态方法
PHP 5 引入了静态方法,可以在不实例化类的情况下呼叫静态方法。
Example
代码:--------------------------------------------------------------------------------
?php
class Foo {
public static function aStaticMethod() {
// ...
}
}
Foo::aStaticMethod();
?
--------------------------------------------------------------------------------
伪变量$this不能够在静态方法方法中使用。
instanceof
Php5引入了instanceof关键字,允许用它来测试一个对象是一个类的实例,或者是一个派生类的实例,或者实现了某个接口
Example
代码:--------------------------------------------------------------------------------
?php
class baseClass { }
$a = new baseClass;
if ($a instanceof baseClass) {
echo "Hello World";
}
?
--------------------------------------------------------------------------------
Static function variables
现在,静态变量在编译阶段处理。因此程序员可以通过引用为静态变量赋值。这可以改善性能,不过,不能够使用对静态变量的间接引用了。
按引用传递的函数参数现在也可以设置缺省值了。
Example
代码:--------------------------------------------------------------------------------
?php
function my_function($var = null) {
if ($var === null) {
die("$var needs to have a value");
}
}
?
--------------------------------------------------------------------------------
__autoload()
__autoload() 拦截函数在一个未声明的类被初始化的时候自动调用。该类的名字会被自动传递给__autoload()函数。而__autoload()也只有这么唯一的一个参数。
Example
代码:--------------------------------------------------------------------------------
?php
function __autoload($className) {
include_once $className . ".php";
}
$object = new ClassName;
?
--------------------------------------------------------------------------------
可重载的方法呼叫和属性访问
方法呼叫和属性访问都能够通过__call, __get() and __set()方法重载。
Example: __get() and __set()
代码:--------------------------------------------------------------------------------
?php
class Setter {
public $n;
public $x = array("a" = 1, "b" = 2, "c" = 3);
function __get($nm) {
print "Getting [$nm]\n";
if (isset($this-x[$nm])) {
$r = $this-x[$nm];
print "Returning: $r\n";
return $r;
} else {
print "Nothing!\n";
}
}
function __set($nm, $val) {
print "Setting [$nm] to $val\n";
if (isset($this-x[$nm])) {
$this-x[$nm] = $val;
print "OK!\n";
} else {
print "Not OK!\n";
}
}
}
$foo = new Setter();
$foo-n = 1;
$foo-a = 100;
$foo-a++;
$foo-z++;
var_dump($foo);
?
--------------------------------------------------------------------------------
Example: __call()
代码:--------------------------------------------------------------------------------
?php
class Caller {
private $x = array(1, 2, 3);
function __call($m, $a) {
print "Method $m called:\n";
var_dump($a);
return $this-x;
}
}
$foo = new Caller();
$a = $foo-test(1, "2", 3.4, true);
var_dump($a);
?
--------------------------------------------------------------------------------
迭代
当和foreach一起使用对象的时候,迭代的方式被重载过了。缺省的行为是迭代类的所有属性。
Example
代码:--------------------------------------------------------------------------------
?php
class Foo {
public $x = 1;
public $y = 2;
}
$obj = new Foo;
foreach ($obj as $prp_name = $prop_value) {
// using the property
}
?
--------------------------------------------------------------------------------
一个类的所有对象都能够被迭代浏览到, 如果这个类实现了一个空的接口:Traversable. 换句话说,实现了Traversable接口的类可以和foreach一起使用。
接口 IteratorAggregate 和Iterator允许指定类的对象在代码中如何迭代。IteratorAggregate接口有一个方法:getIterator() 必须返回一个数组
Example
代码:--------------------------------------------------------------------------------
?php
class ObjectIterator implements Iterator {
private $obj;
private $num;
function __construct($obj) {
$this-obj = $obj;
}
function rewind() {
$this-num = 0;
}
function valid() {
return $this-num $this-obj-max;
}
function key() {
return $this-num;
}
function current() {
switch($this-num) {
case 0: return "1st";
case 1: return "2nd";
case 2: return "3rd";
default: return $this-num."th";
}
}
function next() {
$this-num++;
}
}
class Object implements IteratorAggregate {
public $max = 3;
function getIterator() {
return new ObjectIterator($this);
}
}
$obj = new Object;
// this foreach ...
foreach($obj as $key = $val) {
echo "$key = $val\n";
}
// matches the following 7 lines with the for directive.
$it = $obj-getIterator();
for($it-rewind(); $it-hasMore(); $it-next) {
$key = $it-current();
$val = $it-key();
echo "$key = $val\n";
}
unset($it);
?
--------------------------------------------------------------------------------
新的__toString方法
可以通过覆盖__toString方法来控制对象到字符串的转换。
Example
代码:---------------------------------------
如何运用PHP函数array
PHP有一个系统函数is_array()可以判断一个值是否在数组中。
语法如下:
in_array(value,array,type)
return boolen
参数说明:
value :要搜索的值
array : 被搜索的数组
type : 类型,true全等 ,false非全等(默认)
示例一:普通使用
代码:
$str = 1;
$arr = array(1,3,5,7,9);
$boolvalue = in_array($str,$arr);
var_dump($boolvalue);
执行结果:
bool(true)
实例二:使用第三个参数
非全等
代码:
$str = '1';
$arr = array(1,3,5,7,9);
$boolvalue = in_array($str,$arr,false);
var_dump($boolvalue);
执行结果:
bool(true)
全等
代码:
$str = '1';
$arr = array(1,3,5,7,9);
$boolvalue = in_array($str,$arr,true);
var_dump($boolvalue);
执行结果:
bool(false)
实例三:克隆对象
代码:
class a {
public $a = 1;
public function fun(){
return $this-a;
}
}
class b {
public $a = 2;
public function fun(){
return $this-a;
}
}
$a = new a();
$b = new b();
$c = clone $a;
$arr = array($a,$b);
$boolvalue = in_array($c,$arr,false);
var_dump($boolvalue);
执行结果:
bool(true)
代码:
class a {
public $a = 1;
public function fun(){
return $this-a;
}
}
class b {
public $a = 2;
public function fun(){
return $this-a;
}
}
$a = new a();
$b = new b();
$c = clone $a;
$arr = array($a,$b);
$boolvalue = in_array($c,$arr,true);
var_dump($boolvalue);
执行结果:
bool(false)
示例四:多维数组
代码:
$str = 10;
$arr = array(
array(1,2,3,4),
array(5,6,7,8,9),
10
);
$boolvalue = in_array($str,$arr);
var_dump($boolvalue);
执行结果:
bool(true)
代码:
$str = 10;
$arr = array(
array(1,2,3,4),
array(5,6,7,8,9,10),
);
$boolvalue = in_array($str,$arr);
var_dump($boolvalue);
执行结果:
bool(false)
PHP $this返回对象
$this 就是”指这“的意思, 比方说你有个类叫“aaa”
当你实例化aaa这个类 $a = new aaa(); 之后 $this 就是指向 $a 对象。
this就是指向当前对象实例的指针,不指向任何其他对象或类。
至于什么情况下要用return $this,应该没有这样, 我只知道有一些地方会用到$this取该对象的地址然后进行对象复制。 具体你可以去看下dedecms的mysql类,我记得那里面对数据的操作就是这样用的。
php 中的魔术函数都有哪些?
魔术函数1。__construct()
实例化对象时被调用,
当__construct和以类名为函数名的函数同时存在时,__construct将被调用,另一个不被调用。2。__destruct()
当删除一个对象或对象操作终止时被调用。3。__call()
对象调用某个方法,
若方法存在,则直接调用;
若不存在,则会去调用__call函数。4。__get()
读取一个对象的属性时,
若属性存在,则直接返回属性值;
若不存在,则会调用__get函数。5。__set()
设置一个对象的属性时,
若属性存在,则直接赋值;
若不存在,则会调用__set函数。6。__toString()
打印一个对象的时被调用。如echo $obj;或print $obj;7。__clone()
克隆对象时被调用。如:$t=new Test();$t1=clone $t;8。__sleep()
serialize之前被调用。若对象比较大,想删减一点东东再序列化,可考虑一下此函数。9。__wakeup()
unserialize时被调用,做些对象的初始化工作。10。__isset()
检测一个对象的属性是否存在时被调用。如:isset($c-name)。11。__unset()
unset一个对象的属性时被调用。如:unset($c-name)。12。__set_state()
调用var_export时,被调用。用__set_state的返回值做为var_export的返回值。13。__autoload()
实例化一个对象时,如果对应的类不存在,则该方法被调用。魔术常量1。__LINE__
返回文件中的当前行号。2。__FILE__
返回文件的完整路径和文件名。如果用在包含文件中,则返回包含文件名。自 PHP 4.0.2 起,__FILE__ 总是包含一个绝对路径,而在此之前的版本有时会包含一个相对路径。3。__FUNCTION__
返回函数名称(PHP 4.3.0 新加)。自 PHP 5 起本常量返回该函数被定义时的名字(区分大小写)。在 PHP 4 中该值总是小写字母的。4。__CLASS__
返回类的名称(PHP 4.3.0 新加)。自 PHP 5 起本常量返回该类被定义时的名字(区分大小写)。在 PHP 4 中该值总是小写字母的。5。__METHOD__
返回类的方法名(PHP 5.0.0 新加)。返回该方法被定义时的名字(区分大小写)。
(1)初识魔术方法
Php5.0发布以来为我们提供了很多面向对象的特性,尤其是为我们提供了好多易用的魔术方法,这些魔术方法可以让我们简化我们的编码,更好的设计我们的系统。今天我们就来认识下php5.0给我们提供的魔术方法。