What’s new in PHP 5.4? A huge list of major changes!

lovegigi

　　　　The PHP 5.4 is now available.
　　As you probably know, the updates that were intended for postponed PHP 6 were added to PHP 5.4.0 instead, so now PHP includes a huge set of new language features and removes several legacy behaviors.
　　Because of that I created a list of major changes since PHP 5.3 ,along with some examples and brief descriptions of these changes…

Major PHP improvements
　　Changes since PHP 5.3 version include:

• 
  Added class member access on instantiation.　　Now you can use fluent interfaces like in Java:
  
  $myCar = (new Car)->setSpeed(100)->setColor('blue');
  
• 
  Added callable typehint.　　This typehint allows a string with a function name, a closure, and an array composed of classname (or object) with method name.
  
  <?php
  function foo(callable $cb) {
  $cb();
  }
  ?>
  
• 
  Added closure rebinding as parameter to bindTo.　　Closure::bindTo() has been modified so now it accepts another argument that defines the new scope. This can either be an object if its class is used as the scope, or a class name.
  
  class A {
  private $x;
   
  public function __construct($v) {
  $this->x = $v;
  }
   
  public function getIncrementor() {
  return function() { return ++$this->x; };
  }
  }
   
  class B extends A {
  private $x;
   
  public function __construct($v) {
  parent::__construct($v);
  $this->x = $v*2;
  }
  }
   
  $a = new A(0);
  $b = new B(10);
   
  $ca = $a->getIncrementor();
  var_dump($ca());
   
  echo "Testing with scope given as object", "\n";
   
  $cb = $ca->bindTo($b, $b);
  $cb2 = Closure::bind($ca, $b, $b);
  var_dump($cb());
  var_dump($cb2());
   
  echo "Testing with scope as string", "\n";
   
  $cb = $ca->bindTo($b, 'B');
  $cb2 = Closure::bind($ca, $b, 'B');
  var_dump($cb());
  var_dump($cb2());
   
  $cb = $ca->bindTo($b, NULL);
  var_dump($cb());
  
  
  
  　　Result:
  
  int(1)
  Testing with scope given as object
  int(21)
  int(22)
  Testing with scope as string
  int(23)
  int(24)
  
• 
  Added short array syntax.　　Makes PHP code more readable and maintainable.
  
  $a = [1, 2, 3];
  $b = ['foo' => 'orange', 'bar' => 'apple', 'baz' => 'lemon'];
  
• 
  Added binary value format.　　Now it’s possible to use binary values directly in the PHP code:
  
  $x = 0b001110;
  echo $x;
  
• 
  Added support for Class::{expr}() syntax.　　Makes PHP more flexible, when calling class/object methods.
  
  $method = 'method';
   
  $test = new Test();
   
  $test->method();
  $test->$method();
  $test->{'method'}();
   
  Test::method();
  Test::$method();
  Test::{'method'}();
  
  
  
  　　Result:
  
  method
  method
  method
  method
  method
  method
  
• 
  Added support for Traits.　　A Trait is intended to reduce some limitations of single inheritance by enabling a developer to reuse sets of methods freely in several independent classes living in different class hierarchies.
  
  class Base {
  public function sayHello() {
  echo 'Hello ';
  }
  }
   
  trait SayWorld {
  public function sayHello() {
  parent::sayHello();
  echo 'World!';
  }
  }
   
  class MyHelloWorld extends Base {
  use SayWorld;
  }
   
  $o = new MyHelloWorld();
  $o->sayHello();
  
  
  
  　　Result:
  
  Hello World!
  
• 
  Added closure $this support back.　　Now you have an access to every object property (be it public or not).
  
  class A {
  private $value = 1;
   
  function firstGetter($name) {
  return function() use ($name) {
  return $this->$name;
  };
  }
   
  function secondGetter() {
  return function($name)  {
  return $this->$name;
  };
  }
  }
   
  $a = new A();
  $firstGetter = $a->firstGetter('value');
  echo $firstGetter();
  $secondGetter = $a->secondGetter();
  echo $secondGetter('value');
  
  
  
  　　Result:
  
  1
  1
  
• 
  Added array dereferencing support.　　Provides the implementation of array dereferencing of method/function return.
  
  function fruit () {
  return array('a' => 'apple', 'b' => 'banana');
  }
   
  echo fruit()['a'];
  
  
  
  　　Result:
  
  apple
  
• 
  Added indirect method call through array.　　Now $foo() also works in the cases where $foo is a callable array or Closure object.
  
  class Hello {
  static public function world($x) {
  echo "Hello, $x\n";
  }
  }
   
  function helloWorld($x) {
  echo "Hello, $x\n";
  }
   
  $callbacks = array(
  array('Hello', 'world'),
  function ($x) { echo "Hello, $x\n"; },
  'helloWorld'
  );
   
  foreach ($callbacks as $k => $callback) {
  if (is_callable($callback)) {
  $callback($k);
  }
  }
  
  
  
  　　Result:
  
  Hello, 0
  Hello, 1
  Hello, 2
  
• 
  Changed $GLOBALS into a JIT autoglobal.　　$GLOBALS array is initialized only if it’s used. This is a performance/memory optimization, it can however break some of the existing scripts or opcode caches.
  
  
• 
  Improved performance of @ (silence) operator.　　This can speed up PHP scripts which rely heavily on a silence operator, for example:
  
  $x = @file_get_contents('/etc/passwd');
  echo $x;
  
• 
  Added multibyte support by default.　　Previously php had to be compiled with –enable-zend-multibyte. Now it can be enabled or disabled through zend.multibyte directive in php.ini.
  
  
• 
  Added built-in web server that is intended for testing purpose.　　The following command will open a web server on the port 8000.
  
  php -S localhost:8000
  
• Lots of performance and memory usage improvements
  

Removed major PHP features

• 
  Removed break/continue $var syntax.　　You can no longer use variable to tell PHP how many levels of enclosing loops it should skip to the end of.
  
  
• 
  Removed safe mode and all related ini options.　　Functionality described in this article and marked as depreciated in PHP 5.3 has now been removed
  
  
• 
  Removed register_globals and register_long_arrays ini options.　　If enabled, register_globals injected PHP scripts with all sorts of variables, like request variables from HTML forms or values from GET requests. Now, every request/environment variable must be fetched from an appropriate PHP array.
  
  
• 
  Removed allow_call_time_pass_reference option.　　Passing arguments by reference at function call time was deprecated for code-cleanliness reasons. A function can modify its arguments in an undocumented way if it didn’t declare that the argument shall be passed by reference. To prevent side-effects it’s better to specify which arguments are passed by reference in the function declaration only.
  
  

　　For a full list of changes in PHP 5.4, see the ChangeLog. For source downloads please visit php.net QAT downloads page, Windows binaries can be found here.