- PHP 8 Programming Tips, Tricks and Best Practices
- Foreword
- Contributors
- About the author
- About the reviewer
- Preface
- Section 1: PHP 8 Tips
- Chapter 1: Introducing New PHP 8 OOP Features
- Technical requirements
- Using constructor property promotion
- Property promotion syntax
- Using property promotion for code reduction
- Working with attributes
- Overview of PHP comments
- PHP DocBlock considerations
- Hidden dangers associated with the misuse of DocBlocks
- The Attribute class
- Attribute syntax
- Incorporating match expressions into your program code
- Match expression general syntax
- Understanding named arguments
- Named argument generic syntax
- Calling core functions using named arguments
- Order independence and documentation
- Exploring new data types
- Union types
- mixed type
- The effect of a mixed type on inheritance
- Improving code using typed properties
- What are typed properties?
- Property typing can lead to a reduction in code
- Summary
- Chapter 2: Learning about PHP 8's Functional Additions
- Technical requirements
- Working with new PHP 8 operators
- Using the variadics operator
- Using the nullsafe operator
- The concatenation operator has been demoted
- Using nested ternary operators
- Using arrow functions
- Generic syntax
- Arrow functions versus anonymous functions
- Variable inheritance
- Practical example: Using arrow functions
- Understanding uniform variable syntax
- Defining uniform variable syntax
- How does uniform variable syntax affect PHP 8?
- Learning new array- and string-handling techniques
- Working with array_splice()
- Using array_slice()
- Detecting string beginning, middle, and end
- Securing SQLite databases with the authorizer
- Wait a minute... no security?
- What's a SQLite authorization callback?
- What gets sent to the callback?
- Authorizer usage example
- Summary
- Chapter 3: Taking Advantage of Error-Handling Enhancements
- Technical requirements
- Understanding PHP 8 error handling
- Undefined variable handling
- Undefined constant handling
- Error-level defaults
- Dealing with warnings that are now errors
- Promoted warnings in object error handling
- Promoted warnings in array handling
- Promoted warnings in string handling
- Understanding notices promoted to warnings
- Non-existent object property access handling
- Non-existent offset handling
- Misusing resource IDs as array offsets
- Ambiguous string offset cast
- Uninitialized or non-existent string offsets
- Handling the @ error control operator
- @ operator usage
- @ operator and error_reporting()
- Summary
- Chapter 4: Making Direct C-Language Calls
- Technical requirements
- Understanding FFI
- Relationship between PHP and the C language
- Understanding PHP extensions
- Learning where to use FFI
- Adopting FFI into PHP
- Do not use FFI for speed
- Why use the FFI extension?
- Examining the FFI class
- Working with FFI creational methods
- Comparing data using FFI
- Using FFI infrastructural methods
- Using FFI in an application
- Integrating an external C library into a PHP script
- Working with PHP callbacks
- Summary
- Section 2: PHP 8 Tricks
- Chapter 5: Discovering Potential OOP Backward-Compatibility Breaks
- Technical requirements
- Discovering core OOP coding differences
- Handling static calls in PHP 8
- Dealing with object property handling changes
- Working with PHP 8 autoloading
- Navigating changes in magic methods
- Dealing with constructor changes
- Working with changes to __toString()
- Taking control of serialization
- Understanding PHP serialization
- Understanding the __sleep() magic method
- Understanding a potential code break in the __sleep() method
- Learning about __wakeup()
- Introducing the Serializable interface
- Examining PHP serializable interface issues
- New magic methods to control PHP serialization
- Understanding PHP 8 expanded variance support
- Understanding covariant returns
- Using contravariant parameters
- Handling Standard PHP Library (SPL) changes
- Understanding changes to SplFileObject
- Examining changes to SplHeap
- Handling changes in SplDoublyLinkedList
- Summary
- Chapter 6: Understanding PHP 8 Functional Differences
- Technical requirements
- Learning key advanced string handling differences
- Handling changes to the needle argument
- Dealing with v*printf() changes
- Working with null length arguments in PHP 8
- Examining changes to implode()
- Learning about constants usage in PHP 8
- Understanding PHP 8 string-to-numeric comparison improvements
- Learning about strict and non-strict comparisons
- Examining numeric strings
- Detecting backward-compatible breaks involving numeric strings
- Dealing with inconsistent string-to-numeric comparison results
- Understanding comparison changes made in PHP 8
- Avoiding problems during a PHP 8 upgrade
- Handling differences in arithmetic, bitwise, and concatenation operations
- Handling non-scalar data types in arithmetic and bitwise operations
- Examining changes in the order of precedence
- Taking advantage of locale independence
- Understanding the problems associated with locale dependence
- Reviewing functions and operations affected by locale independence
- Handling arrays in PHP 8
- Dealing with negative offsets
- Handling curly brace usage changes
- Mastering changes in security functions and settings
- Understanding changes in disabled functions handling
- Learning about changes to the crypt() function
- Dealing with changes to password_hash()
- Learning about changes to assert()
- Summary
- Chapter 7: Avoiding Traps When Using PHP 8 Extensions
- Technical requirements
- Understanding the shift from resources to objects
- PHP 8 extension resource-to-object migration
- Potential code break involving is_resource()
- Advantages of objects over resources
- Traversable to IteratorAggregate migration
- Learning about changes to XML extensions
- Examining XMLWriter extension differences
- Working with changes to the SimpleXML extension
- Understanding other XML extension changes
- Avoiding problems with the updated mbstring extension
- Discovering needle-argument differences in mb_str*() functions
- Examining changes to mb_ereg*() functions
- Dealing with changes to the GD extension
- GD extension resource-to-object migration
- GD extension compile flag changes
- Other GD extension changes
- Discovering changes to the Reflection extension
- Reflection extension usage
- Learning about Reflection extension improvements
- Working with other extension gotchas
- New database extension operating system library requirements
- Reviewing changes to the ZIP extension
- Examining PCRE extension changes
- Working with Intl extension changes
- Understanding cURL extension changes
- Reviewing COM extension changes
- Examining other extension changes
- Summary
- Chapter 8: Learning about PHP 8's Deprecated or Removed Functionality
- Technical requirements
- Discovering what has been removed from the core
- Examining functions removed in PHP 8
- Discovering other PHP 8 usage changes
- Examining core deprecations
- Deprecated usage in parameter order
- Working with removed functionality in PHP 8 extensions
- Discovering mbstring extension changes
- Reworking code that uses Reflection*::export()
- Discovering other deprecated PHP 8 extension functionality
- Changes to the XML-RPC extension
- Changes made to the DOM extension
- Dealing with deprecated or removed security-related functionality
- Examining PHP 8 stream-filter changes
- Dealing with custom error-handling changes
- Dealing with changes to backtraces
- PDO error-handling mode default changed
- Examining the track_errors php.ini setting
- Summary
- Section 3: PHP 8 Best Practices
- Chapter 9: Mastering PHP 8 Best Practices
- Technical requirements
- Discovering method signature changes
- Managing magic method signatures
- Examining Reflection method signature changes
- Dealing with PDO extension signature changes
- Dealing with newly defined static methods
- Working with the static return type
- Extending the use of the ::class constant
- Taking advantage of trailing commas
- Learning about methods that are no longer required
- Working with interfaces and traits
- Discovering new DOM extension interfaces
- Using new DateTime methods
- Understanding PHP 8 trait handling refinements
- Dealing with private methods
- Controlling anonymous class usage
- Understanding changes in namespaces
- Discovering differences in tokenization
- Using reserved keywords in a namespace
- Exposing bad namespace naming practices
- Summary
- Chapter 10: Improving Performance
- Technical requirements
- Working with the JIT compiler
- Discovering how PHP works without JIT
- Enabling the JIT compiler
- Configuring the tracing mode
- Using the JIT compiler
- Debugging with the JIT compiler
- Discovering additional JIT compiler settings
- Speeding up array handling
- Working with SplFixedArray in PHP 8
- Implementing stable sort
- Understanding stable sorts
- Contrasting stable and non-stable sorting
- Examining the effect of stable sorting on keys
- Handling illegal sort functions
- Using weak references to improve efficiency
- Taking advantage of weak references
- Reviewing the WeakReference class definition
- Using weak references
- Working with WeakMap
- Implementing a container class using SplObjectStorage
- Understanding the benefits of WeakMap over SplObjectStorage
- Summary
- Chapter 11: Migrating Existing PHP Apps to PHP 8
- Technical requirements
- Understanding development, staging, and production environments
- Defining an environment
- Learning how to spot BC breaks before a migration
- Gaining an overview of BC breaks
- Creating a BC break scan configuration file
- Developing a BC break scan class
- Performing the migration
- Step 1 – Review the migration guide
- Step 2 – Make sure the current code works
- Step 3 – Back up everything
- Step 4 – Create a version control branch
- Step 5 – Scan for BC breaks
- Step 6 – Fix incompatibilities
- Step 7 – Repeat steps 5 and 6 as needed
- Step 8 – Commit changes to the repository
- Step 9 – Test in a simulated virtual environment
- Step 10 – Return to step 5 if the test is unsuccessful
- Step 11 – Install PHP 8 on the staging environment
- Step 12 – Test and clone the staging environment to production
- Testing and troubleshooting the migration
- Testing and troubleshooting tools
- Handling issues with Composer
- Working with unit tests
- Summary
- Chapter 12: Creating PHP 8 Applications Using Asynchronous Programming
- Technical requirements
- Understanding the PHP async programming model
- Developing synchronous programming code
- Understanding the asynchronous programming model
- Working with async coroutine support
- Creating a PHP async application
- Using the Swoole extension
- Examining the Swoole extension
- Installing the Swoole extension
- Testing the installation
- Examining a sample I/O-intensive application
- Using the Swoole extension to improve application performance
- Using selected PHP frameworks in async mode
- Working with ReactPHP
- Implementing PHP async using Amp
- Using Mezzio with Swoole
- Working with the parallel extension
- Learning about PHP 8.1 fibers
- Discovering the Fiber class
- Using fibers
- Examining the effect of fibers on ReactPHP and Swoole
- Summary
- Why subscribe?
- Other Books You May Enjoy
Section 2: PHP 8 Tricks
In this part, you are taken into the dark corners of PHP 8: the places where backward-compatibility breaks exist. This part guides you through the critical process of migrating an existing application to PHP 8.
The following chapters are included in this section:
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.