PHP 5.3 alpha

Posté le Samedi 8 novembre 2008 à 2 h 08, Read it in english with Google

ça fait longtemps qu’on l’attend, il est encore repoussĂ© mais ont devrait le voir arriver avant 2009. faite hommage Ă  PHP 5.3.

Alors qu’est-ce qu’il y a de si nouveau pour que je m’esclaffe ainsi. Globalement on note 3 amĂ©liorations notables en dehors des nouvelles fonctions qui nous seront bien utile mais qu’on pouvait dĂ©jĂ  faire en grugeant un peu :


Je ne donnerais pas de dĂ©tail sur driver intĂ©grĂ© optionnel MySQLnd car j’y vois plus d’inconvĂ©nients que d’avantages. C’est très apprĂ©ciable de voir intĂ©grer un driver au moteur de php et on peut imaginer Ă  termes des optimisations de mĂ©moire et de cache non nĂ©gligeable. Mais qu’en est-il de la maintenance ? Le driver (Ă  ma conaissance) devra ĂŞtre intĂ©grĂ© Ă  la compilation de php donc une recompilation sera nĂ©cessaire Ă  chaque nouvelle version de php. Ce sera utilise pour les applications critiques qui nĂ©cessitent des tests avant mise en production. Le mod_php d’apache est très difficilement exĂ©cutable avec 2 versions diffĂ©rentes de php. Ces applications tournent donc sur en mode fastCGI (CGI est au oubliette) qui permet de lancer facilement 15 versions de php sur le mĂŞme serveur. Cependant mod_php reste nettement plus rapide que fastCGI, je l’utilise et je ne souhaite pas recompiler php Ă  chaque changement de version, n’ayant pas d’environnement de test.

Les Namespaces

C’est une implĂ©mentation simple des namespaces qui va nous permettre de classer un peut toutes nos librairies afin d’une part d’Ă©viter les conflits et de d’autre part d’y voir plus clair (en Ă©vitant d’utiliser de faux namespaces avec des undescore un peu partout…).

Pour l’utilisation je vous conseil de lire le manuel. Un petit exemple, (avec php 5.3 alpha2, mais il reste des bugs) :

ns.php :

<?php
define('_N', "\n");

include('Xorax.php');
include('Xorax.Info.php');

use Xorax::Info;

echo Xorax::test();
echo Xorax::Info::test();
echo Info::linkMe();

Xorax.php :

<?php
namespace Xorax;

function test () {
  echo 'Xorax::test()'. ::_N;
}

function linkHref ($link)
{
  echo '<a href="'.$link.'">'.$link.'</a>';
}

Xorax.Info.php :

<?php
namespace Xorax::Info;

//théorycaly not require (bug ?)
use Xorax;

function test () {
  echo 'Xorax::Info::test()'. ::_N;
}

function linkMe ()
{
  Xorax::linkHref('http://xorax.info');
  // actualy if you don't want declare using Xorax namespace :
  // ::Xorax::linkhref('http://xorax.info');
}

Les namespaces sont rĂ©solu Ă  la compilation. Lorsqu’un nom de classe n’est pas prĂ©cĂ©dĂ© d’un espace de nom, php va rechercher dans l’espace de nom du contexte courant, puis dans le namespace global, puis enfin l’envoyer Ă  un __autoload pour ĂŞtre charger automatiquement.

Late Static Bindings et __callStatic

ça fait longtemps que j’attends ceci et je dois dire que j’ai bien du mal Ă  programmer en objet sans ça. La fin des fixations static (late static binding) vont nous servir Ă  implĂ©menter correctement l’hĂ©ritage sur nos variables static.

Actuellement lorsque vous appelez une variable static dans votre classe, vous ne pouvez pas monter d’un niveau. Votre variable self::$myStaticVar fera rĂ©fĂ©rence Ă  une variable static de la classe courante ou de ses parents mais ne fera jamais rĂ©fĂ©rence Ă  une variable static dĂ©fini dans une classe enfant. C’est donc très difficile d’implĂ©menter un hĂ©ritage avec les variable static. Mais maintenant (enfin bientĂ´t) plus besoin de se prendre le chou. Vous pourrez faire static::$myStaticVar et votre variable pourra faire rĂ©fĂ©rence Ă  une variable d’une classe enfant.

Un exemple vaut mieux que des long discours :

<?php
define('_N', "\n");

class A
{
  public static $s = 'A::$s';
 
  public function testA ()
  {
    echo __CLASS__ . '::' . __FUNCTION__ .' from '. get_class($this).' :' . _N;
    echo 'static::$s = ' . static::$s . _N;
    echo 'self::$s = ' . self::$s . _N;
    echo _N;
  }
}

class B extends A
{
  public static $s = 'B::$s';
 
  public function testB ()
  {
    echo __CLASS__ . '::' . __FUNCTION__ .' from '. get_class($this).' :' . _N;
    echo 'static::$s = ' . static::$s . _N;
    echo 'self::$s = ' . self::$s . _N;
    echo _N;
  }
}

$a = new A();
$b = new B();
$a->testA();
$b->testA();
$b->testB();

sortie :

A::testA from A :
static::$s = A::$s
self::$s = A::$s

A::testA from B :
static::$s = B::$s // voilà notre héritage descendant !!!
self::$s = A::$s

B::testB from B :
static::$s = B::$s
self::$s = B::$s

C’Ă©tait difficile de se sentir Ă  l’aise avec la POO sans ça !

Pour ce qui est dans la fonction __callStatic(), vous l’aurez compris c’est la mĂŞme chose que la fonction __call, mais avec les fonctions static. Pratique efficace inĂ©vitable.

les fonctions lambda et les restrictions de contexte

VoilĂ  une nouvelle structure de fonction que je ne pensais pas voir arriver en php. Mais le langage essayant malgrĂ© lui de se tourner vers une perspective objet, ceci devait arrivĂ©. Voici donc les lambda functions, ou fonctions anonymes. Comme le nom l’indique, cela va vous permettre de crĂ©er des fonctions sans nom Ă  la volĂ© que vous stockerez dans des variables ou que vous exĂ©cuterez directement. Évidemment il va manquez la notion de contexte prĂ©sent dans les autres (vrai) langages objet mais pour l’instant ça ouvre un horizon assez large de possibilitĂ©s. Certes, cela Ă©tait dĂ©jĂ  possible auparavant Ă  l’aide de la mĂ©thode create_function(), mais très couteux car php devait reparser le contenu des parametres passĂ©s Ă  create_function(). Maintenant c’est lors de la compilation que la fonction anonyme sera identifiĂ© comme tel.

Pour ce qui est de la notion de contexte, une fonction anonyme dĂ©clarĂ© dans une mĂ©thode de classe pourra se rĂ©fĂ©rer au contexte de la classe oĂą elle a Ă©tĂ© dĂ©clarĂ© et pourra donc utiliser $this, parent, self et le nouveau static. Si cette fonction anonyme n’a pas la nĂ©cessitĂ© de se rĂ©fĂ©rer au contexte courant, on pourra la dĂ©clarer comme fonction anonyme static. En revanche, impossible de changer le contexte de la fonction une fois dĂ©clarĂ©.

Comme pour le reste rien ne vaut un bon exemple :

<?php
$test = function ($txt = '')
{
  if ($txt) {
    $txt .= ' - ';
  }
  echo $txt . '$test()';
};

$test();
echo "\n";

class A {
  public $a = 'A->a';
  public static $sa = 'A::$a';
  public $func;
 
  public function __construct ()
  {
    $this->func = function ($txt = '') {
      if ($txt) {
        $txt .= ' - ';
      }
      echo $txt .__CLASS__ .'->$func() [ a:' . $this->a . ', sa : '. self::$sa . ']';
    };
  }
 
  function call ($func)
  {
    $func(__CLASS__);
  }
}

$a = new A();
echo "\n";

$a->call($test);
echo "\n";

//$a->func(); // fatal error : undefined function
$f = $a->func;
$f();
echo "\n";

$a->call($f);
echo "\n";

class B {
  public $a = 'B->a';
  public static $sa = 'B::$a';
 
  function call ($func)
  {
    $func(__CLASS__);
  }
}

$b = new B();
$b->call($f);

sortie :

$test()

A - $test()
A->$func() [ a:A->a, sa : A::$a]
A - A->$func() [ a:A->a, sa : A::$a]
B - A->$func() [ a:A->a, sa : A::$a]

Sans être complet donc, ceci va tout de même nous éviter de pourrir notre espace de noms avec des fonctions spécifiques.

Si vous souhaitez utiliser des variables du contexte de déclaration dans votre fonction vous pouvez utiliser la syntaxe avec use :

<?php
$a = 1;

$test = function () use ($a) {
  $a += 1;
  echo 'test-a = '.$a;
};

$test();
echo "\n";
echo '$a = '.$a;
echo "\n";

$test2 = function () use (&$a) {
  $a += 1;
  echo 'test2-a = '.$a;
};

$test2();
echo "\n";
echo '$a = '.$a;

sortie :

test-a = 2
$a = 1
test2-a = 2
$a = 2

On espère voir arriver cette nouvelle version pour noĂ«l. C’est une Ă©volution majeur de la structure du language php qui va nous simplifier la vie sur bien des points. Et pas forcĂ©ment au dĂ©triment des performances puisque la plupart de ces amĂ©liorations sont de la structure donc au niveau du compilateur. L’implĂ©mentation de système de cache comme APC se fera donc de plus en plus ressentir. A vos clavier !!!

2 réponses à “PHP 5.3 alpha”

  1. Michael

    Le sĂ©parateur de namespace ne serait plus :: pas bel et bien le backslash \ a partir de l’alpha3. Je trouve ça carrĂ©ment horrible.. :s

    http://wiki.php.net/rfc/namespaceseparator

  2. XoraX

    ah quelle dĂ©faite…
    on va encore se torde les doigts :s
    mais bon faut dire que c’Ă©tait en conflit avec les Ă©lĂ©ments statics.
    On va devoir se sacrifier pour les qwerty…

Laissez un commentaire :