To examine and run the code examples provided in this chapter, the minimum recommended hardware is listed here:

• x86_64-based desktop PC or laptop
• 1 gigabyte (GB) free disk space
• 4 GB of random-access memory (RAM)
• 500 kilobits per second (Kbps) or faster internet connection

In addition, you will need to install the following software:

• Docker
• Docker Compose

This book uses a pre-built Docker image that contains all the needed software to create and run the PHP 8 code examples covered in this book. You do not need to install PHP, Apache, or MySQL on your computer: just use Docker and the provided image.

To set up a test environment to run the code examples, proceed as follows:

1. Install Docker.

   If you are running Windows, start here:

   https://docs.docker.com/docker-for-windows/install/

   If you are on a Mac, start here:

   https://docs.docker.com/docker-for-mac/install/

   If you are on Linux, have a look here:

   https://docs.docker.com/engine/install/

2. Install Docker Compose. For all operating systems, start here:

   https://docs.docker.com/compose/install/

3. Install the source code associated with this book onto your local computer.

   If you have installed Git, use the following command:

   git clone https://github.com/PacktPublishing/PHP-8-Programming-Tips-Tricks-and-Best-Practices.git ~/repo

   Otherwise, you can simply download the source code from this Uniform Resource Locator (URL): https://github.com/PacktPublishing/PHP-8-Programming-Tips-Tricks-and-Best-Practices/archive/main.zip. You can then unzip into a folder you create, which we refer to as /repo in this book.

4. You can now start the Docker daemon running. For Windows or Mac, all you need to do is to activate the Docker Desktop app.

   If you are running Ubuntu or Debian Linux, issue this command:

   sudo service docker start

   For Red Hat, Fedora, or CentOS, use this command:

   sudo systemctl start docker

5. Build a Docker container associated with this book and bring it online. To do so, proceed as follows.

   From your local computer, open Command Prompt (terminal window). Change the directory to /repo. For the first time only, issue the docker-compose build command to build the environment. Note that you might need root (administrator) privileges to run Docker commands. If this is the case, either run as administrator (for Windows) or preface the command with sudo. Depending on your connection speed, the initial build might take quite a bit of time to complete!

6. To bring the container up, proceed as follows
7. From your local computer, open Command Prompt (terminal window). Change the directory to /repo. Bring the Docker container online in background mode by running the following command:

   docker-compose up -d

   Note that you actually don't need to build the container separately. If the container is not built when you issue the docker-compose up command, it will be built automatically. On the other hand, it might be convenient to build the container separately, in which case docker build will suffice.

   Here's a useful command to ensure all containers are running:

   docker-compose ps

8. To access the running Docker container web server, proceed as follows.

   Open the browser on your local computer. Enter this URL to access PHP 8 code:

   http://localhost:8888

   Enter this URL to access PHP 7 code:

   http://localhost:7777

9. To open a command shell into the running Docker container, proceed as follows.

   From your local computer, open Command Prompt (terminal window). Issue this command to access the PHP 8 container:

   docker exec -it php8_tips_php8 /bin/bash 

   Issue this command to access the PHP 7 container:

   docker exec -it php8_tips_php7 /bin/bash

10. When you are finished working with the container, to take it offline open Command Prompt (terminal window) from your local computer and issue this command:

    docker-compose down 

The source code for this chapter is located here:

https://github.com/PacktPublishing/PHP-8-Programming-Tips-Tricks-and-Best-Practices

Important note

If your host computer uses Advanced RISC Machines (ARM) architecture (for example, Raspberry Pi), you will need to use a modified Dockerfile.

Tip

It would be an excellent idea to get a quick overview of Docker technology and terms by reviewing this article: https://docs.docker.com/get-started/.

We can now begin our discussion by having a look at constructor property promotion.

Aside from the Just-In-Time (JIT) compiler, one of the greatest new features introduced in PHP 8 is constructor property promotion. This new feature combines property declarations and argument lists in the __construct() method signature, as well as assigning defaults. In this section, you will learn how to substantially reduce the amount of coding required in property declarations as well as in the __construct() method signature and body.

Property promotion syntax

The syntax needed to invoke constructor property promotion is identical to that used in PHP 7 and earlier, with the following differences:

• You need to define a visibility level
• You do not have to explicitly declare the properties in advance
• You do not need to make assignments in the body of the __construct() method

Here is a bare-bones example of code that uses constructor property promotion:

// /repo/ch01/php8_prop_promo.php
declare(strict_types=1);
class Test {
    public function __construct(
        public int $id,
        public int $token = 0,
        public string $name = '')
    { }
}
$test = new Test(999);
var_dump($test);

When the preceding code block is executed, this is the output:

object(Test)#1 (3) {
  ["id"]=> int(999)
  ["token"]=> int(0)
  ["name"]=> string(0) ""
}

This shows that an instance of Test type has been created using default values. Now, let's have a look at how this feature might save a substantial amount of coding.

Using property promotion for code reduction

In a conventional OOP PHP class, the following three things need to be done:

1. Declare the properties, as follows:

   /repo/src/Php8/Image/SingleChar.php
   namespace Php7\Image;
   class SingleChar {
       public $text     = '';
       public $fontFile = '';
       public $width    = 100;
       public $height   = 100;
       public $size     = 0;
       public $angle    = 0.00;
       public $textX    = 0;
       public $textY    = 0;

2. Identify the properties and their data type in the __construct() method signature, as follows:

   const DEFAULT_TX_X = 25;
   const DEFAULT_TX_Y = 75;
   const DEFAULT_TX_SIZE  = 60;
   const DEFAULT_TX_ANGLE = 0;
   public function __construct(
       string $text,
       string $fontFile,
       int $width  = 100,
       int $height = 100,
       int $size   = self::DEFAULT_TX_SIZE,
       float $angle = self::DEFAULT_TX_ANGLE,
       int $textX  = self::DEFAULT_TX_X,
       int $textY  = self::DEFAULT_TX_Y)   

3. In the body of the __construct() method, assign values to properties, like this:

   {   $this->text     = $text;
       $this->fontFile = $fontFile;
       $this->width    = $width;
       $this->height   = $height;
       $this->size     = $size;
       $this->angle    = $angle;
       $this->textX    = $textX;
       $this->textY    = $textY;
       // other code not shown 
   }

As the number of constructor arguments increases, the amount of work you need to do also increases significantly. When constructor property promotion is applied, the amount of code required to do the same as previously shown is reduced to one-third of the original.

Let's now have a look at the same block of code as shown previously, but rewritten using this powerful new PHP 8 feature:

// /repo/src/Php8/Image/SingleChar.php
// not all code shown
public function __construct(
    public string $text,
    public string $fontFile,
    public int    $width    = 100,
    public int    $height   = 100,
    public int    $size     = self::DEFAULT_TX_SIZE,
    public float   $angle    = self::DEFAULT_TX_ANGLE,
    public int    $textX    = self::DEFAULT_TX_X,
    public int    $textY    = self::DEFAULT_TX_Y)
    { // other code not shown }

Amazingly, what took 24 lines of code in PHP 7 and earlier can be collapsed into eight lines of code using this new PHP 8 feature!

You are completely free to include other code in the constructor. In many cases, however, constructor property promotion takes care of everything normally done in the __construct() method, which means you can literally leave it empty ({ }).

Now, in the next section, you learn about a new feature called attributes.

Tip

Have a look at the full SingleChar class for PHP 7 here:

https://github.com/PacktPublishing/PHP-8-Programming-Tips-Tricks-and-Best-Practices/tree/main/src/Php7/Image

Also, the equivalent PHP 8 class is found here:

https://github.com/PacktPublishing/PHP-8-Programming-Tips-Tricks-and-Best-Practices/tree/main/src/Php8/Image

For more information on this new feature, have a look at the following:

https://wiki.php.net/rfc/constructor_promotion