Comment. / Co nowego w PHP6 - część 1 / Podstawy / PHP / Artykuły / Wortal / Home

Mimo, że do premiery pozostało jeszcze wiele czasu, warto już teraz zapoznać się ze zmianami jakie wprowadzi PHP6. Większość z nich znajdziemy także w PHP5.3 (planowana data wydania: trzeci kwartał 2008).

Wszystkie przedstawione w artykule przykłady zostały przetestowane na PHP6 skompilowanym ze źródeł z CVS.

Wsparcie dla Unicode

Wsparcie dla Unicode w PHP6 jest jedną z nowości, które na pewno nie pojawią się w PHP5.3.

Kompatybilność wsteczna

Głównym założeniem wsparcia Unicode jest pełna kompatybilność wsteczna. Wszystkie istniejące typy danych i funkcje działają identycznie jak we wcześniejszych wersjach, aczkolwiek możliwe jest obniżenie wydajności niektórych operacji spowodowane zmianami w ich implementacji.

Fallback Encoding

Fallback Encoding jest dyrektywą konfigurującą domyślne wartości dla wszystkich opcji konfiguracyjnych z rodziny unicode.*_encoding.

unicode.fallback_encoding   = "iso-8859-2"

Domyślna wartość dla tej opcji konfiguracyjnej to "UTF-8".

Runtime Encoding

Runtime Encoding kontroluje kodowanie używane wewnętrznie przez interpreter do konwersji łańcuchów binarnych (typ danych binary).

unicode.runtime_encoding   = "iso-8859-2"

Ta opcja konfiguracyjna nie wpływa na operacje wejścia/wyjścia (takie jak: wypisywanie na wyjście czy czytanie z systemu plików).

PHP umożliwia także jawne rzutowanie łańcuchów tekstowych:

(binary) - rzutuje na łańcuch binarny
(unicode) - rzutuje na łańcuch tekstowy z obsługą Unicode
(string) - działa tak jak (unicode).

Na przykład, jeśli unicode.runtime_encoding='iso-8859-2' a $uni jest łańcuch tekstowy z obsługą Unicode, wtedy

$str =   (binary)$uni;

stworzy łańcuch binarny $str w kodowaniu ISO-8859-2

Niejawne rzutowanie zachodzi także m.in. podczas konkatencji czy porównania. Jeśli próbujemy połączyć łańcuch binarny ($str) z literałem Unicode, PHP konwertuje $str na Unicode używając kodowania podanego jako unicode.runtime_encoding, a następnie je łączy.

Output Encoding

Podczas wypisywania danych na standardowe wyjście PHP automatycznie dokonuje konwersji łańcuchów tekstowych z obsługą Unicode na kodowanie podane w dyrektywie:

unicode.output_encoding   = "utf-8"

Filesystem Encoding

Ta dyrektywa kontroluje kodowanie używane w nazwach plików i katalogów.

unicode.filename_encoding   = "utf-8"

Wszystkie funkcje operujące na systemie plików (takie jak opendir) dokonują niejawnej konwersji otrzymanych oraz zwracanych nazw plików i katalogów, dlatego ważne jest ustawienie wartości dyrektywy na kodowanie używane przez system plików.

Typy danych dla łańcuchów znaków

Jak wspomniałem wcześniej istnieją dwa typy danych obsługujące łańcuchy znaków: binary i unicode string.

Typ unicode

Ten typ danych przechowuje tekst używając kodowania UTF-16. Jest on domyślnym typem dla łańcuchów tekstowych.

Typ binary

Łańcuchy binarne służą przede wszystkim:

zachowaniu kompatybliności wstecznej
przechowywaniu danych binarnych

Wypisywanie danych binarnych na standardowe wejście nie powoduje automatycznej konwersji kodowania, tak jak ma to miejsce w przypadku typu unicode.

Przestrzenie nazw

Głównym założeniem obecnej implementacji przestrzeni nazw w PHP jest rozwiązanie problemu bardzo długich nazw klas.

Deklarowanie przestrzeni nazw

Przestrzeń nazw deklarujemy w następujący sposób:

<?php
namespace Zend::DB;
class Connection {
}
function connect() {
}
?>

Do deklaracji przestrzeni nazw używamy słowa kluczowego namespace po którym następuje identyfikator przestrzeni nazw, którego kolejne człony mogą być oddzielone :: (podwójnym dwukropkiem). Umieszczenie deklaracji na samym początku pliku (jedynie po dyrektywie declare lub komentarzu) spowoduje, że wszystkie identyfikatory klas i funkcji zdefiniowanych wewnątrz przestrzeni nazw będą automatycznie poprzedzane prefiksem przestrzeni nazw.

Możliwe jest także zadeklarowanie kilku przestrzeni nazw w pliku:

<?php
namespace FirstNamespace;class Foo{}
echo __NAMESPACE__.PHP_EOL;namespace SecondNamespace;
echo __NAMESPACE__.PHP_EOL;class Foo{}
?>

Importowanie

Przestrzenie nazw oraz klasy mogą zostać zaimportowane:

<?php
require 'Zend/Db/Connection.php';
use Zend::DB;
use Zend::DB::Connection as DbConnection;$x = new Zend::DB::Connection();
$y = new DB::connection();
$z = new DbConnection();
DB::connect();
?>

Użyte w powyższym przykładzie, słowo kluczowe use tworzy jedynie alias nazwy (klasy lub przestrzeni nazw). Prostsza forma:

use   A::B::C::D;

jest równoznaczna z

use   A::B::C::D as D;

Tworzenie aliasów możliwe jest w każdym miejscu pliku (poza ciałami klas i funkcji) - działa od miejsca deklaracji do końca pliku, w którym się znajduje. Dla zachowania czytelności kodu zaleca się umieszczanie dyrektyw use na początku pliku. Możliwe jest także importowanie wielu symboli przy pomocy pojedyńczej dyrektywy use:

use A::B   as B, D as E;

Domyślna przestrzeń nazw

Nazwy klas i funkcji poprzedzone podwójnym dwukropkiem traktowane są jako bezpośrednie odwołania do klas i funkcji zdefiniowanej w domyślnej przestrzeni nazw, w której znajdują się obecnie wszystkie funkcje i klasy wbudowane oraz nieprzypisane do konkretnej przestrzeni nazw.

<?php
namespace A::B::C;
$con = ::mysql_connect(...);
?>

__autoload

Autoloader jest wywoływany, gdy poszukiwanej klasy nie ma w obecnej oraz domyślnej przestrzeni nazw, a jako parametr otrzymuje pełną kwalfikowaną nazwę klasy.

Funkcja __autoload zadeklarowana wewnątrz przestrzeni nazw nie będzie automatycznie wywoływana, należy ją zarejestrować za pomocą spl_autoload_register.

Stałe

Stałe __CLASS__ i __FUNCTION__ zwracają pełne nazwy kwalfikowane (wraz z informacją o przestrzeni nazw). Natomiast stała __NAMESPACE__ zwraca przestrzeń nazw, w której została umieszczona.

Funkcje

get_class() - zwraca pełną nazwę kwalfikowaną klasy

Late Static Binding

LSB jest rozwiązaniem następującego problemu:

<?php
class A {
    public static function who() {
         echo __CLASS__;
    }
     public static function test() {
         self::who();
     }
}
class B extends A {
     public static function who() {
          echo __CLASS__;
     }
}
?>

Statyczne referencje do klasy ( czyli self:: i __CLASS__) zawsze zwracają odwołania do klasy, w której zostały zadeklarowane.

LSB wprowadza możliwość uzyskania referencji do klasy, która została wywołana (poprzez konstrukcję static::):

<?php
class A {
     public static function who() {
          echo __CLASS__;
     }
     public static function test() {
          static::who();
     }
}
class B extends A {
     public static function who() {
          echo __CLASS__;
     }
}
B::test();
?>

Powyższy kod można zastąpić krótszym, działającym identycznie, korzystając z funkcji get_called_class zwracającej nazwę ostatnio wywoływanej klasy:

<?php
class A {
    public static function test() {
          echo get_called_class();
     }
}
class B extends A {
}
B::test();
?>

Do PHP zostały dodane także odpowiedniki funkcji call_user_func i call_user_func_array wykorzystujące LSB: forward_static_call i forward_static_call_array.

Implementacja Singletona

Wykorzystajmy teraz LSB do stworzenia klasy bazowej dla Singletonów:

<?php
class Singleton {
     static $instances = array();
     public static function factory() {
          $class = get_called_class();
          if ( !isset( self::$instances[   $class ] ) ) {
                self::$instances[ $class ] = new static();
          }
          return self::$instances[ $class ];
     }
}
class foo extends Singleton{}
class bar extends Singleton{}
$foo1 = foo::factory();
$foo2 = foo::factory();
var_dump($foo1);
var_dump($foo2);
var_dump($foo1===$foo2);
?>

Metoda factory() przedstawiona na powyższym listingu pobiera najpierw nazwę wywołanej klasy, a następnie działa analogicznie do standardowej implementacji Singletona.

Przesłanianie metod

Dopiero w PHP6 metoda przesłaniająca w klasie potomnej może zyskać nowy parametr z wartością domyślną na końcu listy argumentów, albo jeden z jej argumentów może zyskać wartość domyślną.

<?php
abstract class Base {
     abstract function someMethod($param);
     abstract function anotherMethod($param);
     }
class Ext extends Base {
     function someMethod($param='default') {
          echo $param, "\n";
     }
     function anotherMethod($param='default', $newParam =   'default') {
          echo $param, "\n";
     }
}
$a = new Ext();
$a->someMethod("foo");
$a->someMethod();
?>

Składnia NOWDOC

Składnia NOWDOC jest kolejnym sposobem na zapisanie łańcucha znaków, zachowującym się jak tekst w cudzysłowach pojedynczych.

Przykład użycia

<?php
$fooledYou = '';
print <<<'ENDOFNOWDOC'
{$fooledYou}ENDOFNOWDOC{$fooledYou}
ENDOFNOWDOC{$fooledYou}
{$fooledYou}ENDOFNOWDOC
ENDOFNOWDOC;
?>

Wynik działania skryptu.

{$fooledYou}ENDOFNOWDOC{$fooledYou}
ENDOFNOWDOC{$fooledYou}
{$fooledYou}ENDOFNOWDOC

Operator goto

Instrukcja goto pozwala na bezwarunkowe przekazanie sterowania do tzw. etykiety. Etykietę deklarujemy podając jej nazwę, a następnie dwukropek, np. etykieta: . Instrukcja goto pozwala na skok jedynie pod warunkiem, że przekazanie sterowania nie nastąpi do wnętrza bardziej zagnieżdżonego bloku kodu, np.:

Niepoprawne wykorzystanie operatora goto

<?php
goto L1;
while (0) {
     L1: echo "bug\n";
}
?>

Poprawne wykorzystanie operatora goto

<?php
$n = 1;
L1:
if ($n > 3) goto L2;
echo "$n: ok\n";
$n++;
goto L1;
L2:
?>

Dynamiczne odwołania do składowych statycznych

Dodano wsparcie dla przekazywania nazwy klasy w postaci zmiennej przy odwołaniu do składowej statycznej.

<?php
class foo {
     public static function myFunc() {
          echo "myFunc";
     }
}
$foo = 'foo';
$foo::myFunc();
?>

Powyższy przykład wyświetli myFunc.

Metoda magiczna __callStatic()

Wprowadzono konstrukcję analogiczną do __call działającą dla metod statycznych.

Przykład użycia __callStatic()

<?php
class Test {
     static function __callStatic($fname, $args) {
          echo $fname,'() called with   ',count($args)," arguments\n";
     }
}
call_user_func("Test::Two", 'A', 'B');
call_user_func(array("Test", "Three"), NULL, 0, false);
Test::Four(5, 6, 7, 8);
?>

Operator ?:

Operator ?: pozwala w bardzo prosty sposób przypisywać wartości domyślne dla niezainicjalizowanych zmiennych. Poniższe przykłady działają identycznie

<?php
$a = $b?:$c;
if ( $b ) {
     $a = $b;
} else {
     $a = $c;
}
?>

Należy pamiętać, że oba powyższe przykłady generują ostrzeżenie E_NOTICE, co znacznie zmniejsza atrakcyjność przedstawionego rozwiązania.

break i continue

Opcjonalny argument break i continue może być jedynie stałą.

Poprawne zastosowanie break

<?php
while(true){
     while(true){
          break 2;
     }
}
?>

Niepoprawne zastosowanie break

<?php
$a=2;
while(true){
     while(true){
          break $a;
     }
}
?>

Powyższy kod wygeneruje błąd E_FATAL_ERROR.

Zmiana działania instanceof, catch, is_a, is_subclass_of

instanceof, catch, is_a, is_subclass_of nie wywołują automatycznie funkcji __autoload.

Struktury danych

Rozszerzenie SPL wzbogaciło się o kilka nowych klas implementujących struktury danych:

SplDoublyLinkedList - implementująca listę dwukierunkową

<?php
$dll = new SplDoublyLinkedList();
$dll->push(2);
$dll->push(3);
$dll->push(4);
$dll->setIteratorMode(SplDoublyLinkedList::IT_MODE_LIFO);
foreach ($dll as $k => $v) {
     echo "$k=>$v\n";
}
$dll->setIteratorMode(SplDoublyLinkedList::IT_MODE_FIFO);
foreach ($dll as $k => $v) {
     echo "$k=>$v\n";
}
$dll->setIteratorMode(SplDoublyLinkedList::IT_MODE_FIFO |   SplDoublyLinkedList::IT_MODE_DELETE);
var_dump($dll->count());
foreach ($dll as $k => $v) {
     echo "$k=>$v\n";
}
var_dump($dll->count());
?>

Wynik działania skryptu:

2=>4
1=>3
0=>2
0=>2
1=>3
2=>4
int(3)
0=>2
1=>3
2=>4
int(0)

SplQueue - podklasa SplDoublyLinkedList implementująca kolejkę FIFO
SplStack - podklasa SplDoublyLinkedList implementująca kolejkę LIFO
SplHeap - standardowa implementacja stogu
SplMinHeap - kopiec uporządkowany rosnąco (minimalna wartość w korzeniu). Klasa rozszerza SplHeap

<?php
$input = range(1,5);
shuffle($input);
$h = new SplMinHeap();
foreach($input as $i) {
     $h->insert($i);
}
foreach ($h as $k => $o) {
     echo "$o\n";
}
?>

Powyższy kod wypisze:

SplMinHeap - stóg uporządkowany malejąco (maksymalna wartość w korzeniu). Klasa rozszerza SplHeap.

<?php
$input = range(1,5);
shuffle($input);
$h = new SplMaxHeap();
foreach($input as $i) {
     $h->insert($i);
}
foreach ($h as $k => $o) {
     echo "$o\n";
}
?>

Powyższy kod wypisze:

SplPriorityQueue - implementuje kolejkę priorytetową.
SplFastArray - szybsza (jak sama nazwa wskazuje) implementacja tablicy o stałej wielkości i indeksowanej jedynie liczbami. Etienne Kneuss na swoim blogu twierdzi, że SplFastArray jest szybsza od zwykłych tablic o 10-30%. Dla bardzo dużych tablic można zauważyć znaczne zmniejszenie ilości potrzebnej pamięci od około 4 (dla tablicy o wielkości powyżej 50 000 elementów) do ponad 15 razy (dla 10 000 000 elementów).

<?php
$size = 100;
$array = new SplFastArray($size);
for ( $i=0; $i<$size; ++$i){
     $array[$i] = $i;
}
$array -> setSize(1000);
?>

GlobIterator - iterator nawigujący po systemie plików za pomocą wzorca (analogicznie do funkcji glob()), rozszerza FilesystemIterator i implementuje interfejsy Iterator, Traversable, Countable

<?
var_dump(iterator_to_array(new GlobIterator('*.php')));
?>

array(4) {
      ["/GlobIterator.php"]=>
           object(SplFileInfo) (2) {
                [u"pathName":u"SplFileInfo":private]=> string(0) ""
                [u"fileName":u"SplFileInfo":private]=> string(17) "/GlobIterator.php"
           }
     ["/LSB.php"]=>
           object(SplFileInfo) (2) {
                [u"pathName":u"SplFileInfo":private]=> string(0) ""
                [u"fileName":u"SplFileInfo":private]=> string(8) "/LSB.php"
           }
      ["/SplMaxHeap.php"]=>
           object(SplFileInfo) (2) {
                [u"pathName":u"SplFileInfo":private]=> string(0) ""
                [u"fileName":u"SplFileInfo":private]=> string(15) "/SplMaxHeap.php"
           }
      ["/SplMinHeap.php"]=>
           object(SplFileInfo) (2) {
                [u"pathName":u"SplFileInfo":private]=> string(0) ""
                [u"fileName":u"SplFileInfo":private]=> string(15) "/SplMinHeap.php"
      }
 }

Nowe funkcje

class_alias( $className, $aliasName ) - tworzy alias dla klasy (oba parametry powinny być pełnymi kwalfikowanymi nazwami, przy czym nie muszą znajdować się w jednej przestrzeni nazw).

<?php
namespace foo;
class MyClass { }
class_alias('foo::MyClass', 'MyAlias');
use ::MyAlias as stdClass;
var_dump(new foo::MyClass);
var_dump(new stdClass);
var_dump(new ::MyAlias);
?>

Powyższy kod wypisze:

object(foo::MyClass)1   (0) {
}
object(foo::MyClass)1 (0) {
}
object(foo::MyClass)1 (0) {
}

getopt - od tej pory funkcja ta działa identycznie na każdym systemie operacyjnym; dodano także obsługę elementów opcjonalnych
get_extension_funcs($extensionName) - zwraca wszystkie funkcje zdefiniowane przez rozszerzenie:

<?php
print_r(get_extension_funcs("spl"));
?>

Array (
     [0] => spl_classes
     [1] => spl_autoload
     [2] => spl_autoload_extensions
     [3] => spl_autoload_register
     [4] => spl_autoload_unregister
     [5] => spl_autoload_functions
     [6] => spl_autoload_call
     [7] => class_parents
     [8] => class_implements
     [9] => spl_object_hash
     [10] => iterator_to_array
     [11] => iterator_count
     [12] => iterator_apply
)

gmp_testbit($resource, $bitIndex) - sprawdza czy dany bit jest ustawiony.

<?php
$n = gmp_init("1000000");
var_dump(gmp_testbit($n, 1));
gmp_setbit($n, 1);
var_dump(gmp_testbit($n, 1));
?>

bool(false)
bool(true)

lcfirst( $str) - zwraca łańcuch tekstowy z pierwszą literą zmienioną na małą
str_getcsv( $input [, $delimiter [, $enclosure [, $escape ]]] ) - parsuje dane w formacie CSV i zwraca je jako tablicę 1

<?php
$csvData = <<&lt;DATA
value1;"value 2";"value ""3"
DATA;
var_dump(str_getcsv($csvData, ';', '"', '"'));
?>

array(3) {
     [0]=> unicode(6) "value1"
     [1]=> unicode(7) "value 2"
     [2]=> unicode(8) "value "3"
}

Nowe stałe

W PHP6 znajdzie się też szereg przydatnych stałych takich jak:

__DIR__ - równoważne dirname( __FILE__)
PHP_MAJOR_VERSION
PHP_MINOR_VERSION
PHP_RELEASE_VERSION
PHP_VERSION_ID - ostatnia część pełnej wersji PHP, dla 5.2.5-p20080206-pl3-gentoo to -p20080206-pl3-gentoo
PHP_EXTRA_VERSION - stała z pliku main/main.c identyfikująca wersję (int)
PHP_ZTS - 1 jeśli PHP zbudowane jest z Zend Thread Safety, inaczej 0
PHP_DEBUG - 1 jeśli PHP zbudowane jest z opcją ?enable-debug, inaczej 0

PHP.ini

Jani Taskinen poprawił obsługę plików INI w PHP:

dodane zostało wsparcie dla PHP.ini działających jak pliki .htaccess dla CGI/FastCGI

;Name for   user-defined php.ini (.htaccess) files. Default is ".user.ini"
user_ini.filename = ".user.ini"
;To disable this feature set this option to empty value
;user_ini.filename = ""
;TTL for user-defined php.ini files (time-to-live) in seconds.
;Default is 300 seconds (5 minutes)
user_ini.cache_ttl = 300

obsługa specjalnej sekcji [PATH=/var/www/www.example.com] dla konkretnego katalogu - skrypt znajdujący się w nim nie może zmodyfikować znajdujących się w tej sekcji ustawień.
kompletna obsługa zmiennych oraz tablic indeksowanych alfanumerycznie i zmiennymi

[variable]
     var = 42
     var2 = ${var}
[arrays]
     foo[bar] = 1
     foo[${val}] = "variable"

poprawiona obsługa błędów

ReflectionProperty::setAccessible

Od PHP5.3 możliwe jest pobieranie wartości właściwości prywatnych i chronionych poprzez Reflection API, wystarczy wywołać metodę ReflectionProperty::setAccessible(true).

<?php
class Foo {
     private $property;
     public function __construct($property){
          $this->property = $property;
     }
}
$property = new ReflectionProperty('Foo', 'property');
$property -> setAccessible(true);
echo $property -> getValue( new Foo(42) );
?>

Phar

Rozszerzenie to pozwala na dystrybucję aplikacji w postaci pojedyńczego pliku Phar (podobnego do pliku JAR w Javie). Możemy wyróżnić dwa typy plików Phar:

wykonywalne ( executable) - reprezentowane przez klasę Phar, które mogą być uruchamiane bezpośrednio przez interpreter/serwer WWW. Ich modyfikacja możliwa jest dopiero po ustawieniu dyrektywy phar.readonly=1 w pliku PHP.ini.
niewykonywalne ( non-executable) - reprezentowane przez klasę PharData, używane do przechowywania plików.

Załóżmy, że mamy prostą aplikację składającą się z jednego pliku index.php:

<?php
echo 'Hello Phar!';
?>

Aby stworzyć z niej wykonywalne archiwum Phar należy wykonać następujący skrypt:

<?php
$phar = new Phar('hello.phar');
$phar->setDefaultStub('index.php');
$phar->addFile('index.php');
?>

Pierwszy argument metody setDefaultStub jest ścieżką do pliku, który ma zostać wykonany po uruchomieniu pliku Phar (nawet w przypadku braku zainstalowanego rozszenia) przy pomocy komendy

php   hello.phar

Wsparcie dla profilowania XSLT

<?php
$xml = <<<EOB
<allusers>
<user>
<uid>bob</uid>
</user>
<user>
<uid>joe</uid>
</user>
</allusers>
EOB;
$xsl = <<<EOB
<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheetversion="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns: php=? http://php.net/xsl ?>
<xsl:output method="html" encoding="utf-8" indent="yes" />
<xsl:template match="allusers" ?>
<html><body>
<h2>Users</h2>
<table>
<xsl:for-each select="user" ?>
<tr><td>
<xsl:value-of select="php:function( "ucfirst", string( uid ) ) "/>
</td></tr>
</xsl:for-each>
</table>
</body></html>
</xsl:template>
</xsl:stylesheet>
EOB;$xmldoc = DOMDocument::loadXML( $xml ) ;$xsldoc = DOMDocument::loadXML( $xsl );
$proc = new XSLTProcessor;
$proc->registerPHPFunctions( ) ;
$proc->importStyleSheet( $xsldoc ) ;
$proc->setProfiling( "/tmp/xslt.profile" );
echo $proc->transformToXML( $xmldoc ) ;
?>

Rezultaty profilowania wygladaja nastepujaco:

mysqlnd

mysqlnd (MySQL Native Driver for PHP) jest biblioteką zastępującą libmysql. Zalety mysqlnd w stosunku do libmysql:

Ścisła integracja z ZendEngine
Szybsze działanie
Niższe zużycie pamięci (wyniki zapytań nie są dwukrotnie składowane - najpierw w libmysql, potem w PHP)
Łatwiejsza kompilacja
Użycie PHP Stream API
PersistentConnections (niedostępne dotąd z mysqli)

Dotychczas brakuje wsparcia dla PDO_MySQL.

Ulepszone rozszerzenie mhash

Dodano funkcje:

int mhash_keygen_count
string mhash_get_keygen_name(int $keygen)
bool mhash_keygen_uses_hash(int $keygen)
bool mhash_keygen_uses_salt(int $keygen)
int mhash_get_keygen_salt_size(int $keygen)
binary mhash_keygen(int $type, int $hash1, int $hash2, binary $password[, binary $salt[, int $max_key_size = 128[, int $bytes_count = 0]])

Dodano stałe:

MHASH_KEYGEN_ASIS
MHASH_KEYGEN_HEX
MHASH_KEYGEN_MCRYPT
MHASH_KEYGEN_PKDES
MHASH_KEYGEN_S2K_ISALTED
MHASH_KEYGEN_S2K_SALTED
MHASH_KEYGEN_S2K_SIMPLE

Ulepszony GarbageCollector

W PHP6 znajdzie się ulepszony GarbageCollector usuwający referencje cykliczne, pozwalający (w niektórych przypadkach) znacznie zredukować zapotrzebowanie na pamięć przy niewielkim spadku wydajności. GarbageCollector można włączyć poprzez ustawienie opcji (domyślnie włączona):

zend.enable_gc=true

Nowy mechanizm GC jest ekstremalnie skuteczny w sytaucji przedstawionej na poniższym listingu:

<?php
class A {
     function __construct () {
          $this->b = new B($this);
     }
}
class B {
     function __construct ($parent = NULL) {
          $this->parent = $parent;
     }
}
while (true){
     $a = new A();
}
?>

Dodano także kilka funkcji sterujących GC:

long gc_collect_cycles() - wymusza rozpoczęcie procesu usuwania referencji cyklicznych, zwraca ilość usuniętych struktur.
bool gc_enabled() - zwraca true, jeśli nowy GC jest włączony
void gc_enable() - włącza nowy GC
void gc_disable() - wyłącza nowy GC

Poprawa wydajności

md5 jest obecnie około 15% szybsze
poprawiono obsługę stosu wewnątrz PHP
przyspieszono obsługę błędów
zmniejszono rozmiar i czas uruchomienia pliku wykonywalnego przy kompilacji gcc4

Stałe E_ALL i E_STRICT

Przy poziomie raportowania E_ALL będą wyświetlane także błędy E_STRICT.

Emulacja zachowania z PHP5

Można filtrować błędy E_STRICT używając poniższego kodu:

<?php
error_reporting(error_reporting() & ~E_STRICT);
?>

Zmiany łamiące kompatybilność wsteczną

safe_mode

safe_mode został usunięty. Ustawienie dyrektywy safe_mode w php.ini powoduje wyemitowanie błędu E_WARNING.

Nie ma możliwości emulacji zachowania z PHP5.

register_long_arrays

register_long_arrays oraz tablice $HTTP_* zostały usunięte. PHP emituje E_WARNING podczas uruchomienia, jeśli wykryje włączone register_long_arrays.

<?php
if (!ini_get('register_long_arrays')) {
     $HTTP_POST_VARS =& $_POST;
     $HTTP_GET_VARS =& $_GET;
     $HTTP_COOKIE_VARS =& $_COOKIE;
     $HTTP_SERVER_VARS =& $_SERVER;
     $HTTP_ENV_VARS =& $_ENV;
     $HTTP_POST_FILES =& $_FILES;
}
?>

magic_quotes

Usunięto dyrektywy:

magic_quotes_gpc
magic_quotes_runtime
magic_quotes_sybase

Ustawienie ich spowoduje wyemitowanie ostrzeżenia E_WARNING.

Usunięte funkcje:

set_magic_quotes_runtime

Funkcje:

get_magic_quotes_gpc
get_magic_quotes_runtime

zwracają zawsze false.

register_globals

Ze względów bezpieczeństwa register_globals zostały usunięte z PHP6.

<?php
ini_get("register_globals");
?>

zawsze zwraca false.

Wraz z usunięciem register_globals straciły rację bytu takie funkcje jak:

session_register
session_is_registered
session_unregister

Emulacja zachowania z PHP5

Poniższe rozwiązanie zostało zaproponowane przez twórców PHP, powinno być jednak traktowane tylko jako stadium przejściowe i pod żadnym pozorem nie może być używane na stałe.

<?php
     $_register_globals_order = strrev(ini_get("variables_order"));
     $_register_globals_order_len = strlen($_register_globals_order);
     for($_register_globals_i=0;   $_register_globals_i<$_register_globals_order_len; $_register_globals_i++)   {
          switch($_register_globals_order{$_register_globals_i}) {
               case "E":
                     extract($_ENV, EXTR_REFS|EXTR_SKIP);
                   break;
               case "G":
                     extract($_GET, EXTR_REFS|EXTR_SKIP);
                    break;
               case "P":
                     extract($_POST, EXTR_REFS|EXTR_SKIP);
                    break;
               case "C":
                     extract($_COOKIE, EXTR_REFS|EXTR_SKIP);
                    break;
               case "S":
                     extract($_SERVER, EXTR_REFS|EXTR_SKIP);
                    break;
          }
     }
     unset($_register_globals_order, $_register_globals_order_len,   $_register_globals_i);
     function session_register($mixed) {
          static $started;
          if(!isset($started) || session_id() === "") {
               session_start();
               $started = true;
          }
          $array = func_get_args();
          foreach($array as $mixed) {
               if(is_scalar($mixed)) {
                     $_SESSION[$mixed] =& $GLOBALS[$mixed];
               } elseif(is_array($mixed)) {
                     foreach($mixed as $name) {
                          $ok = session_register($name);
                          if(!$ok) {
                               return false;
                          }
                    }
               } else {
                    return   false;
               }
          }
          return true;
     }
     function session_is_registered($name) {
          if(is_scalar($name)) {
               return isset($_SESSION[$name]);
          }
          return false;
     }
     function session_unregister($name) {
          if(isset($_SESSION[$name]) && is_scalar($name)) {
               unset($_SESSION[$name]);
               return true;
          }
          return false;
     }
?>

ZE1 compatibility mode

ZE1 compatibility mode (emulacja modelu obiektowego PHP4) został stworzony aby ułatwić migrację aplikacji z PHP4 do PHP5, ale nigdy nie działał w 100% poprawnie. Nie ma możliwości emulacji zachowania z PHP5. Model obiektowy PHP5/PHP6 jest jedynym obowiązującym.

Porzucone wsparcie dla funkcji GD1/Freetype1

Biblioteka GD1 nie jest już rozwijana.

Nie ma możliwości emulacji zachowania z PHP5.

ASP-style tags

Nie można dłużej używać <% zamiast <?php i %> zamiast ?>

Nie ma możliwości emulacji zachowania z PHP5.

Wyszukiwarka

Logowanie

Top 10

Kategorie

Spis treści

O autorze

Podobne Artykuły

Nowe artykuły

Co nowego w PHP6 - część 1

Wsparcie dla Unicode

Kompatybilność wsteczna

Fallback Encoding

Runtime Encoding

Output Encoding

Filesystem Encoding

Typy danych dla łańcuchów znaków

Typ unicode

Typ binary

Przestrzenie nazw

Deklarowanie przestrzeni nazw

Importowanie

Domyślna przestrzeń nazw

__autoload

Stałe

Funkcje

Late Static Binding

Implementacja Singletona

Przesłanianie metod

Składnia NOWDOC

Operator goto

Dynamiczne odwołania do składowych statycznych

Metoda magiczna __callStatic()

Operator ?:

break i continue

Zmiana działania instanceof, catch, is_a, is_subclass_of

Struktury danych

Nowe funkcje

Nowe stałe

PHP.ini

ReflectionProperty::setAccessible

Phar

Wsparcie dla profilowania XSLT

mysqlnd

Ulepszone rozszerzenie mhash

Ulepszony GarbageCollector

Poprawa wydajności

Stałe E_ALL i E_STRICT

Emulacja zachowania z PHP5

Zmiany łamiące kompatybilność wsteczną

safe_mode

register_long_arrays

magic_quotes

register_globals

Emulacja zachowania z PHP5

ZE1 compatibility mode

Porzucone wsparcie dla funkcji GD1/Freetype1

ASP-style tags