WordPress как на ладони
wordpress jino

Синтаксис PHP 5.3, 5.4, 5.5, 5.6, 7 — что нового?

В этой статье я рассмотрю интересные моменты в развитии синтаксиса PHP - получится своего рода список изменений PHP. Что появилось в версиях PHP 5.3 и выше. Основная цель этой статьи создать некую карту изменений синтаксиса, что можно было быстро освежить в памяти «фишки» синтаксиса PHP, которые упрощают коддинг. У меня в последнее время частенько возникает необходимость убедиться, что можно в PHP 5.3, а чего нельзя.

При написании плагинов или тем WordPress можно использовать только возможности PHP 5.3, выше пожалуй не стоит... Все что можно в PHP 5.4 и выше, нужно решать через создание вспомогательных переменных. Впрочем, даже 5.3 не всегда работает, есть еще серверы с PHP 5.2, но хорошо что это редкость. К слову, сам WordPress еще поддерживает PHP 5.2.

Итак, к новинкам...

Оглавление:

До PHP 5.3

$str1{0} — синтаксис получения символа строки

Новый синтаксис обращения к символам строки:

// получение символа
$str = 'abc'; 
echo $str{0}; //> a
echo $str{1}; //> b
echo 'abc'{1}; //> b

// установка символа
$str1 = $str2 = 'ff';
$str1{0} = 'a';
echo $str1; //> af
$str2[0] = 'a'; // этот синтаксис не рекомендуется
echo $str2; //> af

$str2[0] не рекомендуется, хотя и работает точно также. Рекомендация использовать фигурные скобки {} связана с тем, чтобы при прочтении кода было сразу понятно, что обрабатывается строка, а не элемент массива. Как мы знаем квадратными скобками в PHP принято обозначать массивы, а не строки.

PHP 5.3

В PHP 5.3, как и во всей пятой ветке PHP, включена новая машина-интерпретатор скриптов Zend Engine 2.0. Благодаря этому PHP стал работать быстрее примерно на 15-20%.

Новые возможности в PHP 5.3 (ссылка на офф. сайт):

?: — сокращение тернарного оператора

С PHP 5.3 стало возможным не писать среднюю часть тернарного оператора. Выражение expr1 ?: expr3 возвращает expr1 если expr1 не пустой, и expr3 в противном случае.

Тернарный — состоящий из трёх частей, компонентов.

$a = $expr1 ?: $expr3;
// равносильно записи:
$a = $expr1 ? $expr1 : $expr3;

Пример тернарного оператора:

// полная запись
if ( $a > 100 )
	$result = "Больше";
else
	$result = "Меньше";

// краткая запись
$result = $a > 100 ? "Больше" : "Меньше";

В короткой записи есть еще момент производительности, например:

// полная запись
if ( get_post_meta(25, 'meta_key', 1) )
	echo esc_html( get_post_meta(25, 'meta_key', 1) );
else
	echo 'Мета поля нет';

// краткая запись
echo esc_html( get_post_meta(25, 'meta_key', 1) ?: 'Мета поля нет' );

В полной записи функция get_post_meta() вызывается 2 раза. В короткой один раз, и если она что-то вернула, второму аргументу сразу передается полученное значение: не нужны дополнительные переменные...

$func = function(){}; — анонимные (лямбда) функции

Лямбда-функции еще называют «анонимными функциями», потому что для них не указывается название.

Лямбда-функции представляют собой замыкание (англ. closure) — это особый вид функции, которая определена в теле другой функции и создаётся каждый раз во время её выполнения. Синтаксически это выглядит как функция, находящаяся целиком в теле другой функции. Насколько я понял, любая функция — это замыкание текущего контекста, т.е. контекст не будет очищен пока работает функция. Но если в функции есть лямбда-функция, то она становится замыканием, и если в неё передаются переменные из «верхней» функции, то они не будут очищены, до тех пор пока работает вложенная-функция, даже если «верхняя» функция работу закончила...

В ранних версиях, анонимные функции создавались с помощью функции create_function().

Пример создания анонимной функции для сортировки usort():

$arr = array(3, 2, 5, 6, 1);

usort( $arr, function($a, $b) {
	if ( $a == $b )
		return 0;

	return ( $a > $b ) ? -1 : 1;
});

Еще одна фишка лямбда-функций — это использование переменных из текущей области видимости, с помощью оператора use:

$var = 'Превед, Медвед!';
$func = function() use ( $var ) { echo $var; };
$func(); //> Превед, Медвед!

Переменные передаются как значение, но можно передать и ссылку на переменную, указав &:

$var = 'Превед, Медвед!';
$func = function() use ( & $var ) { $var = $var .' Мы в гости!'; };
$func(); // вызовем
echo $var; //> Превед, Медвед! Мы в гости!

method()->var — получение объекта из метода/функции

Это удобно:

$object->method()->method()->method(); 
$object->method()->method()->member = 5;

В PHP ниже 5.3 писали как-то так:

$tmp = & $object->method();
$tmp = & $tmp->method();
$tmp->method();

<<<'DOC' — поддержка NOWDOC

В php 5.3 можно использовать аналог HEREDOC, который называется NOWDOC. Особенность его в том, что внутри него переменные остаются простым текстом, как если бы мы указали её в строке с одинарными кавычками: 'текст $foo':

$foo = 'Лето';

// HEREDOC был в 5.2
$str = <<<DOC
	Текст с переменной '$foo'
DOC;

echo $str; // Текст с переменной 'Лето'

// NOWDOC появился в 5.3
$str = <<<'DOC'
	Текст с переменной '. $foo .'
DOC;

echo $str; // Текст с переменной '. $foo .'

namespace — поддержка пространств имен

Пространства имен нужны, чтобы избежать конфликтов при совпадении названий функций/классов/переменных/констант. Если коротко: одинаковые называния в разных пространствах — это разные названия.

Пример ниже должен объяснить почти все, что возможно в пространствах имен. За подробностями идем в официальную документацию.

<?php
#
# Объявлять пространство нужно в самом начале файла содержащего пространство имен,
# т.е. до любого кода, кроме зарезервированного declare(encoding='...');. 
# Также ничего не должно выводиться на экран до объявления пространства
# Одно и тоже пространство имен можно определять в разных файлах. Так эти файлы будут относиться к одному пространству

# Объявляем пространство my\name
namespace my\name;

## Динамичное получения названия пространства --------------
$s = __NAMESPACE__; //> my\name
$s = __NAMESPACE__ . '\HELLO'; //> my\name\HELLO
// namespace: есть еще специальное слово namespace, которое используется для динамичного
// получения названия текущего пространства при вызове функций/методов/констант (см. ниже)

## ГЛОБАЛЬНЫЕ функции/классы/константы в нашем пространстве --------------
$s = strlen('hi');           // вызовет my\name\strlen() - если функция есть в нашем пространстве, иначе глобальную функцию strlen()
define('HELLO', 'HI всем');  // добавит константу в глобальное пространство "\HELLO"

# Доступ к глобальным классам/функциям/константам из пространства имен
$a = \strlen('hi'); // вызывает глобальную функцию strlen()
$b = \ABSPATH;      // получает доступ к глобальной константе ABSPATH
$c = new \WP_Query; // создает экземпляр глобального класса WP_Query

## ФУНКЦИЯ в нашем пространстве --------------
function my_func(){ return 'Моя функция'; }

// Вызов
my_func();           //> "Моя функция"
namespace\my_func(); //> "Моя функция"
\my\name\my_func();  //> "Моя функция"
// my\name\my_func();   //> ошибка: будет вызвана функция my\name\my\name\my_func()
						// такой синтаксис можно использовать для доступа к под-пространствам нашего пространства

## ФУНКЦИЯ в нашем пространстве, которая существует в глобальном --------------
function trim( $str ){
	return \trim( $str, '-' ); # если вызвать trim( $str, '-' ), то функция вызовет сама себя...
}

// Вызов
$s = trim('-foo');           // вызов trim() из текущего пространства. Выведет: foo
$s = \my\name\trim('-foo');  // тоже что в строке выше
$s = namespace\trim('-foo'); // тоже что в строке выше

$s = \trim('-foo'); // вызов trim() из глобального пространства. Выведет: -foo

## КОНСТАНТЫ в нашем пространстве --------------
const HELLO = 'HI';                     // добавим константу в текущее пространство
define('my\name\HELLO', 'HI');          // тоже что в строке выше
define(__NAMESPACE__ . '\HELLO', 'HI'); // тоже что в строке выше

// Вызов
$s = HELLO;           //> HI - если константа есть в текущем пространстве, или значение глобальной константы
$s = \my\name\HELLO;  //> HI
$s = namespace\HELLO; //> HI
$s = \HELLO;          //> HI всем - глобальная константа HELLO

## КЛАСС в нашем пространстве --------------
class MyClass {
	function method(){ return 'метод MyClass'; }
	static function static_method(){ return 'статический метод MyClass'; }
}

// Вызов
$a = new MyClass;            // обращение к MyClass из текущего пространства
$a = new \my\name\MyClass;   // тоже что в строке выше

$s = namespace\MyClass::static_method(); //> 'статический метод MyClass' - вызывает статический метод "static_method" класса my\name\MyClass. 
$s = $a::static_method();                // тоже что в строке выше

$s = $a->method();                       //> 'метод MyClass' - вызывает метод "method" класса my\name\MyClass
										 // namespace\MyClass->method() - такой вызов метода, вызовет ошибку - syntax error

## ВНЕДРЕНИЕ функций/методов/констант в наше пространстве из других пространств --------------

// ЗАМЕТКА: операторы use можно комбинировать: указывать через запятую
// Например: use other\name\OtherClass as Another, other\name\NSname;

use other\name\OtherClass as Another;
$obj = new Another; // создает объект класса other\name\OtherClass

use other\name; // теперь name = other\name
name\other_func(); // вызывает функцию other\name\other_func();

// импорт глобального класса
use WP_Query;
$a = new WP_Query(); // создаст экземпляр класса WP_Query
					 // без выражения "use WP_Query;" создавался бы экземпляр my\name\WP_Query

// импорт функции (PHP 5.6+)
use function other\name\other_func;
$s = other_func(); //> "Другая Функция" - работа функции other\name\other_func()

// импорт функции под псевдонимом func (PHP 5.6+)
use function other\name\other_func as func;
$s = func();         //> "Другая Функция" - работа функции other\name\other_func()

//const other\name\HELLO2 = 'И снова здрасте!'; // вызовет ошибку синтаксиса, что странно
define('other\name\HELLO2', 'И снова здрасте!');

// импорт константы (PHP 5.6+)
use const other\name\HELLO2;
$s = HELLO2; //> "И снова здрасте!" - содержимое константы other\name\HELLO2

## ЕЩЕ ОДНО ПРОСТРАНСТВО в одном файле --------------
// Подробнее: http://php.net/manual/ru/language.namespaces.definitionmultiple.php

namespace other\name;

class OtherClass {}
function other_func() { return 'Другая Функция'; }

// При описании нескольких пространств в одном файле лучше использовать синтаксис со скобками:
/* 
namespace MyProject {
	function connect() {}
}

namespace AnotherProject {
	function connect() {}
}
*/

__DIR__ — новая магическая константа

__DIR__ содержит директорию текущего файла - файла в котором она используется. Возвращает полный путь до текущего файла без закрывающего слэша, за исключением корневой директории.

__DIR__ можно заменить:

dirname(__FILE__)

$class::$foo — динамичное указание класса

Это дает динамичный доступ к статическим методам/свойствам класса:

class C {
	static $foo = 'foo';
}

$class = 'C';
echo $class::$foo; //> foo

const — ключевое слово для создания констант вне классов

Сразу пример, где все понятно:

define('SHORTINIT', 'true');

// теперь можно объявить константу и так:
const SHORTINIT = 'true';

В отличие define(), такие константы, должны быть объявлены в самой верхней области видимости, потому что они определяются при компилировании скрипта. Это значит, что их нельзя объявлять внутри функций/циклов/выражений if или try/ catch блоков.

static::method() — статическое связывание

Статическое объявление метода/свойства связывает его с классом из которого оно вызывается, а не с тем в котором оно зарегистрировано. Посмотрим на примере:

class A {
	static function who() {
		echo __CLASS__;
	}

	static function test1() {
		self::who();
	}

	static function test2() {
		static::who(); // статическое связывание
	}
}

class B extends A {
	static function who() {
		echo __CLASS__;
	}
}

echo B::test1(); //> A
echo B::test2(); //> B
echo B::who(); //> B

Подробнее про статическое связывание читайте в документации.

goto hell; — оператор goto

Используется для перехода в другую часть программы. Место, куда необходимо перейти указывается с помощью метки, за которой ставится двоеточие, после оператора goto указывается желаемая метка для перехода.

Целевая метка должна находиться в том же файле, в том же контексте. Т.е. нельзя выйти за границы функции или метода, а значит нельзя перейти внутрь любой функции.

Также нельзя перейти внутрь любой циклической структуры или оператора switch. Но можно выйти из любой циклической структуры, поэтому «goto» удобен как замена многоуровневых break.

Пример использования goto:

function zayac(){
	$i = 1;
	$out = '';
	start: $out .= ($i > 1 ? '-' : '' ) .$i;

	if( $i++ < 5 ){ goto start; }

	return $out . ' вышел зайчик погулять';
}

echo zayac(); //> 1-2-3-4-5 вышел зайчик погулять

Пример использования goto в цикле:

for( $i=0, $j=50; $i<100; $i++ ) {
	while( $j-- ) {
		if( $j==17 ) goto end; 
	}  
}
echo "i = $i"; // будет пропущено

end: echo 'j дошло до 17';

__callStatic(), __invoke() — магические методы

__callStatic() — срабатывает, когда вызывается несуществующий метод из статического контекста: Foo::bar():

class A {
	static function __callStatic( $name, $args ){
		return $name .' '. print_r( $args, 1 );
	}
}
echo A::no_matter_what('bar');
/* Выведет:
no_matter_what Array
(
	[0] => bar
)
*/

__invoke() — срабатывает, когда объект выполняется как функция: $obj():

class A {
	function __invoke( $var ){
		var_dump( $var );
	}
}
$obj = new A;
$obj('foo'); //> string(3) "foo"

PHP 5.4

Возможности, добавленные в версии PHP 5.4. Ссылка на офф. сайт.

<?= — короткая запись вывода на экран работает всегда

Короткая запись о которой идет речь это: <?= вместо <?php echo.

Для работы такой короткой записи вывода на экран в версиях ниже 5.4 нужно было, чтобы опция short_open_tag в php.ini была включена.

Пример длинной и короткой записи:

<a href="#"><?php echo $page ?></a>
<a href="#"><?= $page ?></a>

[1,2] — запись массива, без слова array

$a = [1, 2, 3, 4]; 
$a = ['one' => 1, 'two' => 2, 'three' => 3, 'four' => 4];. 

trait Class {} — примеси (трейты)

Трейт - это аналог класса, который содержит в себе методы. Нужен он для «подмешивания» его в имеющийся класс, чтобы методы трейта стали методами класса в который он добавлен.

Несколько примесей можно задавать через запятую:

trait TR_A {
	public $var = 'var';
	function foo() { return 'foo'; }
}

trait TR_B {
	function bar() { return 'bar'; }
}

class A {
	use TR_A, TR_B; // подмешиваем

	function hello() { return 'hello A'; }
}

$A = new A();
echo $A->foo();   // foo
echo $A->bar();   // bar
echo $A->hello(); // hello A
echo $A->var;     // var

class B extends A {
	use TR_A, TR_B;

	function hello() { return 'hello B'; }
}

$B = new B();
echo $B->foo();   // foo
echo $B->bar();   // bar
echo $B->hello(); // hello B

Приоритеты трейтов

При совпадении названий свойств/методов приоритеты расставляются так: текущий класс имеет наивысший приоритет, затем трейт, а затем расширяемый класс. Другими словами: элементы из текущего класса переопределяют элементы в трейте, которые в свою очередь переопределяют унаследованные элементы.

Статический доступ к методу примеси из класса

Когда в класс подмешивается trait, то его методы становятся методами класса, включая статические и статический доступ:

trait A {
	static function func(){ echo 'A'; }
}

class B {
	use A;
}

B::func(); //> A

Подробнее про трейты читайте в документации

foo()[0] — быстрое получение элемента массива

Теперь не нужно сохранять массив, который вернула функция/метод в переменную и получать элемент массива из этой переменной. Можно сразу получать элемент из функции/метода:

$foo = func()[0];
$foo = Class::func()[0];

(new Foo)->method() — доступ к элементу объекта при его создании

$foo = (new Foo)->method();
$foo = (new Foo)->property;
$foo = (new Foo)[0];

// было так
$obj = new Foo;
$foo = $obj->method();

Class::{'foo'}() — динамичное указание метода

Чтобы вызвать статический метод/свойство класса, не нужно запоминать его в отдельную переменную:

class A {
	static function foo() {
		echo "Hello world!";
	}
 }
 $x = "f";
 A::{ $x .'oo' }();

callable — новый тип для аргументов функции/метода

Авто-проверка передаваемых данных в функции/методы, известная как «контроль типа» (typehint), продолжает развиваться и теперь понимает слово callable.

Раньше для автоматической проверки типа передаваемого параметра, в аргументах функции/метода можно было указывать только: array или имя класса.

Теперь, можно указать еще: callable — значит, что передаваемый аргумент должен быть вызываемым, т.е. удовлетворяет условию is_callable( $arg, false ).

Пример:

function func( callable $callback ){
	return true;
}

func('trim'); //> true

func( function(){} ); //> true

$db = new wpdb();
func( array($db, 'query') ); //> true

func('my_trim'); //> fatal error: Argument 1 passed to func() must be callable, string given

@ — улучшена производительность

Оператор @ нужен для подавления вывода ошибок любого уровня. Вообще его использовать не рекомендуется, но иногда с ним короче:

if( @ $_GET['foo'] ) echo 'OK';

// или так
if( isset($_GET['foo']) && $_GET['foo'] )  echo 'OK';
// раньше так работало быстрее раз в 20, теперь раз в 5

Использовать @ нужно как можно реже и очень осторожно, потому что часто заметки и предупреждения дают понять, что логика кода работает неправильно. Например, у меня бывало что лезу поправить казалось бы безобидный NOTICE, но при анализе выясняется что ошибка появилась из-за неправильной логики кода, которая изменилась в процессе расширения кода...

PHP 5.5

Новые возможности в PHP 5.5 (ссылка на офф.сайт):

[1,3,4][2], "foobar"{2} — разыменования только-созданных массивов и строк

echo array(1, 2, 3)[0]; // 1
echo [1,3,4][2];        // 4
echo "foobar"{2};       // o
echo "foobar"[0]        // f

// это может пригодиться для быстрой генерации:
echo 'abcdefghijk'{ rand(0,10) }; // получим одну из букв: 'abcdefghijk'

empty() — можно применять к результатам функций и выражений

Раньше empty() мог принимать только переменные, теперь можно передавать сами выражения без необходимости сохранять результат в отдельную переменную:

empty( $object->get() );

list() в foreach

В foreach стало возможным использовать list():

$array = [
	[1, 2],
	[3, 4],
];

foreach( $array as list($a, $b) ){
	echo $a;
	echo $b;
}
// получим: 1234

finally — в конструкции try/catch

Выбрасывать и ловить исключения можно с PHP 5. Такой подход позволяет контролировать выполнение кода, если есть подозрение, что в нем что-то может пойти не так.

А с версии 5.5. в эту конструкцию добавили третий блок finally. Блок finally выполняется всегда после завершается конструкции try/catch. Он выполняется даже когда код try вызвал фатальную ошибку:

try { 
	echo 'Тут что-то деламе... ';
	// выбрасываем
	throw new Exception('Лови меня! ');
}
// ловим
catch( Exception $e ){
	echo $e->getMessage(); // выведет: Лови меня!
}
finally {
	echo 'А это выводиться всегда!';
}

Нужен finally для удобства, и дополнительных возможностей. С ним можно будет писать меньше кода и можно, например, удобно чистить память, когда это нужно.

Пару домонстрационных примеров:

Меньше кода

Допустим, нам нужно выполнить функцию close() в любому случае, было выброшено исключение или нет:

try { 
	my_function();
}
catch( Exception $e ){
	// close(); // эта строка нужна была бы без finally
	echo $e->getMessage(); // выведет: Лови меня!
}
finally {
	close();
}
//close(); // эта строка нужна была бы без finally

Больше возможностей

Допустим мы открыли соединение с БД до выполнения кода и есть вероятность что код вызовет ошибку и открытое соединение не закроется, а нам нужно его закрыть в любом случае. finally как раз кстати:

$db = mysqli_connect();

try {
   my_function( $db ); // результат работы функции может вызвать фатальную ошибку...
}
// исключение можно не обрабатывать
finally {
   mysqli_close($db);
}

Подробнее про finally читайте статью на хабре.

Class::class — для получение имени класса в пространствах

Появилось ключевое слово class для классов, которое выводит название класса. В обычном режиме нам это не нужно, а вот при работе с пространствами (namespace) — это удобно:

namespace test;
class A {}

echo A::class; //> test\A

yield — создание генераторов

Если говорить простым языком: yield похожа на return, она также возвращает значение, но она не обрывает работу функции, а приостанавливает её до тех пор пока не будет запрошено следующее значение. Благодаря этому создавать генераторы стало удобнее.

Пример генератора:

function generator() {
	for( $i = 1; $i <= 3; $i++ ){
		yield $i; // выброс значения
	}
}

foreach( generator() as $value ){
	echo "$value ";
}
// выведет: '1 2 3 '

Как это работает на самом деле?

yield возвращает специальный объект — Generator. Когда функция generator() вызывается в цикле, например foreach, PHP выполнит код функции до первой встречи слова yield, на котором PHP прервет работу функции, запомнит позицию и выбросит значение (объект Generator). Затем, foreach обработает значение и вызовет метод next() у полученного объекта Generator. PHP снова выполнит код функции generator(), только начнет его не с начала, а с прошлой позиции, и опять, до слова yield, которое опять выбросит объект Generator. Работа цикла прервется тогда, когда функция generator() дойдет до конца (не вернет yield), или если она будет прервана с помощью return;.

Пример генератора который возвращает пару: ключ/значение:

function generator( $input ){
	foreach( explode('.', $input) as $part ){
		list( $num, $name ) = explode(' - ', $part );

		yield $num => trim($name);
	}
}

$input = '1 - один. 2 - два. 3 - три';

foreach( generator( $input ) as $num => $name ){
	echo "$num ($name) ";
}

Кратко о генераторах

— Не добавляют нового функционала в язык
— Быстрее
— Возобновление работы генератора происходит с последнего «выброса» yield
— В генератор можно отправлять значения и исключения (через метод throw())
— Генераторы однонаправлены, т.е. нельзя вернуться назад
— Меньше кода в большинстве случаев, более простые для понимания конструкции

Чтобы лучше понять генераторы прочитайте эту статью на Хабре.

Подробно о генераторах в документации (англ.)

API для хэширования паролей

Теперь PHP из коробки предлагает правильный способ хэшировать пароли. Новый API хэширования паролей предоставляет четыре функции:

  1. password_hash() — используется для хэширования пароля. В WP для этого есть своя функция wp_hash_password().

    $hash = password_hash( $passwod, PASSWORD_DEFAULT );
  2. password_verify() — используется для проверки пароля на соответствие хэшу. В WP для этого есть своя функция wp_check_password().

    if( password_verify( $password, $hash ) ){
    	// Success!
    }
  3. password_needs_rehash() — используется для проверки необходимости создать новый хэш.

  4. password_get_info() — возвращает имя алгоритма хеширования и различные параметры, используемые при хэшировании.

Подробнее читайте в статье на хабре.

PHP 5.6

Новые возможности PHP 5.6. Ссылка на офф.сайт.

const PLUS = 1 + 2; — скалярные выражения в константах/свойствах/аргументах функции

Теперь стало возможным указывать в значения констант примитивные PHP выражения (выражения из скаляров).

Точнее, новинка касается не только констант, а всего где раньше PHP ожидал статическое значение. Теперь вместо статики можно указать выражение из чисел/строк/констант. Если точнее, то PHP выражение можно указывать: в константах/свойствах класса и в значении аргумента функции по умолчанию.

const ONE = 1;
const TWO = ONE * 2;

class C {
	const THREE = TWO + 1;
	const ONE_THIRD = ONE / self::THREE;
	const SENTENCE = 'Значение THREE равно '. self::THREE;

	public function f( $a = ONE + self::THREE ){
		return $a;
	}
}

echo (new C)->f() .' - '. C::SENTENCE; //> 4 - Значение THREE равно 3

const ARR = ['a', 'b']; — константа может хранить массив

Стало возможным держать в константе массивы:

const ARR = ['a', 'b'];

echo ARR[0]; //> a

func( ...$args ) или func( ...[2, 3] ) — неизвестное число аргументов функции или распаковка массива с помощью '...' (splat оператор)

Когда мы не знали заранее, сколько параметров может получить функция, нам приходилось внутри функции обрабатывать переданные параметры с помощью специальных функций: func_num_args(), func_get_arg(), func_get_args().

Теперь они не нужны и мы можем получить все параметры в одной переменной, для этого перед этой переменной нужно указать оператор ...:

function sum( ...$numbers ){
	$plus = 0;
	foreach( $numbers as $n ){
		$plus += $n;
	}
	return $plus;
}

echo sum(1, 2, 3); //> 6

Оператор ... еще называют «Splat Оператор», например в языке Ruby

Еще пример:

function func( ...$numbers ){
	return print_r( $numbers, 1 );
}

echo func(1, 2, 3);
/*
Получим:
Array
(
	[0] => 1
	[1] => 2
	[2] => 3
)
*/
Быстрая распаковка передаваемых параметров функции

Теперь с помощью splat оператора ..., можно указать параметры функции сразу из значений массива:

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

$array = [2, 3];
echo plus( 1, ...$array ); //> 6

// или так
echo plus( 1, ...[2, 3] ); //> 6
Замена медленной функции call_user_func_array()

Теперь call_user_func_array(callable $callback, array $param_arr), которая обычно не самая быстрая, можно заменить так:

$params = [1, 2, 3];
$callback( ...$params );

Пример: известная своим неторопливым временем исполнения функция
call_user_func_array(callable $callback, array $param_arr)
может быть заменена на

** — оператор возведения в степень

До php 5.6, чтобы возвести число в степень нужно было использовать функцию pow(2,2);, а теперь есть оператор **:

// пример 1
echo $a = 2 ** 2; //> 4

// пример 2
$a = 2;
echo $a **= 2; //> 8

// пример 3
echo $a = 2 ** 3 ** 2; //> 512 = 2^9

use function и use const — импорт функций и констант в пространство

Теперь стало возможным при помощью ключевого слова use подключать функции или константы другого пространства в наше:

namespace our\space {
	const FOO = 42;
	function func() { echo __FUNCTION__; }
}

namespace my\space {
	use const our\space\FOO;
	use function our\space\func;

	echo FOO .' - '. func(); //> 42 - our\space\func
}

-

Остальные новинки PHP 5.6 не связанные с синтаксисом, смотрите в статье на Хабре.

Куда делся PHP 6?

Умер не родившись... В ядро PHP 6 планировали внедрить полную поддержку юникода, но затея оказалась слишком амбициозной, а объем работ слишком велик. К тому моменту, когда это стало понятно, о PHP 6 уже было написано не мало статей. Чтобы не было путаницы, из-за того что новая версия стала преследовать совсем другие цели (производительность) и сильно отличалась по концепции от PHP 6, было решено пропустить PHP 6. Еще одной причиной стало наличие весомого количества недоделанного кода в репозитории PHP, который решили не трогать, чтобы тот в ответ тоже никого не трогал...

PHP 7

Что нового в PHP 7. Ссылка на офф.сайт.

3 декабря 2015 года было объявлено о выходе PHP 7. Новая версия основывается на экспериментальной ветке PHP, которая изначально называлась phpng (PHPNextGeneration - следующее поколение), и разрабатывалась с упором на увеличение производительности и уменьшение потребления памяти.

Самой важной новинкой стало изменение ядра интерпретатора: теперь он называется PHPNG (Next Generation). Благодаря PHPNG удалось увеличить скорость обработки скриптов почти в двое по сравнению с PHP 5.x. Так же появился более эффективный менеджер памяти.

Прирост в скорости на практике хорошо виден на этой картинке. А для WordPress прирост в скорости выглядит так:

php7-benchmark

Подробнее смотрите в тестах PHP 7

Синтаксические новинки PHP 7:

$a ?? '' — одновременная проверка isset и получение значения

Новый оператор слияния с NULL (NULL coalescing operator) ?? — это сокращение проверки isset и получения значения, если проверка пройдена.

Такая проверка часто была нужна в тернарном операторе ?::

// Получит значение $_GET['foo'], если переменная установлена или не пустая, иначе получит 'default'
$foo = $_GET['foo'] ?? 'default';

// Запись равносильна этой
$foo = isset($_GET['foo']) ? $_GET['foo'] : 'default';
// или этой
$foo = @ $_GET['foo'] ?: 'default';

// удобная проверка при получении $_GET параметра 
if( $_GET['foo'] ?? 0 ){ }
// раньше писали так
if( isset($_GET['foo']) && $_GET['foo'] ){ }

Так же, проверять можно по цепочке:

$foo = $_GET['foo'] ?? $_POST['foo'] ?? 'default';
// вернет: $_GET['foo'], если его нет, то $_POST['foo'], если нет, то 'default'

$a <=> $b — одновременное выполнение трех сравнений: больше, равно или меньше.

Новый оператор сравнения <=> — «spaceship operator». Сравнивает 2 переменные и возвращает результат сравнения в виде числа:

  • -1 — если в сравнении подходит первый символ оператора <
  • 0 — подходит второй символ =
  • 1 — подходит третий символ >
// Числа
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

// Дробные числа
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Строки
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1

Удобен для использования в колбэках для usort().

define('FOO', [1,2]); — передача массива константе через define()

Константы могут содержать массивы еще с PHP 5.6. Но тогда их можно было передавать только через ключевое слово const. Теперь их можно указывать еще и через define().

define('ANIMALS', ['dog', 'cat', 'bird']);

echo ANIMALS[2]; //> bird

use name\space\{A, B, C as c}; — группировка импорта при помощи use

Теперь для краткой записи, импорт данных в наше пространство можно группировать:

// PHP 7
use some\namespace\{ ClassA, ClassB, ClassC as C };
use function some\namespace\{ fn_a, fn_b, fn_c };
use const some\namespace\{ СonstA, ConstB, ConstC };

// тоже самое до PHP 7
use some\namespace\ClassA;
use some\namespace\ClassB;
use some\namespace\ClassC as C;

use function some\namespace\fn_a;
use function some\namespace\fn_b;
use function some\namespace\fn_c;

use const some\namespace\ConstA;
use const some\namespace\ConstB;
use const some\namespace\ConstC;

int, float, bool — новые типы для аргументов функции/метода

Авто-проверка типа передаваемых данных в функции/методы, известная как «контроль типа» (typehint), продолжает развиваться и теперь понимает скаляры: int, float, bool, string. Раньше понимались только типы: array, имя класса или callable (с версии 5.4).

Пример:

function foo( int $a, bool $b, callable $с, array $d, WP_Post $e ) {
	return var_dump( $a, $b, $c, $d, $e );
}

foo( 1, true, 'trim', array(1), get_post(1) );

/* выведет:
int(1)
bool(true)
NULL
array(1) { [0]=> int(1) }
object(WP_Post)#2660 (24) { ...данные объекта... }
*/

// если указать неверный тип:
foo( 'foo', true, 'trim', array(1), get_post(1) );
// Получим ошибку Fatal error: Argument 1 passed to A::foo() must be of the type integer, string given

Режим строгой типизации

Если указан тип int и передать строку '123' то проверка все равно будет пройдена, и php превратить строку в число.

function func( int $num ){
	var_dump( $num );
}
func('123'); //> int(123)

Но что, если нужно получать именно число 123? Для этого можно включить режим строгой типизации, поместив в самое начало файла такую строку:

declare(strict_types=1);

Это объявление должно быть первой строкой в файле, до выполнения какого-либо кода. Оно затрагивает только код файла и только вызовы и возвращаемые значения в этом файле.

Заметка: если строгая типизация указана в файле X, но не указана в файле Y и в файле Y вызывается функция из файла X. То вызов такой функции не будет подвержен строгой типизации!

Читайте по типизации статью на Хабре и вот еще интересная статья.

int, float, bool, array — указание возвращаемых типов для функции/метода

Указывать принимаемый тип, можно еще с версии PHP 5.3. А вот указать какой тип функция/метод должна вернуть доступно только с версии PHP 7. Тут понимаются все типы: string, int, float, bool, array, callable, self (в методах), parent (в методах) , Closure, имя класса, имя интерфейса.

Синтаксис:

function func( $var ): int{ /* код функции */ }
function func( $var ): string{  }
function func( $var ): float{  }
function func( $var ): bool{  }
function func( $var ): array{  }
function func( $var ): callable{  }
function func( $var ): Closure{  }
function func( $var ): WP_Post{  } // может вернуть только объект класса WP_Post

class A extends B {
	function func( $var ): self{ }
	function func( $var ): parent{ }    
}

Рабочие примеры:

// Пример 1:
function func( $var ): int {
	return $var;
}
echo func( 123 );    //> 123
echo func( 'asfd' ); //> вызовет ошибку: Fatal error: Uncaught TypeError: Return value of func() must be of the type integer, string returned

// Пример 2: Closure
function func(): Closure {
	return function( $var ){ return $var .' + 2 = 3'; };
}
echo func()( 1 ); //> 1 + 2 = 3

Возвращаемые типы при наследовании методов класса

При наследовании в классах, дочерние методы должны иметь такие же возвращаемые типы как и в родительском классе/интерфейсе:

class A {
	function func() : int {
		return 123;
	}
}
class B extends A {
	function func() : string {
		return '123';
	}
	// такое объявление функции вызовет ошибку:
	// Fatal error: Declaration of B::func(): string must be compatible with A::func(): int
	// т.е. тип int должен совпадать!
}

Навороченный пример того, как можно писать в PHP 7

Тут сразу несколько новинок:

  1. принимаемый и возвращаемый тип;
  2. объединение и распаковка параметров с помощью ...;
  3. пример создания анонимной функции с указанием возвращаемого типа данных.
function arraysSum( array ...$arrays ): array {
	return array_map( function( array $array ): int {
		return array_sum( $array );
	}, $arrays );
}

print_r(  arraysSum( [1,2,3], [4,5,6], [7,8,9] )  );
/*
Выведет:
Array
(
	[0] => 6
	[1] => 15
	[2] => 24
)
*/

foo()(), $a::$b::$c, $$foo->bar — единый синтаксис переменных: СЛЕВА НАПРАВО

Очень важная новинка! Теперь обращения к сложносочиненным переменным разбираются последовательно СЛЕВА НАПРАВО.

Примеры новых возможностей:

// можно не указывать комбинирующие скобки
$foo()['bar']()
[$obj1, $obj2][0]->prop
getStr(){0}

// поддерживает вложенность ::
$foo['bar']::$baz   // значение: ($foo['bar'])::$baz
$foo::$bar::$baz    // значение: ($foo::$bar)::$baz
$foo->bar()::baz()  // значение: ($foo->bar())::$baz

// поддерживает вложенные ()
foo()()        // вызывает результат вызова foo(): (foo())()
$foo->bar()()  // ($foo->bar())()
Foo::bar()()   // (Foo::bar())()
$foo()()       // ($foo())()

// Операторы над выражениями заключенными в ()
(function() { ... })() // IIFE синтаксис JS
($obj->closure)()
// и т.д.
(...)['foo']
(...)->foo
(...)->foo()
(...)::$foo
(...)::foo()
(...)()

// все операции по разименованию скаляров (не очень полезно)
"string"->toLower()
[$obj, 'method']()
'Foo'::$bar

Примеры разницы старого и нового распознавания:

// строка               // старое понимание       // новое понимание
$$foo['bar']['baz']     ${$foo['bar']['baz']}     ($$foo)['bar']['baz']
$foo->$bar['baz']       $foo->{$bar['baz']}       ($foo->$bar)['baz']
$foo->$bar['baz']()     $foo->{$bar['baz']}()     ($foo->$bar)['baz']()
Foo::$bar['baz']()      Foo::{$bar['baz']}()      (Foo::$bar)['baz']()

Старый код написанный с использованием {} для обработки переменных возможно не будет работать в новой версии PHP7.

foreach — изменена логика работы

Теперь foreach не переключает автоматически внутренний указатель перебираемого массива, т.е. next() не работает автоматически.

Так же, если значение массива передается в foreach по ссылке, то он всегда работает с оригиналом массива. Если значение не передается по ссылке, то foreach всегда работает с копией массива и оригинальный массив не затрагивается при изменении его внутри foreach.

Переключение указателей и влияние на работу цикла в PHP 7:

// Пример 1: автоматически не переключает внутренний переключатель next()
$a = [1,2,3];           foreach($a as $v)   { echo $v ."-". current($a) ." "; } // 1-1 2-1 3-1 (php5: 1-2 2-2 3-2)
$a = [1,2,3]; $b = &$a; foreach($b as $v)   { echo $v ."-". current($b) ." "; } // 1-1 2-1 3-1 (php5: 1-2 2-3 3-) 
$a = [1,2,3]; $b = $a;  foreach($b as $v)   { echo $v ."-". current($b) ." "; } // 1-1 2-1 3-1 (php5: 1-1 2-1 3-1) 
$a = [1,2,3];           foreach($a as & $v) { echo $v ."-". current($a) ." "; } // 1-1 2-1 3-1 (php5: 1-2 2-3 3-) 
// В PHP 7 все строки выведут один результат: 1-1 2-1 3-1
// В PHP 5 он будет разный

// Пример 2: внутренний переключатель можно переключить с помощью next()
$a = [1,2,3];           foreach($a as $v)   { echo $v ."-". current($a) ." "; next($a); } // 1-1 2-2 3-3 (php5: 1-2 2-3 3-)
$a = [1,2,3]; $b = &$a; foreach($b as $v)   { echo $v ."-". current($b) ." "; next($b); } // 1-1 2-2 3-3 (php5: 1-2 2-3 3-)
$a = [1,2,3]; $b = $a;  foreach($b as $v)   { echo $v ."-". current($b) ." "; next($b); } // 1-1 2-2 3-3 (php5: 1-2 2-3 3-) 
$a = [1,2,3];           foreach($a as & $v) { echo $v ."-". current($a) ." "; next($a); } // 1-1 2-2 3-3 (php5: 1-2 2-3 3-)
// В PHP 7 все строки выведут один результат: 1-1 2-2 3-3 
// В PHP 5 результат тоже будет один, но другой: 1-2 2-3 3- 

// Пример 3:
// при &$v foreach работает с оригиналом $a и изменение массива влияет на цикл
$a = [1,2,3];           foreach($a as &$v) { echo "$v "; unset($a[1]); } // 1 3 (php5: 1 3) 
$a = [1,2,3]; $b = &$a; foreach($b as &$v) { echo "$v "; unset($a[1]); } // 1 3 (php5: 1 3) 
// в PHP 5 и PHP 7 совпадают

// при $v foreach работает с копией $a и изменение массива НЕ влияет на цикл
$a = [1,2,3];           foreach($a as $v) { echo "$v "; unset($a[1]); } // 1 2 3 (php5: 1 2 3)
$a = [1,2,3]; $b = &$a; foreach($b as $v) { echo "$v "; unset($b[1]); } // 1 2 3 (php5: 1 3)
// в PHP 5 и PHP 7 результаты отличаются

$class = new class{} — анонимные классы

Анонимные классы позволяют делать тоже самое что и обычные классы: передавать данные в конструктор, наследовать другие классы, использовать трейты и т.п.

$class = new class {
	public function echo( $msg ){
		echo $msg;
	}
};
$class->echo('Привет!'); // выведет на экран: "Привет!"

Расширение классов работает как и ожидается:

class Foo {}

$child = new class extends Foo {};

var_dump( $child instanceof Foo ); //> true

Использование треитов:

trait Foo {
	public function method() {
	  return "bar";
	}
}

$class = new class {
	use Foo;
};

var_dump( $class->method() ); //> string(3) "bar"

Подробнее про анонимные классы читайте в документации и на wiki.php.net.

yield ... return 99; — возврат (return) выражений в генераторах

Функции-генераторы появились в PHP 5.5. Но там можно было использовать return, только чтобы прервать работу генератора. Теперь return может возвращать выражение (значение/массив/другой генератор), а не только NULL. Но сделать это можно только в конце работы генератора.

Получить возвращенное значение можно методом getReturn(), но только по завершении работы генератора.

Возможность явно вернуть последнее значение упрощает работу с генераторами:
теперь не нужно проверять является ли значение последним, а просто вызываем getReturn().

function gen() {
	yield 1;
	yield 2;

	return 3;
}

$gen = gen();

// если генератор еще ничего не вернул, то вызов такой строки
// echo $gen->getReturn();
// вызовет ошибку: Fatal error: Uncaught Exception: Cannot get return value of a generator that hasn't returned

foreach( $gen as $val ) {
	echo $val;
}

echo $gen->getReturn();

// результат работы этого кода выведет на экран: 123

Подробнее: Generator Return Expressions

yield from gen() — делегирование генераторов

Позволяет разбить сложный генератор на несколько простых.

Для этого используется новый синтаксис: yield from <expr>, где <expr> может быть значением (скаляром), массивом или другим генератором.

<expr> будет работать до тех пор, пока возвращает данные, затем выполнение продолжится в генераторе откуда <expr> был вызван. Смотрите пример:

function gen() {
	yield 1;
	yield from gen2();
	yield 4;
}

function gen2(){
	yield 2;
	yield 3;
}

$gen = gen();

foreach ( $gen as $val ) {
	echo $val;
}

// результат работы этого кода: 1234

Пример с массивом:

function g() {
  yield 1;
  yield from [2, 3, 4];
  yield 5;
}

$g = g();
foreach ( $g as $yielded ) {
	echo $yielded;
}

// выведет: 12345

Пример с return из дочернего генератора:

function gen() {
  yield 1;
  $sub_gen = yield from sub_gen();
  yield 4;

  return $sub_gen;
}

function sub_gen() {
  yield 2;
  yield 3;

  return 42;
}

$gen = gen();
foreach( $gen as $val ) {
	echo $val;
}
echo ' - '. $gen->getReturn();

// выведет: 1234 - 42

Подробнее: Generator Delegation

Еще новинки PHP 7.0

  1. Синтаксис конструкторов в стиле PHP 4 (имя метода конструктора совпадает с именем класса) теперь считается устаревшим.

  2. Статичные вызовы :: нестатичных методов теперь считаются устаревшими.

  3. list() — изменение поведения. В PHP 5, list() устанавливал значения начиная с правого крайнего значения указанного массива, в PHP 7 параметры устанавливаются начиная с левого крайнего значения массива. Так же в PHP 5 list() умела разбивать строки на символы, в PHP 7 не работает со строками вообще...

    // Пример 1: обратное чтение
    // Если используются обычные переменные, то разницы нет
    list( $a, $b, $c ) = ['apple', 'bannana', 'cherry', 'damson'];
    var_dump( $a, $b, $c ); // php5 и php7 вернут: apple bannana cherry
    
    // А вот если устанавливаются элементы массива, то порядок будет отличаться
    $arr = [];
    list( $arr['a'], $arr['b'], $arr['c'] ) = ['apple', 'bannana', 'cherry', 'damson'];
    print_r( $arr );
    /* 
    PHP 7
    Array
    (
    	[a] => apple
    	[b] => bannana
    	[c] => cherry
    )
    
    PHP 5
    Array
    (
    	[c] => cherry
    	[b] => bannana
    	[a] => apple
    )
    */
    
    // Пример 2: разбивание строк
    $str = 'ab';
    list( $a, $b ) = $str;
    var_dump( $a, $b );
    // В PHP 7: NULL NULL
    // В PHP 5: string(1) "a" string(1) "b"
  4. Поддержка юникод управляющих (escape-) последовательностей. Т.е. в строках "" и heredoc можно использовать конструкцию \uXXXX для создания юникод символа. Вот так:

    echo "\u{1F602}"; //> ?

    Подробнее читайте: Unicode Codepoint Escape Syntax

  5. Класс IntlChar. Cодержит методы и константы для работы с юникодом.

    printf('%x', IntlChar::CODEPOINT_MAX); // 10ffff
    
    echo IntlChar::ord('@'); //> 64
    echo IntlChar::chr( 64 ); //> @
    
    echo "\u{1F602}"; //> ?
    echo IntlChar::ord("\u{1F602}"); //> 128514
    echo IntlChar::chr( 128514 ); //> ?
  6. Функция intdiv() — делит 2 числа и возвращает только целую часть от деления:

    echo intdiv(10, 3); //> 3
    echo intdiv(5, 2); //> 2
  7. session_start() умеет получать параметры (стандартные настройки сессий из php.ini):

    session_start(['cache_limiter' => 'private']);
  8. Функция preg_replace_callback_array() — альтернатива preg_replace_callback(). Позволяет передать в качестве обратной функции - массив ['/regex'/ => callback, ...]:

    $str = 'a1a2a3';
    $array = [
    	'~[0-9]~' => function ( $m ){   return $m[0] * 2;   },
    	'~a~' => function ( $m ){   return $m[0] . '-';   }
    ];
    
    echo preg_replace_callback_array( $array, $str ); //> a-2a-4a-6  
  9. Можно использовать глобальные ключевые слова в названиях методов. Т.е. раньше нельзя было назвать метод словами: with/new/for/foreach/... — это приводило к ошибке. Теперь можно:
    Class::new('Project Name');
    $class->for('purpose here');

Подробнее о новинках PHP 7 читайте в этой статье и вторая часть.

PHP 7.1

void — возвращаемый тип

Теперь функции и методы, которые не должны ничего возвращать, можно помечать возвращаемым типом void. Оператор return при этом должен отсутствовать или должен быть пустым - return;. Вызов return null; вызовет ошибку.

function someMethod(): void {
	// работает если return отсутствует
	// работает с return;
	// не работает если return null;
	// не работает если return 123;
}

iterable — новый псевдо-тип

Введен новый тип iterable для передаваемых/возвращаемых значений. Может использоваться при передаче массивов или объектов, которые соответствуют интерфейсу Traversable.

function myfunc( iterable $data ){
	foreach( $data as $k => $v ){
		echo $k, ':', $v, PHP_EOL; 
	}
}

// массив
myfunc([10, 20, 30]); // 0:10 1:20 2:30

// объект
myfunc( new SplFixedArray(3) ) // 0: 1: 2:

// генератор
function myGen(){
	yield 10;
	yield 20;
	yield 30;
}
myfunc( myGen() ); // 0:10 1:20 2:30

Подробнее читайте по ссылке.

null — тип передаваемых/возвращаемых значений

В PHP 7.0 стало возможным указать тип возвращаемых/передаваемых значений, но типизация не допускала использование null в качестве значения параметра.

В PHP 7.1 для разрешения null-значений перед типом параметра указывается "?":

function myfunc(?int $i) : ?int {
  var_dump($a);
  return $a;
}

myfunc(20); // int(20)
myfunc(null); // null
myfunc(); // Ошибка: Uncaught Error: Too few arguments to function name(), 0 passed

Подробнее читайте по ссылке.

{-1} — отрицательное значение смещения в строках

Добавлена возможность использовать отрицательное значение для смещения в строках

echo $msg[-1]; // последний символ
echo $msg{-1}; // последний символ

['key'=>$a] = ['key'=>'Значение'] — поддержка ключей и новый синтаксис list()

Теперь, можно использовать новый синтаксис - аналог list(), в котором разрешено использовать строковые ключи:

['test'=>$a, 'name'=>$b] = ['name'=>'Hello', 'test'=>'World!'];
var_dump($a); // World!
var_dump($b); // Hello

Замена list():

list($one, $two) = ['один', 'два']; // list style
[$one, $two] = ['один', 'два']; // [] style
echo "$one, $two";

Область видимости констант в классах

Конец публичным константам, теперь для констант можно указать видимость:

class ConstClass {
	const CONST_ONE = 1; // public
	public const CONST_TWO = 2;
	protected const CONST_THREE = 3;
	private const CONST_FOUR = 4;
}

Заметки по PHP 7.1

PHP движется в сторону строгой типизации данных и при переходе на 7.1 я столкнулся с ФАТАЛЬНОЙ ошибкой. И мне это показалось очень странным. Приведу пример:

$foo = '';

$foo['bar'] = 'мир';   // Warning: Illegal string offset 'bar'

$foo['bar'][] = 'мир'; // Fatal error: Uncaught Error: Cannot use string offset as an array
					   // фатальная ошибка: нельзя использовать отступ строки как массив...

При Warning PHP еще работает, а дальше уже нет! А еще в 7.0 код просто работал, даже без предупреждений и нотисов... Похоже на недоработку в PHP 7.1.

К примеру, ошибка такого типа есть в популярном плагине WP Super Cache (отписал авторам, надеюсь скоро поправят).

Весь список изменение смотрите по ссылке и по этой.

Под какие версии PHP, вы пишите код чаще всего?

  • Добавить ответ
Синтаксис PHP 5.3, 5.4, 5.5, 5.6, 7 — что нового? 9 комментариев
  • campusboy1948 cайт: www.youtube.com/c/wpplus

    Спасибо за статью! Скажу пару слов про скорость. На хостинге есть возможность выставить разные версии php, в том числе и 7. Взял один свой сайт и стал тестить (версия, скорость генерации страницы в секундах, потребляемая память):
    1) php 5.3, 1.2 сек, 25-30МБ
    2) php 5.6, 0.2-0.3 сек, 10-12МБ
    3) php 7, 0.3-0.4 сек, 20-22МБ

    Так что пока остановился на php 5.6

    Ответить1.6 года назад #
    • Kama4639

      Странно, что PHP 7 так слабо себя показал, у меня прирост раза в 1.5.

      1
      Ответить1.6 года назад #
      • campusboy1948 cайт: www.youtube.com/c/wpplus

        Везет! У меня вот такая картина:

        6 числа поставил на всех сайтах php7. По графику видно, как CPU стал "напрягаться" больше, придётся вернуться на 5.6

        Один приятель мне как-то сказал:

        php7 будет рулить только с opcache

        Вот есть ли он на шаред-хостинге - большой вопрос smile

        Ответить1.6 года назад #
        • Родион

          Чтобы был прирост, необходимо переписать код на синтаксис php 7

          Ответить1.3 года назад #
          • campusboy1948 cайт: www.youtube.com/c/wpplus

            Надо дать такой совет разработчикам WP.

            Ответить1.3 года назад #
          • Kama4639

            По моему это не так. Там новый интерпретатор кода, синтаксис тут не при чем... У меня прирост на старом коде...

            1
            Ответить1.3 года назад #
            • campusboy1948 cайт: www.youtube.com/c/wpplus

              Не по твоему, а так и есть. Он без всяких переписки работает быстрее. К примеру, я давал свои значения на хостинге hostland. Сегодня мне пришлось поработать с хостингом webhost1. В режиме php 5.6 страницы wordpress генерируются одинаково по скорости, где-то 0,3-0,5 секунд. У hostland перевожу сайт на php7 - практически ничего не меняется (вместо 10Мб начинает потребляться 20Мб, скорость генерации почти такая же, даже чууууть медленне). Перевожу сайт на webhost1 на php7, потребляемая память падает с 20Мб до 10Мб, а скорость становится 0,06 секунды (!). Страницы генерируются мгновенно под админом, на сайте 8 000 статей, вывод миниатюр и все другие плюшки. Я просто не поверил глазам, что WP может так бодро работать. Эти показатели не дадут мне покоя, пока я не перееду на новый хостинг smile

              Ответить1.3 года назад #
      • Александр cайт: va-soft.ru

        Странно. У меня с переходом на 7ой на всех проектах (где был переход) производительность увеличилась до 2 раз, а потребление памяти снизилось

        Ответить3 месяца назад #

Здравствуйте, !

Ваш комментарий