Programmation défensive en PHP

Nicolas Hart

Développeur Web chez TER'Informatique

@nclsHart

Programmation défensive ?

Programmation défensive

=

Conduite défensive

6 règles

Règle n°1

Typer, tout, partout, tout le temps

/**
 * @param int $a
 * @param int $b
 *
 * @return int
 */
function sum($a, $b)
{
    return $a + $b;
}

PHP 7 ❤️

function sum(int $a, int $b): int
{
    return $a + $b;
}

declare(strict_types=1);

function sum(int $a, int $b): int
{
    return $a + $b;
}

var_dump(sum(5.8, 10.3)); // => int(15)

declare(strict_types=1);

function sum(int $a, int $b): int
{
    return $a + $b;
}

var_dump(sum(5.8, 10.3));

// PHP Fatal error:
// Uncaught TypeError: Argument 1 passed to sum() must be of the type int,
// float given

Utiliser un analyseur de code statique

function sum(int $a, int $b): int
{
    return $a + $b;
}

sum(5.8, 10.3);

+------------------------------------------------------------------+
| Line | test.php                                                  |
+------------------------------------------------------------------+
| 8    | Parameter #1 $a of function sum expects int, float given. |
| 8    | Parameter #2 $b of function sum expects int, float given. |
+------------------------------------------------------------------+

[ERROR] Found 2 errors

/**
 * @param array<string, bool> $options
 */
function configure(array $options): void
{
    // ...
}

$options = [
    'multiple' => false,
    'required' => 1,
];

configure($options);

+--------------------------------------------------------------------+
| Line | test.php                                                    |
+--------------------------------------------------------------------+
| 16   | Parameter #1 $options of function configure expects         |
|      | array<string, bool>, array<string, int|false> given.        |
+--------------------------------------------------------------------+

[ERROR] Found 1 error

Règle n°2

Ne pas avoir d'état invalide

État invalide ?

class Employee
{
    private $lastName;

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

    public function setLastName(string $lastName): void
    {
        $this->lastName = $lastName;
    }
}

$employee = new Employee();
var_dump($employee->getLastName()); // => NULL

Propriétés privées par défaut

Pas de setter

class Employee
{
    private $lastName;

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

    public function setLastName(string $lastName): void
    {
        $this->lastName = $lastName;
    }
}

$employee = new Employee();
var_dump($employee->getLastName()); // => NULL

class Employee
{
    private $lastName;

    public function __construct(string $lastName)
    {
        $this->lastName = $lastName;
    }

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

$employee = new Employee('Berriot');
var_dump($employee->getLastName()); // => string(7) "Berriot"

Considérer les méthodes publiques comme des transactions

$order->setStatus(OrderStatus::CANCELLED);
$order->setCancelledAt(new \DateTimeImmutable());
$order->setReason('I do not need it anymore');

⇓

class Order
{
    public function cancel(string $reason): void
    {
        $this->reason = $reason;
        $this->status = OrderStatus::CANCELLED;
        $this->cancelledAt = new \DateTimeImmutable();
    }
}

Utiliser des Value Objects

Value Object ?

• Encapsule une donnée
• Auto validation
• Identité basée sur son contenu
• Immutable
• Exemple : Adresse, Email, etc

class User
{
    /**
     * @var string
     */
    private $email;

    public function __construct(string $email)
    {
        $this->email = $email;
    }
}

new User('tberriot'); // => no error

class User
{
    public function __construct(Email $email)
    {
        $this->email = $email;
    }
}

class Email
{
    public function __construct(string $email)
    {
        Assert::email($email);

        $this->email = $email;
    }
}

new User(new Email('tberriot')); // => InvalidArgumentException

Règle n°3

Vérifier les valeurs inattendues

class OrderStatus
{
    public const CANCELLED = 'cancelled';
    public const DELIVERED = 'delivered';
}

switch ($status) {
    case OrderStatus::CANCELLED:
        // ...
        break;
    case OrderStatus::DELIVERED:
        // ...
        break;
    default:
        throw new \LogicException(
            sprintf('Unexpected order status "%s".', $status)
        );
}

Règle n°4

Réduire la charge cognitive

Limiter les niveaux d'indentation

public function awesomeFunction()
{
    if (firstCondition) {
        // do something

        if (secondCondition) {
            // do Something
        }
    }
}

public function awesomeFunction()
{
    if (!firstCondition) {
        return;
    }

    // do something

    if (!secondCondition) {
        return;
    }

    // do Something
}

Pas de else

public function awesomeFunction()
{
    if (condition) {
        // do something
    } else {
        // do something else
    }
}

⇓

public function awesomeFunction()
{
    if (condition) {
        // do something

        return;
    }

    // do something else
}

Yoda condition

if ($value === 42) {
    // ...
}

⇓

if (42 === $value) {
    // ...
}

Utiliser des constantes

if ('cancelled' === $status) {
    // ...
}

⇓

if (OrderStatus::CANCELLED === $status) {
    // ...
}

Éviter les arguments "flag"

public function send(Message $message, bool $async = false)
{
    // ...
}

⇓

public function send(Message $message)
{
    // ...
}

public function sendAsync(Message $message)
{
    // ...
}

Automatisez

• friendsofphp/php-cs-fixer
• object-calisthenics/phpcs-calisthenics-rules

Règle n°5

Écrire des tests

Règle n°6

Moins c'est mieux

Écrivez le moins de code possible

about 15 - 50 errors per 1000 lines of delivered code.

Supprimez les fonctionnalités non utilisées

Conclusion

Soyez pragmatique

Merci !