第一章（英文版）

What Is New in PHP 5?
“The best way to be ready for the future is to invent it.”― John Sculley
NTRODUCTION
1.1 I
Only time will tell if the PHP 5 release will be as successful as its two prede-
cessors (PHP 3 and PHP 4). The new features and changes aim to rid PHP of
any weaknesses it may have had and make sure that it stays in the lead as the
world’s best web-scripting language.
This book details PHP 5 and its new features. However, if you are familiar
with PHP 4 and are eager to know what is new in PHP 5, this chapter is for you.
When you finish reading this chapter, you will have learned
The new language features
?
News concerning PHP extensions
?
? Other noteworthy changes to PHP’s latest version
1.2 L  F
ANGUAGE EATURES
1.2.1 New Object-Oriented Model
When Zeev Suraski added the object-oriented syntax back in the days of PHP
3, it was added as “syntactic sugar for accessing collections.” The OO model
also had support for inheritance and allowed a class (and object) to aggregate
both methods and properties, but not much more. When Zeev and Andi Gut-
mans rewrote the scripting engine for PHP 4, it was a completely new engine;
it ran much faster, was more stable, and boasted more features. However, the
OO model first introduced in PHP 3 was barely touched.
Although the object model had serious limitations, it was used exten-
sively around the world, often in large PHP applications. This impressive use
of the OOP paradigm with PHP 4, despite its weaknesses, led to it being the
main focus for the PHP 5 release.
1

                     
Gutmans_Ch01  Page 2  Thursday, September 23, 2004  2:35 PM
2  What Is New in PHP 5?  Chap. 1
So, what were some of the limitations in PHP 3 and 4? The biggest limi-
tation (which led to further limitations) was the fact that the copy semantics of
objects were the same as for native types. So, how did this actually affect the
PHP developer? When  assigning a variable (that points to an object) to
another variable, a copy of the object would be created. Not only did this
impact performance, but it also usually led to obscure behavior and bugs in
PHP 4 applications because many developers thought that both variables
would point at the same object, which was not the case. The variables were
instead pointing at separate copies of the same object. Changing one would
not change the other.
For example:
class Person {
    var $name;
    function getName()
{
        return $this->name;
    }
    function setName($name)
{
        $this->name = $name;
    }
    function Person($name)
{
        $this->setName($name);
    }
}
function changeName($person, $name)
{
    $person->setName($name);
}
$person = new Person("Andi");
changeName($person, "Stig");
print $person->getName();
In PHP 4, this code would print out  . The reason is that we pass
"Andi"
to the   function by-value, and thus,   is
the object
$person changeName() $person
copied and   works on a copy of  .
changeName() $person
This behavior is not intuitive, as many developers would expect the Java-
like behavior. In Java, variables actually hold a handle (or pointer) to the
object, and therefore, when it is copied, only the handle (and not the entire
object) is duplicated.
There were two kinds of users in PHP 4: the ones who were aware of this
problem and the ones who were not. The latter would usually not notice this
problem and their code was written in a way where it did not really matter if
the problem existed. Surely some of these people had sleepless nights trying to
track down weird bugs that they could not pinpoint. The former group dealt
with this problem by always passing and assigning objects by reference. This
would prevent the engine from copying their objects, but it would be a head-
ache because the code included numerous
signs.
&

  
                              
Gutmans_Ch01  Page 3  Thursday, September 23, 2004  2:35 PM
1.2  Language Features 3
The old object model not only led to the afore-mentioned problems, but
also to fundamental problems that prevented implementing some additional
features on top of the existing object model.
In PHP 5, the infrastructure of the object model was rewritten to work
with object handles. Unless you explicitly clone an object by using the
clone
keyword, you never create behind-the-scenes duplicates of your objects. In
PHP 5, you don’t need a need to pass objects by reference or assign them by
reference.
Note: Passing by reference and assigning by reference are still sup-
ported, in case you want to actually change a variable’s content (whether
object or other type).
1.2.2 New Object-Oriented Features
The new OO features are too numerous to give a detailed description in this
section. Chapter 3, “PHP 5 OO Language,” details each feature.
The following list provides the main new features:
?
public/private/protected access modifiers for methods and properties.
Allows the use of common OO access modifiers to control access to
methods and properties:
class MyClass {
    private $id = 18;
    public function getId() {
        return $this->id;
   }
}
?
Unified constructor name __construct().
Instead of the constructor being the name of the class, it is now declared
__construct(), which makes it easier to shift classes inside class hier-
as
archies:
class MyClass {
     function __construct() {
        print "Inside constructor";
    }
}
Object destructor support by defining a __destructor() method.
?
Allows defining a destructor function that runs when an object
is destroyed:
class MyClass {
    function __destruct() {
        print ”Destroying object”;
    }
}

                             
Gutmans_Ch01  Page 4  Thursday, September 23, 2004  2:35 PM
4  What Is New in PHP 5?  Chap. 1
Interfaces.
?
Gives the ability for a class to fulfill more than one is-a relationships. A class can
inherit only from one class, but may implement as many interfaces as it wants:
interface Display {
    function display();
}
class Circle implements Display {
    function display() {
        print "Displaying circle\n";
    }
}
?
instanceof operator.
Language-level support for is-a relationship checking. The PHP 4   function
is_a()
is now deprecated:
if ($obj instanceof Circle) {
    print '$obj is a Circle';
}
?
Final methods.
final
The   keyword allows you to mark methods so that an inheriting class cannot overload
them:
class MyClass {
    final function getBaseClassName() {
        return __CLASS__;
    }
}
?
Final classes.
After declaring a class as
, it cannot be inherited. The following example
final
would error out.
final class FinalClass {
}
class BogusClass extends FinalClass {
}
Explicit object cloning.
?
To clone an object, you must use the clone __clone()
keyword. You may declare a
method, which will be called during the clone process (after the properties have
been copied from the original object):

                 
Gutmans_Ch01  Page 5  Thursday, September 23, 2004  2:35 PM
1.2  Language Features 5
class MyClass {
    function __clone() {
         print "Object is being cloned";
    }
}
$obj = new MyClass();
$obj_copy = clone $obj;
?
Class constants.
Class definitions can now include constant values and are referenced
using the class:
class MyClass {
     const SUCCESS = "Success";
     const FAILURE = "Failure";
}
print MyClass::SUCCESS;
?
Static methods.
You can now define methods as static by allowing them to be called from
variable
non-object context. Static methods do not define the
$this
because they are not bound to any specific object:
class MyClass {
    static function helloWorld() {
        print "Hello, world";
    }
}
MyClass::helloWorld();
Static members.
?
Class definitions can now include static members (properties) that are
accessible via the class. Common usage of static members is in the
pattern:
Singleton
class Singleton {
    static private $instance = NULL;
    private function __construct() {
    }
    static public function getInstance() {
        if (self::$instance == NULL) {
            self::$instance = new Singleton();
        }
        return self::$instance;
    }
}

                             
Gutmans_Ch01  Page 6  Thursday, September 23, 2004  2:35 PM
6  What Is New in PHP 5?  Chap. 1
Abstract classes.
?
A class may be declared   to prevent it from being instantiated.
abstract
However, you may inherit from an abstract class:
abstract class MyBaseClass {
    function display() {
        print "Default display routine being called";
    }
}
Abstract methods.
?
A method may be declared abstract, thereby deferring its definition to an
inheriting class. A class that includes abstract methods must be declared
:
abstract
abstract class MyBaseClass {
    abstract function display();
}
?
Class type hints.
Function declarations may include class type hints for their parameters.
If the functions are called with an incorrect class type, an error occurs:
function expectsMyClass(MyClass $obj) {
}
?
Support for dereferencing objects that are returned from methods.
In PHP 4, you could not directly dereference objects that were returned
from methods. You had to first assign the object to a dummy variable and
then dereference it.
PHP 4:
$dummy = $obj->method();
$dummy->method2();
PHP 5:
$obj->method()->method2();
?
Iterators.
PHP 5 allows both PHP classes and PHP extension classes to implement
Iterator interface. After you implement this interface, you can iterate
an
instances of the class by using the foreach() language
construct:
$obj = new MyIteratorImplementation();
foreach ($obj as $value) {
    print "$value";
}

                     
Gutmans_Ch01  Page 7  Thursday, September 23, 2004  2:35 PM
1.2  Language Features 7
For a more complete example, see Chapter 4, “PHP 5 Advanced OOP and
Design Patterns.”
__autoload().
?
Many developers writing object-oriented applications create one PHP
source file per class definition. One of the biggest annoyances is having to
write a long list of needed inclusions at the beginning of each script (one for
each class). In PHP 5, this is no longer necessary. You may define an
__autoload()
function that is automatically called in case you are trying to use
a class that has not been defined yet. By calling this function, the scripting
engine offers one last chance to load the class before PHP bails out with an
error:
function __autoload($class_name) {
    include_once($class_name . "php");
}
$obj = new MyClass1();
$obj2 = new MyClass2();
1.2.3 Other New Language Features
?
Exception handling.
PHP 5 adds the ability for the well-known   structured
try/throw/catch
exception-handling paradigm. You are only allowed to throw objects that
class:
inherit from the
Exception
class SQLException extends Exception {
    public $problem;
    function __construct($problem) {
        $this->problem = $problem;
    }
}
try {
    ...
    throw new SQLException("Couldn't connect to database");
    ...
} catch (SQLException $e) {
    print "Caught an SQLException with problem $obj->problem";
} catch (Exception $e) {
    print "Caught unrecognized exception";
}
Currently for backward-compatibility purposes, most internal functions
do not throw exceptions. However, new extensions make use of this capability,
and you can use it in your own source code. Also, similar to the already exist-
ing
, you may use   to catch an
set_error_handler() set_exception_handler()
unhandled exception before the script terminates.

Gutmans_Ch01  Page 8  Thursday, September 23, 2004  2:35 PM
8  What Is New in PHP 5?  Chap. 1
? foreach with references.
In PHP 4, you could not iterate through an array and modify its values.
PHP 5 supports this by enabling you to mark the foreach() loop with the
& (reference) sign, which makes any values you change affect the array
over which you are iterating:
foreach ($array as &$value) {
    if ($value === "NULL") {
        $value = NULL;
    }
}
? Default values for by-reference parameters.
In PHP 4, default values could be given only to parameters, which are
passed by-values. PHP 5 now supports giving default values to by-
reference parameters:
function my_func(&$arg = null) {
    if ($arg === NULL) {
        print '$arg is empty';
    }
}
my_func();
1.3 GENERAL PHP CHANGES
1.3.1 XML and Web Services
Following the changes in the language, the XML updates in PHP 5 are proba-
bly the most significant and exciting. The enhanced XML functionality in PHP
5 puts it on par with other web technologies in some areas and overtakes them
in others.
1.3.1.1 The Foundation XML support in PHP 4 was implemented using a
variety of underlying XML libraries. SAX support was implemented using the
old Expat library, XSLT was implemented using the Sablotron library (or using
libxml2 via the DOM extension), and DOM was implemented using the more
powerful libxml2 library by the GNOME project.
Using a variety of libraries did not make PHP 4 excel when it came to
XML support. Maintenance was poor, new XML standards were not always
supported, performance was not as good as it could have been, and interopera-
bility between the various XML extensions did not exist.
In PHP 5, all XML extensions have been rewritten to use the superb
libxml2 XML toolkit (http://www.xmlsoft.org/). It is a feature-rich, highly main-
tained, and efficient implementation of the XML standards that brings cutting-
edge XML technology to PHP.

Gutmans_Ch01  Page 9  Thursday, September 23, 2004  2:35 PM
1.3  General PHP Changes 9
All the afore-mentioned extensions (SAX, DOM, and XSLT) now use
libxml2, including the new additional extensions SimpleXML and SOAP.
1.3.1.2 SAX As previously mentioned, the new SAX implementation has
switched from using Expat to libxml2. Although the new extension should be
compatible, some small subtle differences might exist. Developers who still
want to work with the Expat library can do so by configuring and building
PHP accordingly (which is not recommended).
1.3.1.3 DOM Although DOM support in PHP 4 was also based on the libxml2
library, it had bugs, memory leaks, and in many cases, the API was not W3C-
compliant. The DOM extension went through a thorough facelift for PHP 5. Not
only was the extension mostly rewritten, but now, it is also W3C-compliant. For
studlyCaps as described by the W3C standard,
example, function names now use
which makes it easier to read general W3C documentation and implement what
you have learned right away in PHP. In addition, the DOM extension now sup-
ports three kinds of schemas for XML validation: DTD, XML schema, and
RelaxNG.
As a result of these changes, PHP 4 code using DOM will not always run
in PHP 5. However, in most cases, adjusting the function names to the new
standard will probably do the trick.
1.3.1.4 XSLT In PHP 4, two extensions supported XSL Transformations: the
Sablotron extension and the XSLT support in the DOM extension. PHP 5 fea-
tures a new XSL extension and, as previously mentioned, it is based on the
libxml2 extension. As in PHP 5, the XSL Transformation does not take the
XSLT stylesheet as a parameter, but depends on the DOM extension to load it.
The stylesheet can be cached in memory and may be applied to many docu-
ments, which saves execution time.
1.3.1.5 SimpleXML When looking back in a year or two, it will be clear that
SimpleXML revolutionized the way PHP developers work with XML files.
Instead of having to deal with DOM or―even worse―SAX, SimpleXML repre-
sents your XML file as a native PHP object. You can read, write, or iterate over
your XML file with ease, accessing elements and attributes.
Consider the following XML file:
<clients>
<client>
    <name>John Doe</name>
    <account_number>87234838</account_number>
</client>
<client>
    <name>Janet Smith</name>
    <account_number>72384329</account_number>

Gutmans_Ch01  Page 10  Thursday, September 23, 2004  2:35 PM
10  What Is New in PHP 5?  Chap. 1
</client>
</clients>
The following code prints each client’s name and account number:
$clients = simplexml_load_file('clients.xml');
foreach ($clients->client as $client) {
    print "$client->name has account number $client
?>account_number\n";
}
It is obvious how simple SimpleXML really is.
In case you need to implement an advanced technique in your Sim-
pleXML object that is not supported in this lightweight extension, you can
convert it to a DOM tree by calling it dom_import_simplexml(), manipulate it in
DOM, and convert it to SimpleXML using simplexml_import_dom().
Thanks to both extensions using the same underlying XML library,
switching between them is now a reality.
1.3.1.6 SOAP PHP 4 lacked official native SOAP support. The most com-
monly used SOAP implementation was PEARs, but because it was imple-
mented entirely in PHP, it could not perform as well as a built-in C extension.
Other available C extensions never reached stability and wide adoption and,
therefore, were not included in the main PHP 5 distribution.
SOAP support in PHP 5 was completely rewritten as a C extension and,
although it was only completed at a very late stage in the beta process, it was
incorporated into the default distribution because of its thorough implementa-
tion of most of the SOAP standard.
The following calls SomeFunction() defined in a WSDL file:
$client = new SoapClient("some.wsdl");
$client->SomeFunction($a, $b, $c);
1.3.1.7 New MySQLi (MySQL Improved) Extension For PHP 5, MySQL AB
(http://www.mysql.com) has written a new MySQL extension that enables you
to take full advantage of the new functionality in MySQL 4.1 and later. As
opposed to the old MySQL extension, the new one gives you both a functional
and an OO interface so that you can choose what you prefer. New features sup-
ported by this extension include prepared statements and variable binding,
SSL and compressed connections, transaction control, replication support, and
more.
1.3.1.8 SQLite Extension Support for SQLite (http://www.sqlite.org) was
first introduced in the PHP 4.3.x series. It is an embedded SQL library that
does not require an SQL server, so it is suitable for applications that do not
require the scalability of SQL servers or, if you deploy at an ISP that does not

Gutmans_Ch01  Page 11  Thursday, September 23, 2004  2:35 PM
1.4  Other New Features in PHP 5 11
offer access to an SQL server. Contrary to what its name implies, SQLite has
many features and supports transactions, sub-selects, views, and large data-
base files. It is mentioned here as a PHP 5 feature because it was introduced
so late in the PHP 4 series, and because it takes advantage of PHP 5 by pro-
viding an OO interface and supporting iterators.
1.3.1.9 Tidy Extension PHP 5 includes support for the useful Tidy (http://
tidy.sf.net/) library. It enables PHP developers to parse, diagnose, clean, and
repair HTML documents. The Tidy extension supports both a functional and
an OO interface, and its API uses the PHP 5 exception mechanism.
1.3.1.10 Perl Extension Although not bundled in the default PHP 5 package,
the Perl extension allows you to call Perl scripts, use Perl objects, and use
other Perl functionality natively from within PHP. This new extension sits
within the PECL (PHP Extension Community Library) repository at http://
pecl.php.net/package/perl.
1.4 OTHER NEW FEATURES IN PHP 5
This section discusses new features introduced in PHP 5.
1.4.1 New Memory Manager
The Zend Engine features a new memory manager. The two main advantages
are better support for multi-threaded environments (allocations do not need to
perform any mutual exclusion locks), and after each request, freeing the allo-
cated memory blocks is more efficient. Because this is an underlying infra-
structure change, you will not notice it directly as the end user.
1.4.2 Dropped Support for Windows 95
Running PHP on the Windows 95 platform is not supported anymore due to
Windows 95 does not support the functionality that PHP uses. Because
Microsoft officially stopped supporting it in 2002, the PHP development com-
munity decided that dropping the support was a wise decision.
1.5 SUMMARY
You must surely be impressed by the amount of improvements in PHP 5. As
previously mentioned, this chapter does not cover all the improvements, but
only the main ones. Other improvements include additional features, many
bug fixes, and a much-improved infrastructure. The following chapters cover
PHP 5 and give you in-depth coverage of the named new features and others
that were not mentioned in this chapter.

[ 本帖最后由 laotan 于 2008-7-23 17:51 编辑 ]