Forem: Goran Nikolovski

4 cool new PHP 8 features

Goran Nikolovski — Sun, 16 Aug 2020 13:40:15 +0000

PHP 8 will be released in a little over three months, to be exact on November 26, 2020. It's a new major version of one of the most popular languages used in web development. The new version means some breaking changes, but also lots of new features and performance/security improvements. Here are 4 cool new features that I can't wait to use in production.

1. Named arguments

When we pass arguments to a function, we are doing it based on the parameter position. Named arguments allow passing arguments to a function based on the name. This is a good thing because we don't have to remember the argument position anymore and it will also be much easier to skip default values.

// Positional arguments.
$pieces = explode('-', 'piece1-piece2-piece3');

// Named arguments.
$pieces = explode(delimiter: '-', string: 'piece1-piece2-piece3');
// or
$pieces = explode(string: 'piece1-piece2-piece3', delimiter: '-');

The old way of passing arguments will still work, so if this is not something you like you don't have to use it. Some IDEs like PHPStorm already provide hints for argument names, but having this in PHP core is a cool thing if you ask me.

For more information see PHP RFC: Named Arguments

2. Nullsafe operator ?->

I really like this feature. It will cut the number of lines of code that I have to write especially when accessing some deeply nested fields in Drupal. It's a common thing to call a method on the result of an expression if it's not NULL. This usually leads to a deeply nested code like this:

$street_number =  null;

$current_user = \Drupal::currentUser();

if ($current_user !== NULL) {
    $account = $current_user->getAccount();

    if ($account !== NULL) {
        $address = $account->getAddress();

        if ($address !== NULL) {
            $street_number = $address->getStreetNumber();
        }
    }
}

That is a lot of lines of code just to get the street number. With the Nullsafe operator we can write this in just ONE line:

$street_number = \Drupal::currentUser()?->getAccount()?->getAddress()?->getStreetNumber();

For more information see PHP RFC: Nullsafe operator

3. String contains, string starts with and string ends with functions

Finally, I don't have to use strpos() function anymore to check if a string contains another string. I waited for this function for a very long time.

if (strpos('DS9 centers on the formerly Cardassian', 'formerly') !== false) {}

// vs.

if (str_contains('DS9 centers on the formerly Cardassian', 'formerly')) {}

Checking if a string starts or ends with another string is also a welcome addition.

str_starts_with('Bajoran', 'Baj'); // returns TRUE 
str_ends_with('Bajoran', 'oran'); // returns TRUE

For more information see PHP RFC: str_contains

For more information see PHP RFC: Add str_starts_with() and str_ends_with() functions

4. Constructor property promotion

This sounds complicated, but it isn't. This feature will eliminate boilerplate and that is a cool thing. Constructor property promotion is combining class properties and the class constructor. This feature already exists in Hack -- language created by Facebook that is considered as a dialect of PHP. Let's see how this works. Currently, in PHP 7 we have to do this:

class Human {
    public float $height;
    public float $weight;
    public integer $years;

    public function __construct(
        float $height = 0.0,
        float $weight = 0.0,
        integer $years = 0,
    ) {
        $this->height = $height;
        $this->weight = $weight;
        $this->years = $years;
    }
}

And the new shorthand syntax in PHP 8:

class Human {
    public function __construct(
        public float $height = 0.0,
        public float $weight = 0.0,
        public integer $years = 0,
    ) {}
}

For more information see PHP RFC: Constructor Property Promotion

If you like this article, you can follow me on Twitter for more quality content in the future.

How to convert existing image fields into Media images - Drupal

Goran Nikolovski — Tue, 04 Aug 2020 18:30:05 +0000

All my articles are first published and hosted on my blog - you can find this article here.

Converting existing image fields to Media image fields is easier than you might think. I just converted all image fields to Media image fields on this website and in this article, I'll show you how I did it.

I created this website about four years ago, and at the time Media wasn't in the core. I used regular image fields to store images in my content types and paragraphs.

While there is nothing wrong with regular image fields, using Media is much better at least from the content editing perspective. UI looks much better and you can re-use existing images, and that isn't the case with image fields.

I mean look at the Media library modal window. Isn't that cool? You see all your existing Media images, and you can re-use them.

So, here is how I migrated from regular images to Media images.

1. Enable modules

The very first step you have to do is to enable Media and Media Library modules. These modules are not enabled by default. Once enabled, you'll see several Media types. In this case, we care only about the Image media type, so if you don't need them you can delete other media types.

2. Create media image fields

For each image field create a media image counterpart. For example, my Article content type has the Social share image field, so I created the Social share image media field.

As you can see in the screenshot, Social share image media is an entity reference field. And the settings for this field look like this:

3. Create and attach Media entities

Now, comes the fun part. We get to write some code.

Image field holds the reference to file entities. We just need to create Media entities and attach those existing file entities. This is how I did it.

function gn_core_update_8001(&$sandbox) {
  $entity_types = ['node', 'paragraph'];
  $image_fields = ['field_image', 'field_social_share_image'];

  foreach ($entity_types as $entity_type) {
    $entities = \Drupal::entityTypeManager()
      ->getStorage($entity_type)
      ->loadMultiple();

    foreach ($image_fields as $image_field) {
      gn_core_migrate_to_media($entities, $image_field);
    }
  }
}

function gn_core_migrate_to_media($entities, $image_field) {
  $image_media_field_name = $image_field . '_media';

  foreach ($entities as $entity) {
    if (
      $entity->hasField($image_field) &&
      $entity->get($image_field)->isEmpty() === FALSE &&
      $entity->hasField($image_media_field_name)
    ) {
      $images = $entity->get($image_field)->getValue();
      $entity->set($image_media_field_name, NULL);

      foreach ($images as $image) {
        $media = \Drupal::entityTypeManager()
          ->getStorage('media')
          ->create([
            'bundle' => 'image',
            'uid' => 1,
          ]);
        $media->set('field_media_image', $image);
        $media->save();
        $entity->get($image_media_field_name)->appendItem($media);
      }

      $entity->save();
    }
  }
}

The code is pretty much self-explanatory. I'm looping through all node and paragraph entities, checking if image fields called field_image and field_social_share_image exist and they aren't empty and then creating a Media entity with a reference to existing file entities. The last thing is to attach those Media entities to nodes and paragraphs.

I added this code to an update hook in my custom GN Core module, but you can also use something like Devel execute PHP if you don't want to use update hooks.

4. Final adjustments

The last step is to check all your custom Twig templates and Sass/CSS files and adjust them if needed. Also, if you are using images as tokens you need to update those as well. In my case, I'm using the Social share image media field for the Open Graph image tag.

So, I had to update the token for that field from this:

[node:field_social_share_image:entity:url]

to this:

[node:field_social_share_image_media:entity:field_media_image:entity:url]

After you are completely sure that everything works fine, you can delete your old image fields.

And that's it. I told you it isn't that complicated.