Forem: Jimmy Klein

Simplify your code

Jimmy Klein — Fri, 08 Mar 2024 12:00:38 +0000

Over the years, I have become very interested in clean code, calisthenics objects, etc. And over time, readings, videos, discussions and katas, my writing of code has changed: less superfluous, more meaningful code (at least for me 😇) and a desire to go to the 'essential. So here is what has evolved in my way of approaching code.

The examples in this article are in PHP, but most of what I describe below is applicable to all languages.

Comments

Commenting on your code can be useful, but it must be done for the right reasons. A comment should say why it was done like that and not what the code does.



// If the user is at least 18 years old
if ($user->getAge() >= 18) {
    ...
}

This comment is completely useless, it is a literal copy of the if statement which can surely make you smile. But I used to write this kind of comment and I wasn't the only one (you just had to see the codebase of the project I'm working on some time ago). Look in your codebase, I'm sure you'll find some.



// If the user is an adult
if ($user->getAge() > 18) {
    ...
}

This comment tells us a little more about what this instruction tests, but I think we can do even better and remove this comment. Many solutions :

Put a constant in place of 18 ```php

if ($user->getAge() >= ADULT_AGE) {
...
}


* Extract the test into a function
```php


if (userIsAdult($user)) {
    ...
}
...
...
function userIsAdult(User $user) {
    return $user->getAge() >= ADULT_AGE;
}

This method is useful if you have a fairly complicated test with a sequence of conditions. Instead of putting a comment, try naming your test and extracting it into a function.

Ensure that this test is done directly in the object code ```php

if ($user->isAdult()) {
...
}
...
...
class User
{
private $age;

const ADULT_AGE = 18;
...
public function isAdult()
{
    return $this->age >= self::ADULT_AGE;
}

}


---

## PHPDoc

PHP is becoming more and more typed, and honestly I've never had to extract the PHPDoc from my projects. From now on for my personal projects, I no longer generate the PHPDoc of my functions. To return to my `User` class:

Before:
```php


class User
{
    private $name;
    private $firstName;
    private $age;

    /**
     * User constructor
     * @param string $name;
     * @param string $firstName;
     * @param int $age;
     */
    public function __construct($name, $firstName, $age)
    {
        $this->name = $name;
        $this->firstName = $firstName;
        $this->age = $age;
    }

    /**
     * Indique si l'utilisateur est adulte
     * @return bool
     */
    public function isAdult()
    {
         return $this->age >= self::ADULT_AGE;
    }
}

Now:



class User
{
    public function __construct(
        private string $name,
        private string $firstName,
        private int $age)
    {
    }

    public function isAdult(): bool
    {
         return $this->age >= self::ADULT_AGE;
    }
}

The names of the methods are quite self-explanatory, no need to describe them (especially when we see the comments generated by the IDE like User constructor!)
The constructor parameters are typed, the IDE can very well indicate the type of each parameter
The return type of the method is directly in the code
And the advantage is that if one day a parameter or a return type has to change, there is no risk of forgetting to update the PHPDoc. (because yes, the problem with comments is that over time, they no longer correspond to the code below, due to forgetting to update 😕)

Getter and setter

The IDE can be very convenient, but can also lead to bad habits. Automatic generation of a class's getter and setter is a good example. We don't know if we're going to need them, but we're going to generate them anyway.

I now try to create the minimum possible getter/setter (if not none if possible):

Passing parameters directly into the constructor. Instead of : ```php

class User
{ // The constructor is empty for the example
public function __construct() {}

public function setName(string $name) {...} 
public function setFirstName(string $firstName) {...}
public function setAge(int $age) {...}

}

I do 
```php


class User
{
    public function __construct(
        private string $name,
        private string $firstName,
        private int $age)
    {
    }
}

The object itself can have its own business rules. Taking the example from the beginning of the article on the age of the user: Before ```php

if ($user->getAge() > 18) {
...
}

After
```php


class User
{
    ...

    public function isAdult(): bool
    {
        return $this->age >= self::ADULT_AGE;
    }
}

Temporary variables

Like any developer, I learned to do for/foreach/while loops. And most often this included the creation of temporary variables. If I take the first example from my Refactoring with Collection article, here is the kind of code I used to write before:



public function doubleAllValue(array $numbers)
{
    $result = [];
    foreach ($numbers as $number) {
        $result[] = $number * 2;
    }

    return $result;
}

We have a temporary variable here. If I use the definition from Wikipedia:

In computer programming, a temporary variable is a variable with short lifetime, usually to hold data that will soon be discarded, or before it can be placed at a more permanent memory location. Because it is short-lived, it is usually declared as a local variable, i.e., a variable with local scope.

And now here is what I usually write:



public function doubleAllValue(array $numbers)
{
    return array_map(function($number) {
        return $number * 2;
    }, $numbers);
}

The use of temporary variables can be practical in certain debugging cases, on a case-by-case basis depending on the complexity of the code.

Early return

During my studies, I was taught that a method must have only one output. But over the years, I realized that it was possible to use early returns to improve the readability of the code.



function canDriveACar(User $user): bool
{
    $canDriveACar = null;
    if ($user->isAdult()) {
        $canDriveACar = true;
    } else {
        if ($user->learnInAccompaniedDriving) {
            $canDriveACar = true;
        } else {
            $canDriveACar = false;
        }
    }

    return $canDriveACar ;
}

The use of early return will allow:

Reduce code indentation
To remove the else
To have more readable code



function canDriveACar(User $user)
{
    if ($user->isAdult()) {
        return true;
    }

    if ($user->learnInAccompaniedDriving) {
        return true;
    }

    return false;
}

Our practice evolves over the years, sometimes with good ideas, sometimes not so good ones (but we realize it much later!).

What has changed in the way you code over the years? Let's discuss it in the comments.

Thank you for reading, and let's stay in touch !

If you liked this article, please share. Join me also on Twitter/X for more PHP tips.

Header photo by Artem Sapegin on Unsplash

Never write another loop again

Jimmy Klein — Fri, 01 Mar 2024 11:37:25 +0000

Always with the goal of improving my way of writing code, I discovered a few years ago Adam Wathan and his book Refactoring to Collections. And suffice to say that the slogan Never write another loop again aroused my curiosity.

From the start, the goal is clear: never write a for/foreach/while loop again. And then I say to myself: impossible! These structures are so ingrained in our habits that I can't see myself doing otherwise.

If we take a very simple example written in a very classic way:

public function doubleAllValue(array $numbers)
{
    $result = [];
    foreach ($numbers as $number) {
        $result[] = $number * 2;
    }

    return $result;
}

For each number in the variable $numbers, multiply it by two and save the result in the temporary variable $result.

Another way to write this processing is to use native PHP functions. To continue the previous example, we will use array_map().

public function doubleAllValue(array $numbers)
{
    return array_map(fn($number) => {
        return $number * 2;
    }, $numbers);
}

What do we see here? No more foreach, no more temporary variables and a single instruction. So we are on the right track!! In addition, our business processing is output in a function (here anonymous) which could be reused if extracted.

There are other native methods in PHP on arrays like array_filter, array_reduce... But these functions have several disadvantages:

Their signatures are different and the order of the arguments is not the same between the different functions. So we often refer to the documentation.

array_walk($callback, $array);
array_filter($array, $callback);

The combination of these methods to carry out a particular treatment is particularly illegible. Let's say we want to double the values of positive numbers:

class integer
{
    public function doubleAllPositiveValue(array $numbers)
    {
        return array_map(function($number) {
                return $number * 2;
            },
            array_filter($numbers, function($number) {
                return $number > 0;
            })
        );
    }
}

Suffice to say that it is not very readable. We could very well define methods to make reading easier:

class integer
{
    public function doubleAllPositiveValue(array $numbers)
    {
        return array_map(function($number) {
                return $number * 2;
            },
            $this->keepOnlyPositiveValue($numbers)
        );
    }

    private function keepOnlyPositiveValue(array $numbers)
    {
        return array_filter($numbers, function($number) {
                return $number > 0;
        });
    }
}

A little better, we could even go even further:

class integer
{
    public function doubleAllPositiveValue(array $numbers)
    {
        return array_map(
            $this->getDoubleValueCallback(),
            $this->keepOnlyPositiveValue($numbers)
        );
    }

    private function getDoubleValueCallback()
    {
        return function($number) {
                return $number * 2;
            };
    }

    private function keepOnlyPositiveValue(array $numbers)
    {
        return array_filter($numbers, function($number) {
                return $number > 0;
        });
    }
}

The doubleAllPositiveValue method is now more readable, but its reading direction is reversed: the first processing is the last line ($this->keepOnlyPositiveValue($numbers)) and the result is then processed by the previous line ($this->getDoubleValueCallback()). And then the method which returns a function is not the easiest to understand and especially to use for the uninitiated.

And if only we could have a mechanism that would allow us to define line by line what we want to do.

$result = $numbers
            ->filterPositiveValue()
            ->doubleValue()
            ;

Laravel collections

And that’s where Adam Wathan comes to our rescue with the Collection pipelines. In his book, he relies on Laravel and its classes and methods on collections. But nothing prevents you from using others or writing your own classes.

To return to our previous examples.

public function doubleAllValue(array $numbers)
{
    return Collection::make($numbers)
        ->map(
            function($number) {
                return $number * 2;
            }
        )
        ->toArray()
        ;
}

For information :

The Collection::make method constructs a Collection object from a native array.
The toArray() method returns the array contained in the Collect object;

For this example, which is quite simple, we don't really see the point of these pipelines. But it becomes quite powerful when you start to add them up:

public function doubleAllPositiveValue(array $numbers)
    {
        return Collection::make($numbers)
            ->filter(function($number) {
                return $number > 0;
            })
            ->map(function($number) {
                return $number * 2;
            })
            ->toArray();
        );
    }

Here it becomes interesting, because our processing is done in the direction of reading: we start by filtering the positive numbers, then we multiply them by two. And using a class to manage our tables allows us to do what we want. For example, if I want to find the first positive number in an array and if necessary return 0;

Classically (using early returns to avoid temporary variables):

getFirstPositifValue(array $numbers)
{
    foreach ($numbers as $number) {
        if ($number > 0) {
            return $number;
        }
    }

    return 0;
}

With a method of the Collect class

getFirstPositifValue(array $numbers)
{
    return Collection::make($numbers)
        ->first(
            function($number) {
                return $number > 0:
            },
            0
        );
}

I don't know what you think, but I find it rather elegant and easily understandable! And all these are just simple examples, it is even more interesting for more complicated treatments.

So if you are interested in Collection pipelines, I strongly advise you to start with:

ask to receive a free chapter of his book
watch the screencast available for free on its site

Refactoring to collections: Refactoring to collections: Never write another loop again.

This link is not an affiliate link

Do you know collection pipelines ? Do you use them (definitly yes if you using laravel)?

Thank you for reading, and let's stay in touch !

If you liked this article, please share. Join me also on Twitter/X for more PHP tips.

9 rules for writing (better?) code

Jimmy Klein — Wed, 28 Feb 2024 11:48:05 +0000

Like many developers, I like learning new things. And one thing that interests me a lot is code quality and how to write code.

In order to practice in different areas, I quite often do Katas to which I add constraints. And a while ago I discovered Calisthenics Object.

Behind this name lie 9 rules to follow when writing code. And suffice to say that some of these rules are quite contrary to everything we learn at school or in the various tutorials and online training courses.

The goal is to have code that is more maintainable, more readable and more easily testable.

Code is read much more often than it is written

The following rules are not to be taken literally. The principle is to experiment with them on small personal projects or during Kata code in order to see what would be interesting to apply in a real situation.

1. Only one level of indentation per method

This makes the code easier to read and maintain.

// 🚫 2 levels of indentation
public function notify(array $contacts)
{
    foreach ($contacts as $contact) {
        if ($contact->isEnabled()) {
            $this->mailer->send($contact);
        }
    }
}

Several possible solutions:

// ✅ Extracting indented code in another method
public function notify(array $contacts)
{
    foreach ($contacts as $contact) {
        $this->notifyContact($contact)
    }
}

private function notifyContact(Contact $contact)
{
    if ($contact->isEnabled()) {
        $this->mailer->send($contact);
    }
}

// ---------------------------------------------------

// ✅ We filter the list of contacts before the loop 
public function notify(array $contacts)
{
    $enabledContacts = array_filter(
      $contacts,
      fn($contact) => $contact->isEnabled()
    );

    foreach ($enabledContacts as $contact) {
        $this->mailer->send($contact);
    }
}

// ---------------------------------------------------

// ✅ We ask the caller to send us directly the list of
// activated contacts
public function notify(array $enabledContacts)
{
    foreach ($enabledContacts as $contact) {
        $this->mailer->send($contact);
    }
}

2. Do not use the `else` keyword

Using else forces us to read nested code (with more levels of indentation) whereas in most cases we can do without it.

First solution: use of early return

Before :

class ItemManager
{
    private $cache;
    private $repository;

    public function __construct($cache, $repository)
    {
        $this->cache = $cache;
        $this->repository = $repository;
    }

    public function get($id)
    {
        if (!$this->cache->has($id)) {
            $item = $this->repository->get($id);
            $this->cache->set($id, $item);
        } else {
            $item = $this->cache->get($id);
        }

        return $item;
    }
}

After :

class ItemManager
{
    private $cache;
    private $repository;

    public function __construct($cache, $repository)
    {
        $this->cache = $cache;
        $this->repository = $repository;
    }

    // ✅ Early returns
    public function get($id)
    {
        if ($this->cache->has($id)) {
            return $this->cache->get($id);
        }

        $item = $this->repository->get($id);
        $this->cache->set($id, $item);

        return $item;
    }
}

Upstream initialization

public function redirect(User $user)
{
    if ($user->isAuthenticate()) {
        $urlToRedirect = '/dashboard';
    } else {
        $urlToRedirect = '/login';
    }

    return $urlToRedirect;
}

// ✅ Initialization ahead of default value
// valid if initialization is inexpensive
public function redirect(User $user)
{
    $urlToRedirect = '/login';
    if ($user->isAuthenticate()) {
        $urlToRedirect = '/dashboard';
    }

    return $urlToRedirect;
}

Use of the Fail Fast principle

class MyListener
{
    public function onDelete(Event $event)
    {
        if ($event->getType() === 'OBJECT_DELETE' 
            && $event->getObject instanceOf MyEntity) {
            $this->cache->invalidate($event->getObject());
        } else {
            if ($event->getType() !== 'OBJECT_DELETE') {
                throw new \Exception('Invalid event type');
            } else {
                throw new \Exception('Invalid object instance');
            }
        }
    }
}

// ✅ Use of the Fail Fast principle: 
// we immediately test error cases
class MyListener
{
    public function onDelete(Event $event)
    {
        if ($event->getType() !== 'OBJECT_DELETE') {
            throw new \Exception('Invalid event type');
        }

        $myEntity = $event->getObject();
        if (!$myEntity instanceOf MyEntity) {
            throw new \Exception('Invalid object instance');
        }

        $this->cache->invalidate(myEntity);
    }
}

3. Wrap all primitive types in objects

(especially those who have particular behaviors)

Benefits :

encapsulation of processing
type hinting
validation of parameters upstream.

public function fizzBuzz(int $integer)
{
    if ($integer <= 0) {
        throw new \Exception('Only positive integer is handled');
    }

    if ($integer%15 === 0) {
        return 'FizzBuzz';
    }

    //...
}

// Replacing int with a PositiveInteger object
public function fizzBuzz(PositiveInteger $integer)
{
    // ✅ No more validation testing of the input parameter
    if ($integer->isMultipleOf(15)) {
        return 'FizzBuzz';
    }

    // ...
}

// Using a Value Object
class PositiveInteger
{
    private $value;

    public function __construct(int $integer)
    {
        // ✅ The integer validation test is done directly here
        if ($integer <= 0) {
            throw new \Exception('Only positive integer is handled');
        }

        $this->value = $integer;
    }

    // ✅ You can even add functions related to this object
    public function isMultipleOf(int $multiple)
    {
        return $this->valueinteger%$multiple === 0;
    }
}

Other example :

// 🚫 Passing a table does not allow us to be sure 
// of the content and requires us to do additional tests
public function notify(array $enabledContacts)
{
    foreach ($contacts as $contact) {
        if ($contact->isEnabled()) {
            $this->mailer->send($contact);
        }
    }
}

// ✅ Here we directly pass an object containing only activated contacts. 
// We are therefore assured of only having active contacts
public function notify(EnabledContacts $enabledContacts)
{
    foreach ($enabledContacts as $contact) {
        $this->mailer->send($contact);
    }
}

class EnabledContacts implements \Iterator 
{
    private $contacts;

    public function __construct(array $contacts)
    (
        // ✅ We only keep active contacts
        $this->contacts = array_filter(
          $contacts,
          fn(Contact $contact) => $contact->isEnabled()
        );
    )

    // ... définition des méthode de l'interface \Iterator
}

Other example :

// 🚫 Two parameters are strongly linked
public function findAll(int $start, int $end)
{
  // paginated data recovery in database
}

// ✅ We group two attributes in a single class
public function findAll(Pagination $pagination)
{
  $start = $pagination->getStart();
  $end = $pagination->getEnd();

  ...// paginated data recovery in database
}

4. First Class Collections: a class that contains an array as an attribute must not contain any other attribute

The code related to this collection is now encapsulated in its own class.

class Newsletter
{ 
    private int $id;
    private string $title;

    // 🚫 The object already contains two attributes, 
    // so it cannot contain an array. 
    // You have to encapsulate it in an object
    private array $subscriberCollection;

    public function getNumberOfSubscriberWhoOpen()
    {
        $subscribersWhoOpen = array_filter(
          $this->subscriberCollection,
          fn($subscriber) => $subscriber->hasOpenNewsletter()
        );

        return \count($subscriberWhoOpen);
    }

    // ....
}

class Newsletter
{
    private int $id;
    private string $title;

    // ✅ The array is now encapsulated in its own class
    private SubscriberCollection $subscriberCollection;

    public function getNumberOfSubscriberWhoOpen()
    {
        return $this->subscriberCollection
            ->getSubscriberWhoOpen()
            ->count();
    }

    // ....
}

class SubscriberCollection 
{
    private array $subscriberCollection;

    // ✅ We can declare here "business" methods 
    // linked to subscribers
    public function getSubscriberWhoOpen()
    {
        $subscribersWhoOpen = array_filter(
          $this->subscriberCollection,
          fn($subscriber) => $subscriber->hasOpenNewsletter()
        );

        return new static($subscribersWhoOpen);
    }

    // ...
}

5. Only one `->` per line (except for Fluent interface)

The goal here is not to have nicely formatted code, but to follow Demeter's law: "Speak only to your immediate friends."

Obviously $this->myAttribute does not count in the count

class User
{
    private ?Identity $identity;

    public function getIdentity(): ?Identity
    {
        return $this->identity;
    }
}

class Identity
{
    private string $firstName;
    private string $lastName;

    public function getFirstName(): string
    {
        return $this->firstName;
    }

    public function getLastName(): string
    {
        return $this->lastName;
    }
}

$user = new User();
$fullName = sprintf(
  '%s %s',
  // 🚫 Non-compliance with the law of demeter
  // 🚫 getIdentity() could return `null` and this would 
  // generate an error
  $user->getIdentity()->getFirstName(), 
  $user->getIdentity()->getLastName()
);

class User
{
    private ?Identity $identity;

    public function getFullName(): string
    {
      if ($this->identity === null) {
        return 'John Doe';
      }

      return sprintf(
        '%s %s',
        // The original rule applies for example to java 
        // where the keyword “this” does not need to be 
        // specified in classes.
        // We therefore do not count the first here `->` 
        // because in PHP $this is mandatory in classes
        // to use an attribute
        $this->identity->getFirstName(),
        $this->identity->getLastName()
      );
    }
}

class Identity
{
    private string $firstName;
    private string $lastName;

    public function getFirstName(): string
    {
        return $this->firstName;
    }

    public function getLastName(): string
    {
        return $this->lastName;
    }
}

$user = new User();
// ✅ Respect for the law of Demeter
// ✅ More error handling here
$fullName = $user->getFullName();

This rule does not apply to fluent interfaces such as query builders for example

$query = $queryBuilder
  ->select('user')
  ->where('user.id = :id')
  ->setParameter('id', 1);
  ->getQuery()
;

6. Not using abbreviations

One of the simplest rules to apply and above all to apply immediately!

Better comprehension
Better maintainability
If you can't name: the function does too many things, the content of the variable is unclear, etc.

🚫 $m->send($contact);

✅ $mailer->send($contact)

🚫 $cmpMng->getById($id);

✅ $companyManager->getById($contact)

🚫 $translator->trans($input);

✅ $translator->translate($input)

7. Keep all entities small (classes, methods, packages/namespaces)

🔥 Constraints:

Maximum 10 methods per class
Maximum 50 lines per class
Maximum 10 classes per namespace

✅ Objective:

Limit class responsibilities
Facilitate the maintainability of classes and methods
Have a consistent set of classes (namespace)

8. Classes should not contain more than five instance variables

Fewer dependencies
So easier to mock for unit tests

Example here with the limit at 2

class EntityManager
{
    // 🚫 4 attributes
    private EntityRepository $entityRepository;
    private LoggerInterface $logger;
    private MiddlewareInterface $middleware;
    private NotificationService $notificationService;

    public function update(Entity $entity)
    {
        $this->entityRepository->update($entity);

        // 🚫 These three acions could very well be 
        // relocated in order to avoid overloading 
        // this method and to facilitate 
        // the addition of other actions later.
        $this->logger->debug($entity);
        $this->middleware->sendMessage($entity);
        $this->notificationService->notify($entity);
    }
}

class EntityManager
{
    // ✅ Fewer dependencies
    // ✅ So easier to mock for unit tests
    private EntityRepository $entityRepository;
    private EventDispatcher $eventDispatcher;

    public function update(Entity $entity)
    {
        $this->entityRepository->update($entity);

        // ✅ It will be very easy to add another 
        // processing by adding a listener to this event
        $this->eventDispatcher->dispatch(Events::ENTITY_UPDATE, $entity);
    }
}

// ✅ Processing has been relocated to 3 separate listeners
// ✅ Small and easily testable classes
class EntityToLog
{
    private LoggerInterface $logger;

    public function onUpdate(Entity $entity)
    {
        $this->logger->debug($entity);
    }
}

class EntityToMiddleware
{
    private MiddlewareInterface $middleware;

    public function onUpdate(Entity $entity)
    {
        $this->middleware->sendMessage($entity);
    }
}

class EntityNotification
{
    private NotificationService $notificationService;

    public function onUpdate(Entity $entity)
    {
        $this->notificationService->notify($entity);
    }
}

9. No getter / setter

Encapsulation of actions
Allows you to think on the principle “Tell, don’t ask”

class Game
{
    private Score $score;

    public function diceRoll(int $score): void
    {
        $actualScore = $this->score->getScore();
        // 🚫 We modify its value outside the object 
        // and then “force” the result on it.
        $newScore = $actualScore + $score;
        $this->score->setScore($newScore);
    }
}

class Score 
{
    private int $score;

    public function getScore(): int
    {
        return $this->score;
    }

    public function setScore(int $score): void
    {
        $this->score = $score;
    }
}

class Game
{
    private Score $score;

    public function diceRoll(Score $score): void
    {
        $this->score->addScore($score);
    }
}


class Score 
{
    private int $score;

    public function addScore(Score $score): void
    {
        // ✅ We define here the score addition logic
        $this->score += $score->score;
    }
}

🗣️ Tell me in the comments if you already apply some of these rules and if you will try some of them.

Thank you for reading, and let's stay in touch !

If you liked this article, please share. Join me also on Twitter/X for more PHP tips.

Check the presence of a key in an array in PHP - The right way

Jimmy Klein — Mon, 26 Feb 2024 12:31:47 +0000

I see this kind of code quite regularly:

$items = [
    'one' => 'John',
    'two' => 'Jane',
];

if (in_array('two', array_keys($items))) {
    // process
}

Although functional, there is a much simpler way to check that a key exists: the array_key_exists() method

$items = [
    'one' => 'John',
    'two' => 'Jane',
];

if (array_key_exists('two', $items)) {
    // process
}

This method will just check the presence of the key, regardless of the associated value.

If we also want to test that the value is not null, we can use the isset() function.

if (isset($items['two'])) {
    // process
}

Thank you for reading, and let's stay in touch !

If you liked this article, please share. Join me also on Twitter/X for more PHP tips.

Be careful about the switch statement in PHP

Jimmy Klein — Thu, 22 Feb 2024 20:29:18 +0000

Could you find the difference in results between these two codes?

function getStatusByCode($code)
{   
    $status = '';

    switch ($code) {
        case 0:
            $status = 'OK';
            break;

        case 1: 
            $status = 'WARNING';
            break;

        default:
            $status = 'UNDEFINED';
            break;
    }    

    return $status;
}

var_dump(getStatusByCode(null));

and

function getStatusByCode($code)
{   
    $status = '';

    if ($code === 0) {
        $status = 'OK';
    } elseif ($code === 1) {
        $status = 'WARNING';
    } else {
        $status = 'UNDEFINED';
    }

    return $status;
}

var_dump(getStatusByCode(null));

So have you found it?

In the first case with the switch, the method returns OK.
In the second case, the method returns UNDEFINED.

But why this difference?

The first code with the switch comes from a legacy code base: no type hinting on the arguments, no return from the function. And this code was the cause of a small bug, because switch uses loose comparison: using == instead of === to compare values.

And in PHP with the loose comparison, null equals 0.

So be careful when you have a sequence of if / elseif / else, switching to switch can have an impact on the expected behavior.

So what to do?

If you follow me a little, I recommend that you use the strict comparison with === most often (if not all the time).

So if you want to keep this behavior, some ideas:

You leave your sequence of if / elseif / else
You reinforce your function parameters with types to ensure you never have an unwanted value (if that's the case)

function getStatusByCode(int $code)
{   
    $status = '';

    switch ($code) {
        case 0:
            $status = 'OK';
            break;

        case 1: 
            $status = 'WARNING';
            break;

        default:
            $status = 'UNDEFINED';
            break;
    }    

    return $status;
}

var_dump(getStatusByCode(null));

/* Result : Fatal error: Uncaught TypeError: 
 * Argument 1 passed to getStatusByCode() must be of the type int, null given
 */

You are using match available since PHP 8 which uses strict comparison 👍

function getStatusByCode($code)
{
    return match($code) {
        0 => 'OK',
        1 => 'WARNING',
        default => 'UNDEFINED',
    };
}

Thank you for reading, and let's stay in touch !

If you liked this article, please share. You can also find me on Twitter/X for more PHP tips.

Create date easily in PHP

Jimmy Klein — Tue, 20 Feb 2024 12:43:31 +0000

The simplest way to create dates in PHP is to instantiate an object of the DateTime class.

$date = new DateTime();
// "2022-12-19 08:33:03.003983"

We can also pass a string as a parameter to this constructor:

// Current date and time ("2022-12-19 08:33:03.003983")
// Default value of the constructor
$date = new DateTime("now");

// This morning at midnight ("2022-12-19 00:00:00.000000")
$date = new DateTime("midnight");

// Tomorrow at midnight ("2022-12-20 00:00:00.000000")
$date = new DateTime("tomorrow");

// Last day of december at midnight ("2022-12-31 00:00:00.000000")
$date = new DateTime("last day of december");

From a format

We can also create dates from a format that we define.

// 2022-12-21 08:33:03.003983
$date = DateTime::createFromFormat('Y-m-d', '2022-12-21');

We see here that the hours, minutes and seconds are initialized with the values of the current time. If we want to reset these values to 0, we can use !.

A date at midnight?

// 2022-12-19 00:00:00.000000
$date = DateTime::createFromFormat('!Y-m-d', '2022-12-19');

But it also works with days, months and years. The first day of the month?

// 2022-12-01 00:00:00.000000
$date = DateTime::createFromFormat('!Y-m', '2022-12');

First day of the year ?

// 2022-01-01 00:00:00.000000
$date = DateTime::createFromFormat('!Y', '2022');

January 1, 1970 🙃?

// 1970-01-01 00:00:00.000000
$date = DateTime::createFromFormat('!', '');

Thank you for reading, and let's stay in touch !

If you like this article, please share. You can also find me on Twitter/X for more PHP tips.

Never use `empty` function in PHP

Jimmy Klein — Mon, 19 Feb 2024 11:35:06 +0000

There are several ways to test that an array is empty in PHP, and the one I see most often is:

$var = [];

if (empty($var)) { ... }

By reading the code, you immediately know what it does, the name of the function is quite self-explanatory. But the problem is the use of the empty function which is not only used to test array!

Did you know that using empty is like writing:

$var = [];

if (
    isset($var) === false
    || $var === false
    || $var === 0
    || $var === -0
    || $var === 0.0
    || $var === -0.0
    || $var === ''
    || $var === '0'
    || $var === []
) { ... }

We can clearly see here that we can use empty to also test that an integer is equal to 0, or that a string is empty. And that's the problem with this function: it does too many things and can cause many bugs.

For example, a test with empty of an undeclared variable returns true without errors! So a bug can occur if you make a mistake in the name of your variable:

$var = [1, 2, 3];

var_dump(
    empty($errorVar)
); // bool(true)

It is therefore better to test the expected value directly:

var_dump(
    $errorVar === []
); // bool(false)
/*
 * With php < 8 : Notice: Undefined variable: myErrorVar in /in/Nm3CT on line 8
 * With php >= 8 : Warning: Undefined variable $myErrorVar in /in/Nm3CT on line 8
 */

What is the right method?

To test that an array is empty, I advise you to use one of the suggestions below instead.

$var = [];

if (count($var) === 0) {...}
// ou 
if (sizeof($var) === 0) {...}

My favorite solution:

$var = [];

if ($var === []) {...}

And more generally, I advise you to ban the empty function from your vocabulary and your daily life:

Want to test that an integer is equal to 0?

$var === 0

Want to test that a string is empty?

$var === ''

Do you want to test that a previously declared and initialized variable is equal to null?

$var = null;

if ($var === null) {...}

If you want to test that a variable exists and is different from null, you must use the isset function

isset($var)

It's simple, isn't it?

What if I want to test several things at the same time?

If for example, you want to test that your variable is not null and that it is not an empty string, you can either combine the two conditions:

if ($var !== null && $var !== '')

Either create a private method with an explicit name which will do this control

private function isTokenValid(?string $token): bool
{
     return $token !== null && $token !== '';
}

// in the condition
if ($this->isTokenValid($var)) {...}

Thank you for reading, and let's stay in touch !

If you liked this article, please share. Join me also on Twitter/X for more PHP tips.

⚠️ [PHP] N'écrivez pas ce type de code en production ⚠️

Jimmy Klein — Fri, 03 Dec 2021 20:58:43 +0000

Vous connaissez surement le callback hell en JS ?
Mais connaissez-vous le array_ hell en PHP ?

Voici ma solution de la partie 1 du jour 3 de l'Advent of Code 😄

Mais cette complexité m'a fait réviser certaines fonctions 👇!

Le `array_` hell

Tout d'abord, ce que j'appelle 🔥 array_ hell 🔥 :

Si on cumule des appels aux différentes méthodes array_, le sens de lecture se retrouve inversé par rapport au traitement réalisé.

➕ d'info dans mon article "Revue : Refactoring to collections"

On en profite pour réviser un peu

1/ array_count_values : retourne un tableau contenant les valeurs du tableau comme clés et leur fréquence comme valeurs.

2/ Savez-vous comment transformer un tableau à deux dimensions en transposant les colonnes en lignes et les lignes en colonnes ❓

Avec array_map en lui passant comme callback la valeur null et en utilisant comme deuxième argument le spread operator sur le tableau 🤩

3/ Un petit rappel sur les fonctions fléchées disponible depuis PHP 7.4 ❤️

Cela permet de définir de manière plus concises les fonctions anonymes.

4/ Et pour finir, la méthode strtr qui permet de remplacer des caractères dans une chaîne 🎆

Merci d'avoir lu, et restons en contact !

Si vous avez aimé cet article, partagez-le autour de vous 🙏

Vous pouvez aussi me retrouver sur Twitter

Si vous souhaitez recevoir des tips de ce genre directement dans votre boîte mail, inscrivez-vous à ma dev letter.

Have you a hey.com account ? What do you think of it ?

Jimmy Klein — Fri, 10 Jul 2020 18:44:20 +0000

Hey.com is a new email service created by Basecamp.

It’s a redo, a rethink, a simplified, potent reintroduction of email. A fresh start, the way it should be.

HEY is our love letter to email, and we’re sending it to you on the Web, Mac, Windows, Linux, iOS, and Android.

What do you think of it ? If you already use it, can you please share your thoughts about it ?

9 tips for git

Jimmy Klein — Mon, 22 Jun 2020 10:23:20 +0000

If you use Git on a daily basis, you know that this tool is full of commands and different configuration options. I suggest here to list some tips that I use.

Configure your username and e-mail

$ git config --global user.name "Darth Vader"
$ git config --global user.email "darth-vader@deathstar.space"

I voluntarily start simple but it is a manipulation that happens to me quite often, my computer being used to manage several projects with different identities.
So if you have different information for a project, you can override this declaration at the level of your project:

$ cd ~/dev/my_project
$ git config user.name "Luke Skywalker"
$ git config user.email "luke-skywalker@jedi.force"

Ignore certain files globally

I recommend that you set up a global .gitignore file for your development environment in order to ignore the files related to your way of working (IDE used for example).

This avoids finding all the IDEs in the .gitignore files of your projects.

$ vi ~/.gitignore

Example with PHPStorm / Intellij directory

.idea

Configuring git

$ git config --global core.excludesfile ~/.gitignore

Click the following link to find a collection of gitignore file templates: https://github.com/github/gitignore

Choose the commit editor

If you don't want to use vi, ask git to use another editor for your commits !

# With nano
$ git config --global core.editor nano

# You can also choose a graphical editor
# Visual Studio Code
$ git config --global core.editor "code --wait"

# Sublime text
$ git config --global core.editor "subl -n -w"

# Atom
$ git config --global core.editor "atom --wait"

Change the default log display format

If the format of the git log command does not suit you, you can change it or define a custom one.

# One line display by default
$ git config --global format.pretty oneline

# You can also define your own log display format
$ git config --global format.pretty "format:%h%x09%an"

# And save it
$ git config --global pretty.my-custom-log-format "format:%h%x09%an"


# Which allows either to use it on demand
$ git log --pretty=my-custom-log-format

# Or define it as the default configuration
$ git config --global format.pretty my-custom-log-format

The list of formats and placeholders is available : https://git-scm.com/docs/pretty-formats

Use `fixup` to fix a previous commit and get a cleaner history

You probably know the --amend option in order to modify the last commit. But do you know the option --fixup and theautosquash to modify any previous commit.

Warning : the autosquash will modify the references of the commits in your branch. Not recommended if you are not comfortable with rebases and what it means.
You can do it serenely if you don't haven't pushed anything on remote yet.

Take the example where you are going to add a README file to your project.

List of commits on your branch where you are writing the file

$ git log

b58faee269c Add contribution in README
18a11d43eb2 Add deployment in README
8385fc0cd1a Initial commit

And there you see an error in the commit to add the deployment part (spelling error for example) (ref commit: 18a11d43eb2).

We fix the error and commit with the --fixup option

$ git commit --fixup 18a11d43eb2
94ae1b02f4a fixup! Add deployment in README

The git log now looks like:

$ git log
94ae1b02f4a fixup! Add deployment in README
b58faee269c Add contribution in README
18a11d43eb2 Add deployment in README
8385fc0cd1a Initial commit

We can then merge the original commit with the fixup commit

$ git rebase -i --autosquash 8385fc0cd1a

The fixup commit was squashed in the deployment section commit. We can see here the modification of the commits references.

$ git log
fc5c36d4183 Add contribution in README
0a94be69d2c Add deployment in README
8385fc0cd1a Initial commit

Standardize commit messages

Git lets you pre-fill commit messages from a template.

$ vi ~/.gitmessage

Short Title

IssueNumber

Why :

$ git config --global commit.template "~/.gitmessage"

New command git switch

Since version 2.23, a new command is available to switch branches.

Usually we use checkout

$ git checkout my_branch
Switched to branch 'my_branch'

We can now use the switch command

$ git switch my_branch
Switched to branch 'my_branch'

And if we want to create a new branch and switch on it

$ git switch -c my_new_branch # equivalent to git checkout -b my_new_branch
Switched to a new branch 'my_new_branch'

Go back to the previous branch

If you are a bit lazy like me, you can go back to the previous branch using the git switch - command

(master) $ git switch my_branch
Switched to branch 'my_branch'

(my_branch) $ git switch -
Switched to branch 'master'

It also works by doing git checkout -

Bonus (thanks to Julien Deniau for the tips):
You can also rebase or merge in the same way:

(master) $ git switch my_branch
(my_branch) $ git rebase -

New git restore command

If you want to restore a modified file to its original state, a new command has been added since version 2.23 of git: restore

# Usually we use `git checkout -- <file>`
(master) $ git status
Changes not staged for commit:
    modified:   README.md

(master) $ git checkout -- README.md
(master) $ git status
nothing to commit, working tree clean

# We can now use the command `git restore`
(master) $ git status
Changes not staged for commit:
    modified:   README.md

(master) $ git restore README.md
(master) $ git status
nothing to commit, working tree clean

Thank you for reading, and let's stay in touch !

If you liked this article, please share. I'm also writing a dev letter that you might like.

5 bad habits to lose in PHP

Jimmy Klein — Sat, 13 Jun 2020 15:33:53 +0000

I do a lot of code review and I often see the same mistakes. Here's how to correct them.

Test that an array is not empty before loop

$items = [];
// ...
if (count($items) > 0) {
    foreach ($items as $item) {
        // process on $item ...
    }
}

foreach loop or array function (array_*) can handle empty array.

No need to test it before
One less indentation level

$items = [];
// ...
foreach ($items as $item) {
    // process on $item ...
}

If you want to learn how to code without for/foreach/while loop, I recommend my article on collections (in French).

Encapsulate all the content of a method in an if statement

function foo(User $user) {
    if (!$user->isDisabled()) {
        // ...
        // long process
        // ...
    }
}

This one is not specific to PHP but I see it very often. I have already talk in my article about calisthenics objects and in my article about my minimalist code of reduce indentation level using early return.
All the "useful" body of the function is now at first indentation level

function foo(User $user) {
    if ($user->isDisabled()) {
        return;
    }

    // ...
    // long process
    // ...
}

Call multiple times isset method

$a = null;
$b = null;
$c = null;
// ...

if (!isset($a) || !isset($b) || !isset($c)) {
    throw new Exception("undefined variable");
}

// or

if (isset($a) && isset($b) && isset($c) {
    // process with $a, $b et $c
}

// or 

$items = [];
//...
if (isset($items['user']) && isset($items['user']['id']) {
    // process with $items['user']['id']
}

We often need to check that a variable is defined (and not null). In PHP, we can do this by using isset function. And, magic, it can take multiple parameters !

$a = null;
$b = null;
$c = null;
// ...

if (!isset($a, $b, $c)) {
    throw new Exception("undefined variable");
}

// or

if (isset($a, $b, $c)) {
    // process with $a, $b et $c
}

// or 

$items = [];
//...
if (isset($items['user'], $items['user']['id'])) {
    // process with $items['user']['id']
}

Combine the echo method with sprintf

$name = "John Doe";
echo sprintf('Bonjour %s', $name);

This bit of code may be smiling but I happened to write it a while ago. And I still see it quite a bit! Instead of combining echo andsprintf, we can simply use the printf method.

$name = "John Doe";
printf('Bonjour %s', $name);

Check the presence of a key in an array by combining two methods

$items = [
    'one_key' => 'John',
    'search_key' => 'Jane',
];

if (in_array('search_key', array_keys($items))) {
    // process
}

Last error I see quite often is the joint use of in_array andarray_keys. All of this can be replaced using array_key_exists.

$items = [
    'one_key' => 'John',
    'search_key' => 'Jane',
];

if (array_key_exists('search_key', $items)) {
    // process
}

We can also use isset which also check that the value is not null.

if (isset($items['search_key'])) {
    // process
}

Thank you for reading, and let's stay in touch !

If you liked this article, please share. You can also find me on Twitter/X for more PHP tips.

9 astuces pour git

Jimmy Klein — Sun, 10 May 2020 21:08:53 +0000

Si vous utilisez Git au quotidien, vous savez que cet outil regorge de commandes et de différentes options de configuration. Je vous propose ici de lister quelques astuces que j'utilise.

Configurer son nom d'utilisateur et son e-mail

git config --global user.name "Darth Vader"
git config --global user.email "darth-vader@deathstar.space"

Je commence volontairement assez simple mais c'est une manipulation qui m'arrive de faire assez souvent, mon ordinateur me servant à gérer plusieurs projets avec des identités différentes.
Donc si vous avez des informations différentes pour un projet, vous pouvez surchargez cette déclaration au niveau de votre projet :

cd ~/dev/my_project
git config user.name "Luke Skywalker"
git config user.email "luke-skywalker@jedi.force"

Ignorer globalement certains fichiers

Je vous recommande de mettre en place un fichier .gitignore global à votre environnement de développement afin d'ignorer les fichiers liés à votre manière de travailler (IDE utilisé par exemple).
Cela permet d'éviter de retrouver tous les IDE de la terre dans les fichiers .gitignore de vos projets.

vi ~/.gitignore

Exemple avec le répertoire de PHPStorm / Intellij

.idea

Configuration de git

git config --global core.excludesfile ~/.gitignore

Cliquez sur le lien suivant pour retrouver une collection de modèle de fichier gitignore : https://github.com/github/gitignore

Choisir l'éditeur de commit

Si vous êtes allérgiques à vi, demandez à git d'utiliser un autre éditeur pour vos commits

# Utilisation de nano par exemple
git config --global core.editor nano

# Vous pouvez aussi choisir un outil graphique
# Visual Studio Code
git config --global core.editor "code --wait"

# Sublime text
git config --global core.editor "subl -n -w"

# Atom
git config --global core.editor "atom --wait"

Modifier le format d'affichage des logs par défaut

Si le format de la commande git log ne vous convient pas, vous pouvez le changer ou en définir un personnalisé

# Affichage par défaut sur une ligne
$ git config --global format.pretty oneline

# On peut aussi définir son propre format d'affichage de log
$ git config --global format.pretty "format:%h%x09%an"

# Et l'enregistrer avec un nom
$ git config --global pretty.my-custom-log-format "format:%h%x09%an"


# Ce qui permet de soit de l'utiliser à la demande
$ git log --pretty=my-custom-log-format

# Soit de le définir aussi comme configuration par défaut
$ git config --global format.pretty my-custom-log-format

La liste des formats et des placeholders est disponible : https://git-scm.com/docs/pretty-formats

Utiliser `fixup` pour corriger un commit précédent et avoir un historique plus clean

Vous connaissez surement l'option --amend afin de modifier le dernier commit effectuée. Mais connaissez vous l'option --fixup et l'autosquash pour modifier n'importe quel commit précédent.

Attention : l'autosquash va modifier les références des commits de votre branche.
A déconseiller si vous n'êtes pas à l'aise avec les rebase et ce que ça induit
Vous pouvez le faire sereinement si vous n'avez encore rien poussé (push) sur des remotes distants.

Prenons l'exemple où vous allez ajouter un fichier README à votre projet.

Liste des commits sur votre branche où vous êtes entrain d'écrire le fichier

git log

b58faee269c Ajouter la partie contribution dans le README
18a11d43eb2 Ajouter la partie déploiement dans le README
8385fc0cd1a Initial commit

Et là vous constatez une erreur dans le commit d'ajout de la partie déploiement (faute d'orthographe par exemple) (ref commit : 18a11d43eb2).

On corrige l'erreur et on commit avec l'option --fixup

git commit --fixup 18a11d43eb2
94ae1b02f4a fixup! Ajouter la partie déploiement dans le README

Le git log ressemble désormais à :

git log
94ae1b02f4a fixup! Ajouter la partie déploiement dans le README
b58faee269c Ajouter la partie contribution dans le README
18a11d43eb2 Ajouter la partie déploiement dans le README
8385fc0cd1a Initial commit

On peut ensuite fusionner le commit d'origine avec le commit de fixup

git rebase -i --autosquash 8385fc0cd1a

Le commit de "fixup" a été squashé dans le commit de la partie déploiement. On voit bien ici la modification des références des commits.

git log
fc5c36d4183 Ajouter la partie contribution dans le README
0a94be69d2c Ajouter la partie déploiement dans le README
8385fc0cd1a Initial commit

Uniformiser les messages de commit

Git permet de pré-remplir les messages de commit à partir d'un modèle

vi ~/.gitmessage

Short Title

IssueNumber

Why :

git config --global commit.template "~/.gitmessage"

Nouvelle commande git switch

Depuis la version 2.23, une nouvelle commande est dipsonible pour changer de branche

Habituellement, on utilise checkout

git checkout my_branch
Switched to branch 'my_branch'

On peut désormais utiliser la commande switch

git switch my_branch
Switched to branch 'my_branch'

Et si on veut créer une nouvelle branche et switcher dessus

git switch -c my_new_branch # équivalent à git checkout -b my_new_branch
Switched to a new branch 'my_new_branch'

Revenir à la branche précédente

Si vous êtes un peu paresseux comme moi, vous pouvez revenir sur la branche précédente utilisant la commande git switch -

(master) $ git switch my_branch
Switched to branch 'my_branch'

(my_branch) $ git switch -
Switched to branch 'master'

Cela fonctionne aussi en faisant git checkout -

Bonus (merci à Julien Deniau pour l'astuce):
Vous pouvez aussi faire un rebase ou un merge de la même manière :

(master) $ git switch my_branch
(my_branch) $ git rebase -

Nouvelle commande git restore

Si vous voulez restaurer un fichier modifié dans son état d'origine, une nouvelle commande a été ajoutée depuis la version 2.23 de git : restore

# Habituellement on utilise `git checkout -- <file>`
(master) $ git status
Changes not staged for commit:
    modified:   README.md

(master) $ git checkout -- README.md
(master) $ git status
nothing to commit, working tree clean

# On peut désormais utiliser la command `git restore`
(master) $ git status
Changes not staged for commit:
    modified:   README.md

(master) $ git restore README.md
(master) $ git status
nothing to commit, working tree clean

Forem: Jimmy Klein

Simplify your code

Comments

Getter and setter

Temporary variables

Early return

Thank you for reading, and let's stay in touch !

Never write another loop again

Laravel collections

Thank you for reading, and let's stay in touch !

9 rules for writing (better?) code

1. Only one level of indentation per method

2. Do not use the else keyword

First solution: use of early return

Upstream initialization

Use of the Fail Fast principle

3. Wrap all primitive types in objects

4. First Class Collections: a class that contains an array as an attribute must not contain any other attribute

5. Only one -> per line (except for Fluent interface)

6. Not using abbreviations

7. Keep all entities small (classes, methods, packages/namespaces)

8. Classes should not contain more than five instance variables

9. No getter / setter

Thank you for reading, and let's stay in touch !

Check the presence of a key in an array in PHP - The right way

Thank you for reading, and let's stay in touch !

Be careful about the switch statement in PHP

But why this difference?

So what to do?

Thank you for reading, and let's stay in touch !

Create date easily in PHP

From a format

Thank you for reading, and let's stay in touch !

Never use `empty` function in PHP

What is the right method?

What if I want to test several things at the same time?

Thank you for reading, and let's stay in touch !

⚠️ [PHP] N'écrivez pas ce type de code en production ⚠️

Le array_ hell

On en profite pour réviser un peu

Merci d'avoir lu, et restons en contact !

Have you a hey.com account ? What do you think of it ?

9 tips for git

Configure your username and e-mail

Ignore certain files globally

Choose the commit editor

Change the default log display format

Use fixup to fix a previous commit and get a cleaner history

Standardize commit messages

New command git switch

Go back to the previous branch

New git restore command

Thank you for reading, and let's stay in touch !

5 bad habits to lose in PHP

Test that an array is not empty before loop

Encapsulate all the content of a method in an if statement

Call multiple times isset method

Combine the echo method with sprintf

Check the presence of a key in an array by combining two methods

Thank you for reading, and let's stay in touch !

9 astuces pour git

Configurer son nom d'utilisateur et son e-mail

Ignorer globalement certains fichiers

Choisir l'éditeur de commit

Modifier le format d'affichage des logs par défaut

Utiliser fixup pour corriger un commit précédent et avoir un historique plus clean

Uniformiser les messages de commit

Nouvelle commande git switch

Revenir à la branche précédente

Nouvelle commande git restore

2. Do not use the `else` keyword

5. Only one `->` per line (except for Fluent interface)

Le `array_` hell

Use `fixup` to fix a previous commit and get a cleaner history

Utiliser `fixup` pour corriger un commit précédent et avoir un historique plus clean