Újítások PHP 5.2-ről 5.3-ra
Névterek
Névterek támogatása lett hozzáadva a nyelvhez. A névterek két fő probléma megoldására hivatottak, a név ütközések feloldására és a aliasolás lehetőségnek megteremtésére. Részletes leírás itt található
Late Static Bindings
A Late Static Bindings a statikus metódus hívásoknál kap szerepet. A self és a __CLASS__ arra az osztályra mutat, ahol deklarálva lett. Az static kulcsszó viszont a hívott osztályra mutat. Példával illusztrálva:
class A {
public static function who() {
echo __CLASS__;
} public static function test() {
self::who();
}
}
class B extends A {
public static function who() {
echo __CLASS__;
}
}
B::test();
A
class A {
public static function who() {
echo __CLASS__;
} public static function test() {
static::who(); // Here comes Late Static Bindings
}
}
class B extends A {
public static function who() {
echo __CLASS__;
}
}
B::test();
B
Részletes leírás itt található
Goto
A jól ismert goto utasítást is beemelték a nyelvbe. A goto utasítás arra használható, hogy a program egyik részéből a másikba ugorjunk. A célpontnak azonos fájlban kell lennie.
for($i=0,$j=50; $i<100; $i++) {
while($j--) {
if($j==17) goto end;
}
} echo "i = $i"; end: echo 'j hit 17';
j hit 17
_callStatic() metódus
A __callStatic() mágikus metódust egy osztályon belül lehet definiálni. Automatikusan hívódik meg akkor, amikor olyan statikus metódust akarunk meghívni, ami nincs deklarálva. Overloadingot lehet vele megvalósítani.
class MethodTest {
public function __call($name, $arguments) {
// Note: value of $name is case sensitive.
echo "Calling object method '$name' "
. implode(', ', $arguments). "\n";
}
/** As of PHP 5.3.0 */
public static function __callStatic($name, $arguments) {
// Note: value of $name is case sensitive.
echo "Calling static method '$name' "
. implode(', ', $arguments). "\n";
}
}
$obj = new MethodTest; $obj->runTest('in object context');
MethodTest::runTest('in static context'); // As of PHP 5.3.0
Calling object method 'runTest' in object context
Calling static method 'runTest' in static context
__invoke() metódus
Az __invoke() mágikus metódust osztályon belül lehet definiálni. Automatikusan hívódik meg akkor, ha egy objektumot függvényként próbálunk meghívni.
class CallableClass {
public function __invoke($x) {
var_dump($x);
}
} $obj = new CallableClass; $obj(5); var_dump(is_callable($obj));
int(5) bool(true)
Újítások PHP 5.3-ről 5.4-re
Traitek
Bekerült a PHP-ba a traitek támogatása. A traitek alapvetően kód újrahasznosítást tesznek lehetővé. Az egyszeres öröklődés korlátainak csökkentésére szolgál
trait ezcReflectionReturnInfo {
function getReturnType() { /*1*/ } function getReturnDescription() { /*2*/ }
}
class ezcReflectionMethod extends ReflectionMethod {
use ezcReflectionReturnInfo;
/* ... */
}
class ezcReflectionFunction extends ReflectionFunction {
use ezcReflectionReturnInfo;
/* ... */
}
Részletes leírás itt található
Rövid tömb szintaxis
Tömböket már rövidített formában is létre lehet hozni. Az alábbi példa jól szemlélteti ezt
$a = [1, 2, 3, 4]; $a = ['one' => 1, 'two' => 2, 'three' =>
3, 'four' => 4];
Closure és a $this
A closureök alkalmazása során már lehetőség van a $this kulcsszó használatára, amely ilyenkor a megszokott módon működik.
Objektum elérés inicializáláskor
Lehetőség van inicializálás után egyből használni az objektumot. Ezt eddig csak két lépésben tudtuk megtenni.
$foo = new Foo(); $foo->bar();
(new Foo)->bar();
Újítások PHP 5.4-ről 5.5-re
Generátorok
Generátorok támogatása a yield kulcsszóval. A generátorok egyszerű módot adnak egyszerű iterátorok implementálására az overhead nélkül amit egy osztály implementálása adna, ami rendelkezik az Iterator interfésszel
function xrange($start, $limit, $step = 1) {
for ($i = $start; $i <= $limit; $i += $step) {
yield $i;
}
}
echo 'Single digit odd numbers: ';
/*
* Note that an array is never created or returned,
* which saves memory. */
foreach (xrange(1, 9, 2) as $number) {
echo "$number ";
}
echo "\n";
Single digit odd numbers: 1 3 5 7 9
Részletes leírás itt található
Finally kulcsszó
A try-catch blokk már támogatja a finally blokkot is. Az ebben a blokkban található kód, le fog futni, függetlenül attól, hogy volt-e expection vagy sem.
Új jelszó hashelő API
Új jelszó hashelő API került bevezetésre, ami könnyebbé teszi, hogy biztonságosan hash-eljünk és menedzseljünk jelszavakat. Ez egy erős egy-irányú hash algoritmust implementál. Kompatibilis a crypt() függvénnyel. A függvény: password_hash()
A foreach támogatja a list()-et
A foreach szerkezet támogatja a beágyazott tömbök kicsomagolását külön változókba a list() segítségével
$array = [
[1, 2], [3, 4],
];
foreach ($array as list($a, $b)) {
echo "A: $a; B: $b\n";
}
A: 1; B: 2 A: 3; B: 4
empty() függvény kifejezéseket is támogat
Az empty() függvény már nem csak változókat, hanem kifejezéseket is támogat paraméterként.
function always_false() {
return false;
}
if (empty(always_false())) {
echo "This will be printed.\n";
}
if (empty(true)) {
echo "This will not be printed.\n";
}
This will be printed.
Tömb és sztring dereferenciálás
Tömböket és sztringeket közvetlenül lehet dereferenciálni és az egyes elemeit elérni
echo 'Array dereferencing: '; echo [1, 2, 3][0]; echo "\n";
echo 'String dereferencing: '; echo 'PHP'[0]; echo "\n";
Array dereferencing: 1 String dereferencing: P
Osztály név feloldás
Lehetőség van a ClassName::class használatára a "fully qualified name of class" eléréséhez.
namespace Name\Space; class ClassName {}
echo ClassName::class;
echo "\n";
Name\Space\ClassName
foreach nem skalár kulcsok
A foreach támogatja a nem skalár kulcsokat. Az Iterator::key() bármilyen típust visszaadhat, ami egy PHP tömb kulcsaként szerepelhet.
Újítások PHP 5.5-ről 5.6-re
Konstant skalár kifejezések
Lehetőség van konstans skalár kifejezések használatára
const ONE = 1; const TWO = ONE * 2;
class C {
const THREE = TWO + 1; const ONE_THIRD = ONE / self::THREE; const SENTENCE =
'The value of THREE is '.self::THREE;
public function f($a = ONE + self::THREE) {
return $a;
}
}
echo (new C)->f()."\n"; echo C::SENTENCE;
4 The value of THREE is 3
Változó paraméterszámú függvények
Már nem csak a func_get_args() függvény használatával lehet változó paraméterszámú függvényeket használni, hanem a ... operátorral is.
function f($req, $opt = null, ...$params) {
// $params is an array containing the remaining arguments.
printf('$req: %d; $opt: %d; number of params: %d'."\n",
$req, $opt, count($params));
}
f(1); f(1, 2); f(1, 2, 3); f(1, 2, 3, 4); f(1, 2, 3, 4, 5);
$req: 1; $opt: 0; number of params: 0 $req: 1; $opt: 2;
number of params: 0 $req: 1; $opt: 2; number of params: 1 $req: 1; $opt: 2;
number of params: 2 $req: 1; $opt: 2; number of params: 3
Argument unpacking via ...
Tömbök és Traversable objektumokat is ki lehet csomagolni argumentum listába függvények hívásakor a ... operátor használatával. Ez más nyelvekben, mint példál a Ruby-ban "splat operator"-nak nevezik.
function add($a, $b, $c) {
return $a + $b + $c;
}
$operators = [2, 3]; echo add(1, ...$operators);
6
Hatványozás a ** operátorral
A jobb asszociatív ** operátor az hatványozás támogatására szolgál, a **= rövidített értékadó operátorral együtt. printf("2 ** 3 == %d\n", 2 ** 3); printf("2 ** 3 ** 2 ==
%d\n", 2 ** 3 ** 2);
$a = 2; $a **= 3; printf("a == %d\n", $a);
2 ** 3 == 8 2 ** 3 ** 2 == 512 a == 8
use function és use const
A use operátor lehet használni függvények és konstansok és osztályok importálására is.
namespace Name\Space {
const FOO = 42; function f() { echo __FUNCTION__."\n"; }
}
namespace {
use const Name\Space\FOO; use function Name\Space\f;
echo FOO."\n"; f();
}
42 Name\Space\f