O slideshow foi denunciado.
Utilizamos seu perfil e dados de atividades no LinkedIn para personalizar e exibir anúncios mais relevantes. Altere suas preferências de anúncios quando desejar.

PHP7 is coming

22.616 visualizações

Publicada em

PHP7 is coming

Publicada em: Internet

PHP7 is coming

  1. 1. PHP7 is coming in November 2015
  2. 2. Hello  Julien PAULI  PHP user for more than 10y now  Linux / Unix adopter  PHP Internals developper (C language)  PHP 5.5 / 5.6 Release Manager  Working at SensioLabs (Paris)  Likes writing tech articles/books  @julienpauli - jpauli@php.net  Blog at http://jpauli.github.io
  3. 3. PHP versions ?  PHP 5.3  Dead  PHP 5.4  Dead  PHP 5.5  Dead (sec fixes only)  PHP 5.6  Current version (Sept 2014), still current  PHP 7  Future version (end 2015)  Major version  PHP 8  2020 ?
  4. 4. Timeline  http://php.net/supported-versions.php 2004 2015 5.0 PHP 7.0 2005 2006 2009 5.1 5.2 5.3 5.4 2012 2013 2014 5.5 5.6
  5. 5. PHP 6 ?
  6. 6. PHP 6 ?
  7. 7. PHP 7
  8. 8. PHP 7
  9. 9. PHP 7 doctrines  We are in a new major, we may break things  Only majors are allowed to do so (starting from 5.4)  We are devs. we also need to refactor (like you)  Only break when it brings a significant advantage  Think about our users and their migrations  Do not fall into a Python2 vs Python3 war  We'll have PHP 7.1 etc.. and PHP 8.0, probably in 2020.
  10. 10. So ?  Functions arguments order will not be touched  Functions() won't be turned into objects->methods()  "Goto" will not disappear  And the earth won't just stop its rotation tomorrow
  11. 11. PHP 7 changes  Internal Engine evolutions (Zend Engine 3.0)  Perfs ++  32/64bits platform fully supported  Integer sizes  New parser based on an AST  Some syntaxes change with PHP5  Tidy up old things that were deprecated before  Many new features
  12. 12. PHP7 new user features  Exceptions to replace fatal errors  New language syntaxes  ?? operator  <=> operator  Group use  Return type declaration and scalar type hints  Anonymous classes  Other new features (Can't list all here)
  13. 13. PHP 7 new features
  14. 14. PHP 7 group "use" decl.  Group "use" declaration : use SymfonyComponentConsoleHelperTable; use SymfonyComponentConsoleInputArrayInput; use SymfonyComponentConsoleInputInputInterface; use SymfonyComponentConsoleOutputOutputInterface; use SymfonyComponentConsoleQuestionChoiceQuestion as Choice; use SymfonyComponentConsoleQuestionConfirmationQuestion; use SymfonyComponentConsole{ HelperTable, InputArrayInput, InputInputInterface, OutputOutputInterface, QuestionChoiceQuestion as Choice, QuestionConfirmationQuestion, };
  15. 15. PHP 7 ?? operator  ?? : Null Coalesce Operator $username = isset($_GET['user']) ? $_GET['user'] : 'nobody'; $username = $_GET['user'] ?? 'nobody';
  16. 16. PHP 7 <=> operator  Combined Comparison (Spaceship) Operator  (expr) <=> (expr) returns 0 if both operands are equal, -1 if the left is greater, and 1 if the right is greater function order_func($a, $b) { return ($a < $b) ? -1 : (($a > $b) ? 1 : 0); } function order_func($a, $b) { return $a <=> $b; }
  17. 17. PHP7 Errors and Exceptions
  18. 18. PHP7 Exceptions instead of fatals  The engine allows the user to try{}catch{} any call that may generate a fatal error  Every other error stays untouched, only fatals can now be caught  E_RECOVERABLE are turned to exceptions (most of them)  There is no more need to hack with user error handlers, just try-catch now  E_STRICT have been reclassified to E_WARN or E_NOTICE
  19. 19. PHP7 Exceptions instead of fatals  The engine now allows the user to try{}catch{} any call that may generate a fatal error foo(); try { foo(); } catch (Error $e) { /* haha */ }
  20. 20. PHP7 Exceptions instead of fatals  If the user doesn't catch the engine exception, this latter is back converted to a Fatal Error foo(); Fatal error: Uncaught Error: Call to undefined function foo() in /tmp/foo.php:2 Stack trace: #0 {main} thrown in /tmp/foo.php on line 2
  21. 21. PHP7 Exceptions instead of fatals  Some parse errors are catchable (ParseException), especially using eval(); try { $result = eval($code); } catch (ParseException $exception) { }
  22. 22. PHP7 Exceptions instead of fatals
  23. 23. PHP7 Exceptions instead of fatals  PHP errors inherit from Error  User exceptions inherit from Exception (no change)  To catch both, you may catch Throwable  Users can't inherit from Throwable directly try { foo(); } catch (Throwable $e) { /* catch any user defined Exception or catch any fatal Error */ }
  24. 24. PHP7 Closures  Closure::call(object $to, [mixed ...$params])  Allows to bind a Closure to a specific object at runtime  Won't work for internal classes : user classes only class Foo { public $bar; } $foo = new Foo; $foo->bar = 3; $foobar = function ($qux) { var_dump($this->bar + $qux); }; $foobar->call($foo, 4); /* int(7) */
  25. 25. PHP7 return type declaration  Functions may declare return types.  Types "null" and "resource" are not supported  Those are checked at runtime issuing Fatal errors function foo(): int { return []; } foo(); Fatal error: Return value of foo() must be of the type integer, array returned
  26. 26. PHP7 return type declaration  Functions may declare return types  Types "null" and "resource" are not supported  PHP will try to convert them when possible, if not, it issues a fatal error function foo($i): int { return $i; } var_dump(foo("123")); (int)123 var_dump(foo( ["123"] )); Fatal error: Return value of foo() must be of the type integer, array returned
  27. 27. PHP7 return type declaration  Call time variance type is allowed interface A { static function make(): A; } class B implements A { static function make(): A { return new B(); } }
  28. 28. PHP7 return type declaration  Compile time variance type is not allowed interface A { static function make(): A; } class B implements A { static function make(): B { return new B(); } } Fatal error: Declaration of B::make() must be compatible with A::make(): A
  29. 29. PHP7 scalar type hints  Scalar type hints are now allowed in functions arguments declarations  Type "null" and "resource" are not supported  https://wiki.php.net/rfc/scalar_type_hints_v5 function foo(int $i, string $j, bool $k) { }
  30. 30. PHP7 scalar type hints  By default, scalar type hints are not honored  The default behavior is that PHP ignores those scalar type hints, but not compound ones (like it used to do) function foo(int $i, string $j, bool $k) { } foo(1, 1, 1); /* OK */ function foo(int $i, array $j) { } foo('baz', 'bar'); Fatal error: Argument 2 passed to foo() must be of the type array, string given
  31. 31. PHP7 scalar type hints  PHP converts the scalar type hinted arguments function foo(int $i, string $j, bool $k) { var_dump(func_get_args()); } foo('12', 0, 'foo'); array(3) { [0]=> int(12) [1]=> string(1) "0" [2]=> bool(true) }
  32. 32. PHP7 scalar type hints  PHP converts the scalar type hinted arguments, only when this is possible , if not, it emits a fatal error function foo(int $i, string $j, bool $k) { var_dump(func_get_args()); } foo('foo', 0, 'foo'); Fatal error: Argument 1 passed to foo() must be of the type integer, string given
  33. 33. PHP7 scalar type hints errors  As Fatal Errors may now be catched, this can be used : function foo(int $i, string $j, bool $k) { var_dump(func_get_args()); } try { foo('foo', 0, 'foo'); } catch (TypeError $e) { echo $e->getMessage(); } Fatal error: Argument 1 passed to foo() must be of the type integer, string given
  34. 34. PHP7 scalar type hints  PHP however allows you to declare strict type hints  honored for every future call  no implicit conversion anymore  strict checks must be turned on at function call-time  strick checks are file-bound (not global)  declare() must be the first file statement function foo(int $i, string $j, bool $k) { } foo(1, 'foo', true); /* OK */ declare(strict_types=1); foo('1', 'foo', 'baz'); /* fatal */
  35. 35. PHP7 scalar type hints  strict mode is also relevant for return type hints : function foo(int $i) :string { return $i; } var_dump(foo("123 pigs")); string(3) "123" declare(strict_types=1); var_dump(foo(123)); Fatal error: Return value of foo() must be of the type string, integer returned
  36. 36. PHP 7 new type hints  Scalar type hints and return types are independant features, one may be used without the other  However, they are both affected by the strict mode  Strict mode is file based only, it doesn't affect other required files  Strict mode is disabled by default  Strict mode may be turned on for every function calls, it doesn't impact function declarations at all
  37. 37. Anonymous classes  Like anonymous functions var_dump( new class() { }); object(class@anonymous)#1 (0) { }
  38. 38. Anonymous classes  Like anonymous functions $obj->setLogger(new class implements Logger { public function log($msg) { print_r($msg); } }); interface Logger { function log($m); } class Bar { function setLogger(Logger $l) { } } $obj = new Bar;
  39. 39. PHP 7 new minor features  Added scanner mode INI_SCANNER_TYPED to yield typed .ini values  Added second parameter for unserialize() function allowing to specify acceptable classes  preg_replace_callback_array()  intdiv()  error_clear_last()  PHP_INT_MIN  random_bytes()  New assertion mechanism (more optimized, useful)  New session features (lazy writes, , read only ...)
  40. 40. PHP 7 breakages
  41. 41. PHP 7 breakage  Syntax changes that break  Removals  Behavior changes
  42. 42. PHP 7 Syntax changes  The compiler has been rewritten entirely  It is now based on an AST  You may use the AST using https://github.com/nikic/php-ast extension  Some syntax changes were necessary to support new features
  43. 43. PHP 7 Syntax changes  Indirect variable, property and method references are now interpreted with left-to-right semantics $$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']}() In PHP5
  44. 44. PHP 7 Syntax changes  list() allows ArrayAccess objects (everytime)  list() doesn't allow unpacking strings anymore  Other minor changes to list() ... list($a, $b) = (object) new ArrayObject([0, 1]); /* $a == 0 and $b == 1 */ $str = "xy"; list($x, $y) = $str; /* $x == null and $y == null */ /* no error */
  45. 45. PHP 7 Syntax changes  Invalid octal literals (containing digits > 7) now produce compile errors  Hexadecimal strings are not recognized anymore $i = 0781; // 8 is not a valid octal digit! /* Fatal error: Invalid numeric literal in */ var_dump("0x123" == "291"); var_dump(is_numeric("0x123")); var_dump("0xe" + "0x1"); bool(false) bool (false) int(0) bool(true) bool(true) int(16) In PHP5In PHP7
  46. 46. PHP 7 Syntax changes  The new UTF-8 escape character u has been added  Only added in heredocs and double-quoted strings (as usual)  Codepoints above U+10FFFF generate an error  https://wiki.php.net/rfc/unicode_escape echo "u{262F}"; u{262F} ☯ In PHP7In PHP5
  47. 47. PHP 7 Removals  Removed ASP (<%) and script (<script language=php>) tags  Removed support for assigning the result of new by reference  Removed support for #-style comments in ini files  $HTTP_RAW_POST_DATA is no longer available. Use the php://input stream instead.  bye bye call_user_method()/call_user_method_array() $a = &new stdclass; Parse error: syntax error, unexpected 'new' (T_NEW)
  48. 48. PHP 7 Removals  Removed support for scoped calls to non-static methods from an incompatible $this context  In PHP7, $this will be undefined in this case class A { function foo() { var_dump(get_class($this)); } } class B { function bar() { A::foo(); } } $b = new B; $b->bar();
  49. 49. PHP 7 Removals class A { function foo() { var_dump($this); } } class B { function bar() { A::foo(); } } $b = new B; $b->bar(); Deprecated: Non-static method A::foo() should not be called statically, assuming $this from incompatible context object(B) #1 Deprecated: Non-static method A::foo() should not be called statically Notice: Undefined variable: this in /tmp/7.php on line 4 In PHP5 In PHP7
  50. 50. PHP 7 Removals  Other removals into extensions :  Date  Curl  DBA  GMP  Mcrypt  OpenSSL  PCRE  Standard  JSON  Many old SAPI removed (Apache1, roxen, tux, isapi ...)
  51. 51. PHP 7 changed behaviors
  52. 52. PHP 7 changed behaviors  Redefinition of function argument is no longer allowed function foo($a, $b, $b) { } Fatal error: Redefinition of parameter $b in ...
  53. 53. PHP 7 changed behaviors  PHP4 constructor types now generate E_DEPRECATED, and will be removed in a next PHP  "Types" have been turned to reserved words against class/trait/interface names class Foo { public function foo() { } } /* E_DEPRECATED */ class String { } Fatal error: "string" cannot be used as a class name
  54. 54. PHP 7 changed behaviors  Some reserved keywords in class context however, can now be used  Into a class context, expect the parser to be smoother now :  But you still cannot declare a const named 'class' Project::new('Foo')->private()->for('bar'); class baz { private function private() { } public function const() { } public function list() { } const function = 'bar'; }
  55. 55. PHP 7 changed behaviors  func_get_arg() / func_get_args() now return the current scoped variable value function foo($x) { $x++; var_dump(func_get_arg(0)); } foo(1); (int)1 (int)2 In PHP7In PHP5
  56. 56. PHP 7 changed behaviors  Exception traces now show the current scoped variable values function foo($x) { $x++; throw new Exception; } foo(1); Stack trace: #0 /tmp/php.php(7): foo(1) #1 {main} Stack trace: #0 /tmp/php.php(7): foo(2) #1 {main} In PHP7In PHP5
  57. 57. PHP 7 changed behaviors  Left bitwise shifts by a number of bits beyond the bit width of an integer will always result in 0  Bitwise shifts by negative numbers will now throw a warning and return false var_dump(1 << 64); (int)1 (int)0 In PHP7In PHP5 var_dump(1 >> -1); (int)0 (bool)false Uncaught ArithmeticError In PHP7In PHP5
  58. 58. PHP 7 changed behaviors  Iteration with foreach() no longer has any effect on the internal array pointer $array = [0, 1, 2]; foreach ($array as $val) { var_dump(current($array)); } int(1) int(1) int(1) int(0) int(0) int(0) In PHP7In PHP5
  59. 59. PHP 7 changed behaviors  When iterating arrays by-reference with foreach(), modifications to the array will continue to influence the iteration. Correct position pointer is maintained $array = [0]; foreach ($array as &$val) { var_dump($val); $array[1] = 1; } int(0) int(0) int(1) In PHP7In PHP5
  60. 60. PHP7 : Other changes  More generally , what before used to generate E_DEPRECATED is now removed, or may be very soon
  61. 61. PHP 7 new engine
  62. 62. PHP 7 new internals  Full 64bit support  New Thread Safety mechanism  New engine memory management  New optimized executor  New optimized structures
  63. 63. PHP 7 full 64bit engine  PHP was known to be platform dependent on this crucial criteria  LP64: Linux64 (and most Unixes)  LLP64: Windows64  ILP64: SPARC64 http://www.unix.org/whitepapers/64bit.html string size signed integer Platform int long LP64 32 64 LLP64 32 32 ILP64 64 64
  64. 64. PHP 7 full 64bit engine  PHP 7 now uses platform independant sizes  Strings > 2^31  Real 64bit userland PHP integers  LFS (Large File Support)  64bits hash keys  Whatever your platform (OS) : consistency
  65. 65. PHP 7 new memory management  PHP7 has reworked every memory management routine  Use less heap and more stack  Zvals are stack allocated  refcount management more accurate  Scalar types are no longer refcounted  Redevelop a new MM heap, more optimized  Based on sized pools (small, medium and large)  CPU cache friendly  Concepts borrowed from tcmalloc
  66. 66. PHP 7 thread safety  PHP7 has reworked its thread safety mechanism routine  PHP5 thread safety routine had a ~20% perf impact  This is no more the case in PHP7  TLS is now mature, and it is used  For PHP under Windows (mandatory)  For PHP under Unix, if asked for (usually not)
  67. 67. PHP 7 new structures  Critical structures have been reworked  More memory friendly  More CPU friendly (data alignment, cache friendly)  Strings are now refcounted  Objects now share their refcount with other types  Wasn't the case in PHP5  The engine Executor uses a full new stack frame to push and manage arguments  Function calls have been heavilly reworked
  68. 68. PHP 7 performances
  69. 69. PHP 7 performances  A lot of tweaks have been performed against PHP 7 code performances.  A lot of internal changes - invisible to userland - have been performed to have a more performant language  CPU cache misses have been heavilly worked on  Spacial locality of code is improved  This results in a language beeing at least twice fast and that consumes at least twice less memory
  70. 70. PHP 7 performances ... ... $x = TEST 0.664 0.269 $x = $_GET 0.876 0.480 $x = $GLOBALS['v'] 1.228 0.833 $x = $hash['v'] 1.048 0.652 $x = $str[0] 1.711 1.315 $x = $a ?: null 0.880 0.484 $x = $f ?: tmp 1.367 0.972 $x = $f ? $f : $a 0.905 0.509 $x = $f ? $f : tmp 1.371 0.976 ---------------------------------------------- Total 35.412 ... ... $x = TEST 0.400 0.223 $x = $_GET 0.616 0.440 $x = $GLOBALS['v'] 0.920 0.743 $x = $hash['v'] 0.668 0.491 $x = $str[0] 1.182 1.005 $x = $a ?: null 0.529 0.352 $x = $f ?: tmp 0.614 0.438 $x = $f ? $f : $a 0.536 0.360 $x = $f ? $f : tmp 0.587 0.411 ---------------------------------------------- Total 20.707 PHP7PHP5.6 Zend/micro_bench.php
  71. 71. PHP 7 performances Time: 4.51 seconds, Memory: 726.00Mb Time: 2.62 seconds, Memory: 368.00Mb PHP7 PHP5.6 PHPUnit in Symfony2 components Time gain ~ 40% Memory gain ~ 50%
  72. 72. PHP 7 performances  Take care of synthetic benchmarks  They only demonstrates basic use cases  Run your own benchmarks  Run your own applications against PHP 7  On a big average, you can expect dividing CPU time and memory consumption by a factor of 2 compared to PHP-5.6, probably even more than 2
  73. 73. Thank you for listening !

×