Quoi de neuf en PHP

PHP 8.4 : Quoi de neuf et comment l'utiliser

PHP 8.4 est là, apportant plusieurs fonctionnalités intéressantes qui simplifient le codage et améliorent les performances. Cet article explique les mises à jour les plus importantes avec des exemples simples, permettant aux développeurs de tous niveaux de comprendre et d'utiliser facilement ces fonctionnalités.

1. Crochets de propriété

Les hooks de propriété vous permettent de personnaliser ce qui se passe lorsque vous obtenez ou définissez une propriété. Cela supprime le besoin de méthodes getter et setter distinctes.

Exemple:

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

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

    // This property combines first and last name
    public string $fullName {
        get => $this->firstName . ' ' . $this->lastName;
        set => [$this->firstName, $this->lastName] = explode(' ', $value, 2);
    }
}

$user = new User('John', 'Doe');
echo $user->fullName; // Output: John Doe

$user->fullName = 'Jane Smith'; // Updates first and last names
echo $user->fullName; // Output: Jane Smith

Pourquoi c'est utile :

Les hooks de propriété rendent votre code plus propre et réduisent le passe-partout.

2. Visibilité asymétrique

Vous pouvez désormais définir différents niveaux de visibilité pour la lecture et l'écriture d'une propriété. Par exemple, une propriété peut être lisible par tout le monde mais uniquement accessible en écriture par la classe elle-même.

Exemple:

class BankAccount {
    public private(set) float $balance; // Public read, private write

    public function __construct(float $initialBalance) {
        $this->balance = $initialBalance; // Allowed here
    }

    public function deposit(float $amount): void {
        $this->balance += $amount; // Allowed here
    }
}

$account = new BankAccount(100.0);
echo $account->balance; // Output: 100

$account->deposit(50.0); // Adds 50 to the balance
echo $account->balance; // Output: 150

// The following line will cause an error:
// $account->balance = 200.0;

Pourquoi c'est utile :

Cette fonctionnalité facilite le contrôle de la manière dont une propriété est accessible et mise à jour.

3. Nouvelles fonctions de tableau

PHP 8.4 ajoute de nouvelles fonctions de tableau qui vous évitent d'écrire des boucles manuelles.

Exemple:

$numbers = [1, 2, 3, 4, 5];

// Find the first even number
$firstEven = array_find($numbers, fn($n) => $n % 2 === 0);
echo $firstEven; // Output: 2

// Check if any number is greater than 4
$hasBigNumber = array_any($numbers, fn($n) => $n > 4);
var_dump($hasBigNumber); // Output: bool(true)

// Check if all numbers are positive
$allPositive = array_all($numbers, fn($n) => $n > 0);
var_dump($allPositive); // Output: bool(true)

Pourquoi c'est utile :

Ces fonctions rendent les opérations sur les tableaux plus rapides à écrire et plus faciles à comprendre.

4. Instanciation d'objet simplifiée

Vous pouvez désormais créer un objet et appeler une méthode dessus immédiatement, sans mettre l'instanciation entre parenthèses.

Exemple:

class Logger {
    public function log(string $message): void {
        echo $message;
    }
}

// Create an object and call a method in one step
new Logger()->log('Logging a message'); // Output: Logging a message

Pourquoi c'est utile :

Cela réduit la syntaxe inutile, rendant votre code plus propre.

5. Dépréciation des types implicites nullables

PHP 8.4 vous oblige à déclarer explicitement quand un paramètre peut être nul. Cela rend le code plus facile à comprendre et à maintenir.

Exemple:

// PHP 8.4 (Recommended):
function process(?string $data = null) {
    echo $data ?? 'No data provided';
}

Pourquoi c'est utile :

Les déclarations explicites évitent toute confusion et réduisent les bogues potentiels.

6. Objets paresseux

Les objets paresseux vous permettent de retarder la création d'un objet jusqu'à ce qu'il soit réellement utilisé, ce qui peut économiser des ressources.

Exemple:

class ExpensiveResource {
    public function __construct() {
        // Simulate a time-consuming setup
        sleep(2);
    }

    public function doWork(): void {
        echo 'Working...';
    }
}

// Use a lazy object to delay creation
$initializer = fn() => new ExpensiveResource();
$reflector = new ReflectionClass(ExpensiveResource::class);
$resource = $reflector->newLazyProxy($initializer);

// The object isn't created yet
$resource->doWork(); // Now the object is created and "Working..." is printed

Pourquoi c'est utile :

Ceci est particulièrement utile lorsqu'il s'agit d'opérations coûteuses ou de grands systèmes.

Conclusion

PHP 8.4 introduit plusieurs fonctionnalités qui rendent le codage plus simple et plus puissant :

• Property Hooks : remplace les fonctions getter et setter.
• Visibilité asymétrique : Meilleur contrôle de l'accès à la propriété.
• Nouvelles fonctions de tableau : simplifiez les opérations courantes sur les tableaux.
• Instanciation d'objet simplifiée : Création d'objets plus propres.
• Dépréciation des types implicites nullables : code plus sûr et plus clair.
• Objets paresseux : économisez des ressources en retardant la création d'objets.

Ces mises à jour rendront PHP encore plus agréable à utiliser, que vous soyez débutant ou développeur expérimenté. Commencez à explorer PHP 8.4 dès aujourd'hui !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!