Pois é, hoje dia 28 de agosto de 2014 é lançado a nova versão do PHP. A Equipe de Desenvolvimento PHP anuncia o lançamento do PHP 5.6.0. Esta nova versão vem com novas funcionalidades, algumas mudanças e muitas melhorias.

Bem, vamos ver algumas dessas mundaças:

Constant scalar expressions

Agora é possísel atribuir valores de uma contante ou de atributos de uma function concatenados e/ou calculados;

const ONE = 1;
const TEN = ONE * 10;
const PRICE = 1571;

class Sample
{
    const DISCOUNT = TEN;
    const TOTAL = PRICE - (PRICE * self::DISCOUNT / 100);
    const SENTENCE = 'O desconto foi de ' . self::DISCOUNT . '% e o preço final foi ' . self::TOTAL;

    public function any($a = ONE + self::DISCOUNT) {
        return $a;
    }
}

echo (new Sample)->any(); // 11
echo Sample::SENTENCE; // O desconto foi de 10% e o preço final foi R$ 1413,9

Variadic functions via ...

Antigamente para passar infinitos parametros era necessário para um array, agora é possível passar uma variável antecedida de ..., é isso mesmo três pontos. Eu achei meio bizarra a syntax mas a feature é legal. Nada que não podesse ser feito com um func_num_args()

function any($required, $optional = null, ...$attributes) {
    echo $required;
    echo empty($optional) ? 'optional is null' : $optional;
    foreach($attributes as $key => $attr) {
        echo 'attr ' . $key  . ' => ' . $attr;
    }
}

# você pode usar essas chamadas
any(1);
any(1, 2);
any(1, 2, 3);
any(1, 2, 3, 4);
any(1, 2, 3, 4, 5);

Argument unpacking via ...

Esse eu achei legal

function add($a, $b, $c) {
    return $a + $b + $c;
}

# você pode continuar chamando assim
echo add(1, 2, 3); // print 6
# ou assim
$attrs = [2, 3];
echo add(1, ...$attrs); // print 6

Large file uploads

Arquivos com mais de 2 Gb são aceitos

phpdbg

Agora tem um debugger chamado phpdbg para mais informações

Default character encoding

Por padrão o encoding do PHP é "UTF-8"

Exponentiation via **

Não precisei usar muitas vezes, mas facilita muito;

echo '2 ** 3 == ' . (2 ** 3); // 8
echo '2 ** 3 ** 2 == ' . (2 ** 3 ** 2); // 512

$a = 2;
$a **= 3;
echo '$a ' . $a; // 8

use function and use const

É possível também usar contantes e metodos em classes e namespaces. Por exemplo se você criar a classe a seguir:

namespace Name\Space\Sample
{
    const FOO = 42;
    public function sayMyName() {
        return __FUNCTION__;
    }
}

Você pode 'importar' metodos e/ou constantes assim:

namespace
{
    use const Name\Space\Sample\FOO;
    use function Name\Space\Sample\sayMyName;

    echo FOO; // 42
    echo sayMyName(); // Name\Space\Sample\sayMyName
}

GMP supports operator overloading

Para mais informações sobre o GMP clique aqui

$a = gmp_init(42);
$b = gmp_init(17);

// Pre-5.6 code:
var_dump(gmp_add($a, $b));
var_dump(gmp_add($a, 17));
var_dump(gmp_add(42, $b));

// New code:
var_dump($a + $b);
var_dump($a + 17);
var_dump(42 + $b);

hash_equals() for timing attack safe string comparison

O hash_equals() foi adicionado para comparar duas hashes

$expected  = crypt('12345', '$provavelsecuritysalt$');
$correct   = crypt('12345', '$provavelsecuritysalt$');
$incorrect = crypt('1234',  '$provavelsecuritysalt$');

var_dump(hash_equals($expected, $correct)); // bool(true)
var_dump(hash_equals($expected, $incorrect)); // bool(false)

__debugInfo()

class Sample
{
    private $prop;

    public function __construct($val) {
        $this->prop = $val;
    }

    public function __debugInfo() {
        return [
            'propSquared' => $this->prop ** 2,
        ];
    }
}

var_dump(new Sample(42));
/* output
object(Sample)#1 (1) {
  ["propSquared"]=>
  int(1764)
} */

Bem pessoas é isso!