Translation: Deep Space Author: Andi Gutmans, Stig Bakken, and Derick Rethans may not be reproduced without permission. Introduction [Ready]? New Object Oriented Model [New Object-Oriented Model]? New Object Oriented Features [New Object-Oriented Features]? Other New Language Features [Other New Language Features] General PHP Changes PHP Change Summary]? XML and Web Services [XML and Web Server]? New mysqli (MySQL IMPROVED) EXTENSION [new mysqli (improved mysql) extension]? SQLITE EXTENSION [SQLITE extension]? TIDY EXTENSION [TIDY extension]? Perl EXTENSION [Perl Extension]? Other New Things in PHP 5 [Other PHP5 New things] Summary [Summary]
The best way to prepare for the future is to create it. (John Sculley)
Introduction [Introduction]
Only time will tell if the PHP 5 release will be as successful as the releases of its two predecessors (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 Only the time can prove whether PHP5 is as successful as his two seniors (PHP3 and PHP4). The purpose of new language features and changes is to eliminate PHPs may have already have weaknesses, and confirm that it is the leading position in the world's best web scripting language. THIS BOOK COVERS PHP 5 and ITS New Features in Great Detail. However, for Those of You Familiar with PHP 4, And Are Eager to Know What Is New in PHP 5, The Chapter is for you. This book includes PHP5 and A detailed description of its new features. However, as a close friend of PHP4, you are eager to know which updates do this PHP5, then this chapter is prepared for you. THE Chapter Will Cover: This chapter will include:
The New Language Features [New Language Features] News Concerning PHP Extensions [About PHP Extensions] Other Noteworthy Changes [Other Changes "
Language Features [Language Features]
New Object Oriented Model [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 object-oriented 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 rewrote the scripting engine for PHP 4, it was a completely new engine, running much faster, much more stable and with many more features. However, the object-oriented model first introduced In PHP 3, WAS Barely Touch. When Zeev Suraski adds an object-oriented syntax during the PHP3, it is added as "Syntactic Sugar for Accessing Collection". The object-oriented model also supports inheritance and allows class (or object) aggregation methods and properties, but there is no more features. When Zeev and Andi rewrote the script engine, it is a complete new engine, run faster, more stable, and more features. However, the object-oriented model is first introduced in PHP3 for the first time, and it is very small. Although the object model had serious limitations it was used extensively around the world, often in very 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. Although, The object model has seriously limited it widely in the world - often is very large PHP application, but this impressive object-oriented program design example application and PHP4 disadvantages cause it to become a PHP5 release version. Main focus.
So what were some of the limitations in PHP 3 & 4? The biggest limitation (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 you'd assign a variable (that points to an object) to another variable, a copy of the object would be created. Not only did performance but it usually also lead to obscure behavior and bugs in PHP 4 applications because many developers this impact thought that both variables would be pointing at the same object which was not the case. They were pointing at separate copies of the same object, changing one would not change the other. so, where PHP3 & limitations of PHP4 in it? The biggest limitations (which leads to greater limitations), in fact the object's copy and the original object, so this actually affects the development of PHP. When you assign a variable (it point to an object) to another variable, a copy of this object will be created. Do this in PHP4 applications not only affect the implementation, but often cause fuzzy behavior and errors. Because many developers think that the two variables point to the same object (which is not the case). They points to two copies of this object, and change one of which does not change another one. For example [such as]: Class Person {var $ name; function getname () {Return $ this-> name;} function setName ($ this-> name = $ name;} Function Person ($ name) { $ this-> setname ($ name);}} Function ChangeName ($ Person, $ Name) {$ Person-> setName ($ name); "Andi"); "Andi"); ChangeName ($ Person, " Stig "); Print $ Person-> GetName ();
In PHP 4, this Piece of Code Would Print Out "Andi". The Reason Is That We Pass The Object $ Person To The Changename () Function By-Value, And Thus, $ Person Is Copied and ChangeName () Works on a Copy Of $ Person. In PHP4, this code will print "andi". The reason is that we pass the value to the function $ Person to the function CHANGENAME (), then a copy of the $ Person is created, and ChangeName () runs the copy of $ Person. This behavior is not very intuitive, as many developers would expect the Java-like behavior. In Java variables actually hold a handle (or pointers) to the object, and therefore, when it is copied only the handle and not the entire object is duplicated This behavior is not intuitive, and many developers have originally operated like Java. In Java, the variable actually maintains a handle (or claim indicator), so it is just as a handle instead of being copied out of the Are 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. Surely some of these people had sleepless nights trying if the problem existed or not to track down weird bugs which 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 would be quite a headache as the code included numerous '&' signs PHP4 has two different types of users, one knows this problem and the other is not known. The latter usually did not pay attention to this problem, whether this problem does not have much relationship with the code they write. Indeed, some people in this kind of person usually hunt through the inexplicable mistakes they can't determine all night. The past team usually handles this problem by registering this object. This will prevent the engine from creating a copy of the object, but a little headache is that the code contains numerous '&' labels.
The old object model not only led to the above-mentioned problems but also led to fundamental problems that prevented implementing some additional features on top of the existing object model. The old object model not only cause the problems mentioned above, but also hindered in This already existing object model implements some additional features. 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 will never create behind the scene duplicates of your objects. In PHP 5, there is neither a need TO Pass Objects by Reference Nor Assigning Them By Reference. In PHP5, the structure of the object model is rewritten to run in the object handle. Unless you use the Clone keyword to determine an object, you can't create a copy of the object at all. In PHP5, there is no need to pass references or reference objects for objects. Note: Passing by reference and assigning by reference is still supported, in case you want to action (Whather object (Whather Obit (WHETER OBJECT (). Note: Pass references and registration references are still supported, in case you want to change a variable Content (regardless of object or other type). New Object Oriented Features [New Object-Oriented Features]
The new object oriented features are too numerous to give a detailed description in this section. The object oriented language chapter goes over each feature in detail. The new object-oriented features too much, can not be detailed in this chapter, for Object Language Chapter will explain each characteristic. The Following Is A List of The Main New Features: The following is a list of the main new features:
1. Public / Private / Protected Access Modifiers for Methods and Properties1. Add public / private / protection access to methods and properties.
Allows The Use of Common OO Access Modifiers To Control Access To Methods and Properties. Allows the use of public object-oriented access to control methods and properties.
Class myclass {private $ ID = 18; public function getId () {return $ this-> id;}}
2. Unified constructor name __construct () 2. Unified constructor name: __construct ()
Instead of the constructor being the name of the class, it will shop now be declared as __construct (), MAKING IT Easier to Shift Classes Inside Class Hierarchies. Instead of using the class name as the name of the constructor, it should now be declared as __construct (), created it is easier than replacing classes at the level of the class. Class myclass {function __construct () {print "inside constructor";}}
3. Object Destructor Support by Defining A __Destructor () Method3. The object parses function is supported by the definition __destructor () method
Allows Defining A Destructor Function That Runs When An Object is destroyed. Allows a destructor to run when the object crashes.
Class myclass {function __destruct () {print "destroying object";}}?>
4. Interfaces4. Interface
Gives The Ability for a class to fulfill more Than One is-a rel - mailships. A class can inherit from One Class Only But May Implement As Many Interfaces as it wants. Give classes have more interrelationships. A class can only inherit from another class but can implement more you want.
Interface Display {Function Display ();} Class Circle Implements Display {Function Display () {print "displaying circle";}}
5. InstanceOf operator5. Instance operation
Language Level Support for Is-a Relationship CHECKING. The PHP 4 IS_A () Function is now DepRecated. Provides an IS-A language level check support, the IS_A () function in PHP4 is not approved.
IF ($ OBJ Instance of Circle) {Print '$ Obj IS A CIRCLE';
6. Final Methods6. Final method
The Final Keyword Allows You To Mark Methods So That An Inheriting Class CAN't Overload The Final Keyword Allows you to mark the method, so that inheritance classes cannot load them.
Class myclass {final function getBaseclassName () {return__class___;}}
7. Final Classes7. Final class
After Declaring a class as final, it can't be inherited. The Following Example Would Error Out: After declaring a final class, they cannot be inherited, the following example will generate errors:
Final Class FinalClass {} class bogusclass extends FinalClass {} 8. Explicit Object Cloning8. Clear object clone
In order to clone an object you have to use the clone keyword. You may declare a __clone () method which will be called during the clone process (after the properties have been copied from the original object). To copy an object you have to use Clone keyword. You can declare a __clone () method that it will execute when a class is copied (after the original object property is copied).
Class myclass {function __clone () {Print "Object is being cloned";}} $ obj = new myclass (); Clone $ OBJ;
9. Class Constants9.
Classes definitions can now include constant values, and is reference using the class. Class definitions now contain constant definitions and references them by classes.
Class myclass {const enough; const fiveure = "failure"; }print myclass :: sucps;
10. Static Members10. Static member
Classes Definitions CAN now include static members (Properties), Accessible Via the Class. Common usage of static membs IS in the singleton pattern. Class definitions now contain a definition of static members (attributes) and access them through classes. Typically static members are used for separate parts.
class Singleton {static private $ instance = NULL; private function __construct () {} static public function getInstance () {if (self :: $ instance == NULL) {self :: $ instance = new Singleton ();} return self :: $ installation;}}
11. static methods11. Static method
You can now define methods as static allowing the be called from non-object context. Static methods don't define the $ this variable as the aren't bound to any reference. You can now define a static method, and Called within the range without an object. The static method does not define $ this variables as limitations for other specific objects.
Class myclass {static function helloworld () {print "Hello, World";}} myclass :: helloWorld ();?> 12. Abstract classes12. Abstract class
A class May Be Declared AS ABSTRACT SO As To Prevent It from Being Instantiated. However, You May Inherit from an Abstract Class. Class You can use the Abstract declaration to prevent them from being instantiated. However, you can inherit an abstract class.
Abstract class mybaseclass {function display () {print "default display routine being"}}
13. Abstract methods13. Abstract method
A Method May Be Declared ABSTRACT, Thereby Deferring Its Definition To An Inheriting Class. A Class That Includes Abstract Methods Must Be Declared As Abstract. Method can use the Abstract declaration, so from one inheritance class continues their definition. A class If a abstract method must be declared with a Abstract.
Abstract class mybaseclass {abstract function display ();
14. Class Type Hints14. Class Type Tips
Function Declarations May Include Class Type Hint Thepe The AN INCORRECT CLASS TYPE AN Error OcCurs. Function declaration can contain class stars as their parameters, if a function is called by an erroneous class error.
Function EXPECTSMYCLASS (MyClass $ OBJ) {}
15. Support for Dereferencing Objects Which Are Returned from Methods. 15. Support from the method to return to non-related objects
In PHP 4, you could not directly dereference objects which are returned from methods. You would have to first assign the object to a dummy variable and then dereference it. In PHP4, objects you can not return directly from a process of resolution, You must register this object to an intermediate variable and parse it. PHP 4:
$ Dummy = $ OBJ-> Method (); $ dummy-> method2 ();
PHP 5:
$ Obj-> Method () -> Method2 ();
16. Iterators16. Iteration
PHP 5 allows both PHP classes and PHP extension classes to implement an Iterator interface. Once you implement this interface you will be able to iterate instances of the class by using the foreach () language construct. PHP5 allows PHP classes and PHP extension classes to implement a Iterative interface. Once you perform this interface, you will be able to instantiate this class by using the Foreach () language structure. $ obj = new myiteratorimplementation (); foreach ($ OBJ AS $ VALUE) {Print "$ value";
For a more completion example, please refer to the "Advanced OOP & Design Patterns" Chapter. View a more complete example, please review the "Advanced Object-Oriented and Design Model" chapter.
17. __autoload () 17. __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 includes at the beginning of each script (one for each class). In PHP 5, this is no longer necessary. you may define an __autoload () function which is automatically called in case you are trying to use a class which has not been defined yet. By calling this function the scripting engine is giving a last chance to load the class Before php bails out with an error. Many developers are writing a target application, rewarding each class in Russian PHP files, one of the biggest troubles is that every one of every script must write a very Long file contains a list (a class contains once). In PHP5, this needs to be done. You can define a __autoload () function, which will automatically call a class that has not been defined yet. By calling this function, the script engine will continue to read this class until PHP throws an error.
Function __autoload ($ Class_Name) {include_once ($ class_name. "php");} $ obj = new myclass1 (); $ obj2 = new myclass2 ();
Other New Language Features [Other New Language Features]
Exception Handling1. Exception Processing
PHP 5 adds the ability for the well known try / throw / catch structured exception handling paradigm. You are only allowed to throw objects which inherit from the Exception class. PHP5 added a well-known try / throw / catch exception handling system. Only you allow you to throw an object that inherits the class that appears. class SQLException extends Exception {public $ problem; function __construct ($ problem) {$ this-> problem = $ problem;}} try {... throw new SQLException ( "Could not connect to database"); ...} Catch (SQLEXCEPTION $ E) {Print "Caught An Sqlexception with Problem $ OBJ-> Problem";} catch (Exception $ E) {print "caught unrecognized exception"}
Currently for backwards compatibility purposes most internal functions do not throw exceptions. However, new extensions are making use of this capability and you can use it in your own source code. Also, similar to the already existing set_error_handler () you may use set_exception_handler () To catch an unhandled Exception Before The Script Terminates. Now, in order to be backward compatible, most internal functions do not throw an exception. However, in order to use these features, new extensions are being set, you can use them in your code. Moreover, with the existing set_error_handler (), you can use set_exception_handler () before the script is terminated to capture an unprocessed exception.
2. Foreach with references2. Foreach and reference
In PHP 4, you could not iterate through an array and modify its values. PHP 5 supports this by allowing you to mark the foreach () loop with the '&' (reference) sign, thus, making any values you change affect the array You're itrating over. In PHP4, you cannot iterate an array and change their value. PHP5 allows you to implement by using the '&' (reference) tagging for ", create any array you changed.
Foreach ($ Array As & $ VALUE) {IF ($ VALUE === "NULL") {$ value = null;}}
3. default values for by-reference parameters3. Default by reference parameters In PHP 4, default values could only be given to parameters which are passed by-value. Giving default values to by-reference parameters is now supported. In PHP4 In the middle, the parameters can only receive the default value by values. The value of a reference to the parameter is now worth supporting.
Function my_func (& $ arg = null) {IF ($ arg === null) {print '$ arg is empty';}} my_func ();
General PHP Changes [PHP Change Overview]
XML and Web Services [XML and Web Server]
Following the changes in the language, the XML updates in PHP 5 are most probably 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. As the language Changes, XML updates in PHP5 are approximately most important and exciting. The enhanced XML function in PHP5 is the same as other Web technology in the same field, and exceeds part of them.
The Foundation [Basics]
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. XML is supported by the underlying XML library in PHP4; SAX is supported by the old EXPAT library; XSLT is supported by the Sablotron library (or using libxml2 via DOM extension); while DOM is more powerful Ghome The project's libxml2 library is supported. 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 interoperability between the varies XML extensions DID NOT EXIST. Using this kind of library did not make PHP4 supported by others in XML. The maintenance is poor, the new XML standard is not always supported, the performance is not ideal, and there is no compatibility between these extensions. In PHP 5, all XML extensions have been rewritten to use the superb libxml2 XML toolkit (http://www.xmlsoft.org/). It is a very feature rich, highly maintained and efficient implementation of the XML standards bringing the cutting edge In PHP5, all XML extensions have been rewritten and use excellent libxml2 XML toolkit (http://www.xmlsoft.org/). It has a very rich feature. And highlands maintained and effectively realize the advantages of XML for PHP. All The Above Mentioned Extensions (SAX, DOM AND XSLT) No Use Libxml2 Including The New Additional Extensions Simplexml and SOAP. These extensions mentioned above (SAX, DOM and XSLT) are now using libxml2 - including new additional SIMPLEXML and SOAP. SAX
As mentioned, the new SAX implementation has switched from using Expat to libxml2. Although the new extension should be compatible there may be some small subtle differences. Developers who still want to work with the Expat library can do so by configuring and building PHP accordingly ( NOT Recommended. Lift it, the new SAX implementation has turned from Expat to libxml2. Although new extensions may have some subtle differences in compatibility. Developers can still support EXPAT extensions by configuring PHP (this is not recommended). DOM
Although DOM support in PHP 4 was also based on the libxml2 library, it was quite buggy, had memory leaks and the API in many cases was not W3C compliant. The DOM extension went through a thorough facelift for PHP 5. Not only was the extension mostly rewritten it is now also W3C complaint. for example, function names now use studlyCaps as described by the W3C standard making it easier for you to read general W3C documentation and implementing what you learnt, right away in PHP. in addition, the DOM extension NOW Supports Three Kinds of Schemas for XML Validation, DTD, XML Schema And Relaxng. Although DOM support is still libXML2 in PHP4, it is loophole, there is a memory vulnerability and because of a variety of reasons, the API is not comparable to W3C . The DOM extension has made a thorough improvement for PHP5, not only almost completely rewritten, but also the W3C recommendation. For example, the function name is now using StudlyCaps as a description through the W3C standard, making you easier to read the overall W3C documentation in PHP, and perform what you have learned. As A Result of these Changes PHP 4 CODE USING DOM WILL NOT ALWAYS RUN PHP 5. However, in Most Cases Adjusting The Function Names To The New Standard Will Probably Do The Trick. Code of DOM in PHP4 Will not always be available in PHP5. However, in most cases, the adjustment function name to a new standard may be a method.
Xslt
In PHP 4, there were two extensions that supported XSL Transformations. The first was using the Sablotron extension and the second was using the XSLT support in the DOM extension. In PHP 5, a new XSL extension was written and, as mentioned, 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 documents saving execution time in In PHP4, there are two extensions support XSL transformation. The first use of Sablotron extension and the second use XSLT support in the DOM extension. In PHP5, a new XSL extension is written, and it is based on libxml2 extension. Due to the PHP5, XSL conversion is not extracted as a parameter but rely on the DOM extension to read it, this style is stored in memory and applies to many documents to save execution time. Simplexml
Probably when looking back in a year or two it will be clear that SimpleXML has revolutionized the way PHP developers work with XML files. SimpleXML could really be called "XML for Dummies". Instead of having to deal with DOM or even worse SAX, SimpleXML REPRESENTS YOUR XML File As a Native PHP Object. You Can Read, Write or Ite Accations Elements and Attributes. Probably, reviewing the past two years, we will clearly know that Simplexml has reforming PHP developers Handling the way XML files. Simplexml is able to be true called "XML for Dummies". Instead of processing DOM or even worse SAX, SimpleXML will describe the XML file as a PHP object. You can read, write or use iterative convenient access elements and properties. Consider The Following XML File: Consider the following XML file:
Name>
Account_number>
Client>
Name>
Account_number>
Client>
Clients>
The following piece of code prints each client's name and account number: The following code printing each customer'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";} It's obvious how Simple Simplexml really is. This example shows how simple Simplexml is. And in case there is something advanced you need to do to your SimpleXML object which is not supported in this lightweight extension, you can convert it to a DOM tree by calling dom_import_simplexml (), manipulate it in DOM and covert it back to SimpleXML using Simplexml_import_dom (). Thanks to Both Extensions Using The Same Underlying XML Library Switch Between these Two Has Been Made a reality. In case you need some advanced features to use the SimpleXML object and it is not supported by this light level extension itself. You can convert it into a DOM tree by calling Dom_Import_SIMPLEXML (), use the DOM to use SimpleXML_IMPORT_DOM () to Simplexml. Thanks to the two extensions use the same underlying XML library, switching between them has been implemented. SOAP Official native SOAP support in PHP 4 was lacking. The most commonly used SOAP implementation was PEAR's but as it was implemented 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. Lacks formal SOAP support in PHP4. Generally use SOAP is supported through PEAR. However, using PHP is used as an implementation and cannot be as good as using built-in C. Other available C extensions cannot achieve a wide range of stability. Therefore, the primary configuration of PHP5 does not contain it.
(Phrase seems to have problems) 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 incooperated into the default distribution due to its thorough implementation of most Of The SOAP Standard. SOAP supports it in PHP5 as a C-extended rewrite, although it is only completed in later BETA versions. Since it is completely implemented, it has been added to the default configuration. The Following Calls SomeFunction () Defined IN A WSDL FILE: The following calls a SomeFunction defined in a WSDL file (): $ client = new soapclient ("some.wsdl"); $ client-> Somefunction ($ A, $ B, $ c); new mysqli (mysql improved) Extension [new mysqli (modified mysql) extension] for php 5, mysql ab (has /www.mysql.com/) HAS Written a new mysql extension That Allows 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 object oriented interface so that you can choose what you prefer. New features supported by this extension include prepared Statements and Variable Binding, SSL and Compressed Connections, Transaction Control, Replication Support and more ... for PHP5, MySQL AB (http://www.mysql.com/) has written a new MySQL extension, which allows you Use MySQL 4.1 or update the new function. Compared with old MySQL extensions, new extensions are provided to you a function and an object-oriented interface, so you can choose according to your preference. This extension supports new features, including pre-sounding and variable binding, SSL and connection compression, processing control, replication support, and many other features.
SQLite extension [SQLite extensions] Support for SQLite (http://www.sqlite.org/) was first introduced in the PHP 4.3.x series. It is an embedded SQL library which does not require an SQL server and is very suitable for applications which do not require the scalability of SQL servers or if you're deploying at an ISP who does not give you access to an SQL server. Contrary to what its name implies SQLite is very feature rich and supports transactions, sub-selects .., views and large DB files It is mentioned here as a PHP 5 feature because it was introduced so late in the PHP 4 series and as it takes advantage of PHP 5 by providing an object oriented interface and supporting iterators SQLite (http: / /www.sqlite.org/) Support first introduced in PHP 4.3.x. It is an embedded SQL library that does not include SQL servers and is ideal for applications that do not contain scalable SQL, or you are using ISPs that do not support access SQL. Comparing its name, suggesting SQLite is a rich feature and transaction support, sub-selects, view, and large DB files. It is referred to herein as a new feature of PHP5 because it is introduced later in the PHP4 series, and it uses PHP5 advantages and supports by providing an object-oriented interface. Tidy extension [Tidy extended] PHP 5 includes support for the useful Tidy (http://tidy.sf.net/) library. It allows PHP developers to parse, diagnose, clean and repair HTML documents. The Tidy extension supports both a functional And an Object Oriented Interface, And It's API Uses The PHP 5 Exception Mechanism. PHP5 contains a very useful tidy (http://tidy.sf.net/) library support. It allows PHP developers to analyze, diagnose, clean up, and fix HTML documents. The TIDY extension supports functions and object interfaces, and its API uses PHP5 exception mechanism.
Perl extension [Perl extensions] 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 a http://pecl.php.net/package/perl. Although there is no comprehensive evaluation default PHP5 plugin, Perl extensions allow you to call Perl scripts within PHPs, use Perl objects and other Perl features. This new extension is located in the PECL (PHP extension public library) warehouse. Http://pecl.php.net/package/perl Other New Things in PHP 5 [Other PHP5 New things]: New Memory Manager New Memory Management The Zend Engine Features A New Memory Manager. The Two Main Advantages Are Better Support for multi-threaded environments (allocations do not need to do any mutual exclusion locks) and after each request freeing the allocated memory blocks is much more efficient. As this is an underlying infra-structure change you will not notice it directly as the end- The User. The Zend Engine has written a new memory management. Two main advantages are better support multi-threaded environments (allocation does not need to do any mutex locks), and will be more effectively released after each request. Since this is a fundamental underlying structure change, you will not pay attention to this change directly as an end user. Dropped support for Windows 95 to abandon support for Windows Running PHP 95 is on the Windows 95 platform is not supported anymore due to it not supporting functionality which PHP uses. As Microsoft has officially stopped supporting it over a year ago the PHP development community decided that this Is A Wise Decision. Running PHP under the Windows 95 platform will no longer be supported. Because it does not support PHP functionality. Since Microsoft has officially stopped a year ago to support Windows 95 support, the PHP development team believes this is a broad decision.
