Fermer

janvier 18, 2024

PHP 8 Unleashed : une plongée approfondie dans les fonctionnalités améliorées

PHP 8 Unleashed : une plongée approfondie dans les fonctionnalités améliorées


Introduction:

PHP, un langage de script côté serveur qui alimente une grande majorité de sites Web, a fait un pas de géant avec la sortie de PHP 8. Doté de fonctionnalités et d’améliorations innovantes, PHP 8 promet de révolutionner la façon dont les développeurs créent des applications Web. Dans cet article de blog complet, nous explorerons les fonctionnalités améliorées de PHP 8, plongerons dans des exemples concrets pour illustrer leurs applications pratiques et nous assurerons que nous abordons le sujet en tenant dûment compte des problèmes de droits d’auteur.

1 : Compilateur JIT – Turbocharger les performances PHP

Les interpréteurs PHP traditionnels fonctionnent en traduisant le code source en une représentation intermédiaire, que le Zend Engine exécute ensuite. Le compilateur JIT adopte une approche différente, traduisant le code PHP en code machine juste avant son exécution, l’optimisant pour l’architecture système spécifique.

La principale motivation du compilateur JIT est d’améliorer considérablement la vitesse d’exécution du code PHP. En convertissant le code PHP en code machine au moment de l’exécution, les tâches répétitives peuvent être exécutées plus efficacement, réduisant ainsi le temps d’exécution global. Cela peut avoir un impact profond sur les performances des applications Web, en particulier celles traitant de calculs complexes ou de grands ensembles de données.
Prenons un scénario dans lequel une application Web implique des calculs mathématiques complexes, tels que la génération de rapports statistiques. Avant PHP 8, les développeurs pouvaient optimiser l’algorithme ou utiliser des mécanismes de mise en cache pour atténuer les goulots d’étranglement des performances. Avec le compilateur JIT, les performances de ces calculs peuvent être améliorées sans nécessiter d’optimisations manuelles approfondies.

Exemple:


function calculateFactorial($n) {
if ($n <= 1) {
    return 1;
  }
  return $n * calculateFactorial($n - 1);
}

$result = calculateFactorial(10);
echo $result;

Dans cet exemple, le compilateur JIT optimise le calcul factoriel récursif, ce qui améliore les performances.

2 : Arguments nommés – Clarté et flexibilité dans les appels de fonction

PHP 8 introduit des arguments nommés, une fonctionnalité conçue pour améliorer la lisibilité du code et offrir aux développeurs une plus grande flexibilité lors de l'appel de fonctions. Les arguments nommés rendent les appels de fonction plus lisibles en permettant aux développeurs de transmettre des valeurs en spécifiant explicitement les noms des paramètres.

Exemple:


function createPerson($name, $age, $city) {

}
createPerson("John Doe", 25, "New York");

function createPersonWithNamedArgs($name, $age, $city) {

}
createPersonWithNamedArgs(name: "John Doe", age: 25, city: "New York");

Les arguments nommés améliorent la lisibilité du code et réduisent le risque de transmission des arguments dans le mauvais ordre.

Flexibilité dans les appels de fonction

Les arguments nommés permettent aux développeurs d'ignorer les paramètres facultatifs ou de spécifier uniquement ceux dont ils ont besoin. Ceci est particulièrement utile lorsqu’il s’agit de fonctions comportant un grand nombre de paramètres.

Exemple:


configureDatabase("localhost", "username", "password", "my_database", true, true);


configureDatabase(
    host: "localhost",
    username: "username",
    password: "password",
    database: "my_database"
);

Nous avons ignoré les paramètres facultatifs, fournissant uniquement les valeurs des paramètres nécessaires. Cela améliore l'expressivité du code et réduit le risque d'erreurs dues à des arguments mal placés.

3 : Attributs – Ajout de métadonnées au code

Les attributs, également appelés annotations dans d'autres langages, permettent aux développeurs d'ajouter des métadonnées aux éléments de code, fournissant ainsi des informations supplémentaires aux frameworks et aux outils.

Exemple:


#[Author("Jane Smith")]
class Article{
  #[Title("PHP 8 Enhanced Features")]
public function publish() {

  }
}

$classAttributes = attributes(Article::class);
$methodAttributes = attributes([Article::class, 'publish']);

Les attributs améliorent l'expressivité du code et facilitent une meilleure documentation.

4 : Types d'union – Sécurité de type améliorée

PHP 8 introduit les types d'union, permettant aux développeurs de spécifier qu'une variable peut avoir plusieurs types. Les déclarations de type traditionnelles en PHP impliquent souvent de spécifier un seul type pour une variable, ce qui limite la flexibilité d'accepter plusieurs types valides.

Exemple:


function processUserData($data) {

}

function processUserDataWithUnionType(string|int $data) {

}

Les types Union fournissent des déclarations de type plus claires, réduisant ainsi le risque d'erreurs d'exécution inattendues.

Sécurité de type améliorée :

Les types d'union contribuent à améliorer la sécurité des types en déclarant explicitement les types acceptables pour une variable. Cela réduit la probabilité d'erreurs d'exécution causées par des types inattendus.

Exemple:

function divideNumbers(float|int $a, float|int $b): float|int {
  if ($b === 0) {
    return 0; 
  }
  return $a / $b;
}

Dans cet exemple, le divideNumbers La fonction peut gérer à la fois les types float et int pour ses paramètres, améliorant ainsi la sécurité des types.

Les types Union fonctionnent bien avec les types nullables, permettant aux développeurs de spécifier qu'une variable peut être d'un certain type ou null.

5 : Match Expression – Simplification des instructions Switch

L'expression match en PHP 8 est une version améliorée de l'instruction switch, offrant une syntaxe plus concise et des fonctionnalités améliorées.

Exemple:


function getStatusMessage($status) {
  switch ($status) {
    case 'success':
      return 'Operation successful';
    case 'error':
      return 'An error occurred';
    default:
      return 'Unknown status';
  }
}

function getStatusMessageWithMatch($status) {
  return match ($status) {
    'success' => 'Operation successful',
    'error' => 'An error occurred',
    default => 'Unknown status',
  };
}

L'expression match simplifie la syntaxe et améliore la lisibilité du code.

Gestion de conditions complexes :

L'une des forces de l'expression match réside dans sa capacité à gérer des conditions complexes plus efficacement que les instructions switch.

Exemple:

$grade = 'B';
$result = match (true) {
    $grade == 'A' => 'Excellent',
    $grade == 'B' => 'Good',
    $grade == 'C' => 'Average',
    default => 'Fail',
};
echo $result;

Ici, l'expression de correspondance évalue un ensemble de conditions et renvoie le résultat correspondant en fonction de la première condition vraie.

6 : Opérateur Nullsafe – Atténuer les problèmes du pointeur nul

La gestion des valeurs nulles et la prévention des exceptions de pointeur nul sont depuis longtemps une préoccupation pour les développeurs. Les vérifications nulles traditionnelles peuvent conduire à un code verbeux et sujet aux erreurs, en particulier lorsqu'il s'agit d'objets ou de tableaux imbriqués. L'opérateur nullsafe (?->) simplifie et rationalise les vérifications nulles, permettant aux développeurs d'accéder aux propriétés ou d'appeler des méthodes sur des objets potentiellement nuls sans avoir besoin de vérifications explicites.

Exemple:


$length = 0;
if ($user !== null) {
  $address = $user->getAddress();
  if ($address !== null) {
    $length = $address->getLength();
  }
}

$length = $user?->getAddress()?->getLength() ?? 0;

Dans cet exemple, si $user, $user->getAddress()ou $user->getAddress()->getLength() est nulle, l'expression entière est évaluée à 0. Cela permet d'éviter les exceptions de pointeur nul et garantit une valeur par défaut en cas de valeur nulle. L'opérateur nullsafe réduit le besoin de vérifications nulles détaillées, ce qui permet d'obtenir un code plus propre.

L'opérateur nullsafe de PHP 8 offre une solution puissante et concise au défi de longue date de la gestion des valeurs nulles. En simplifiant la syntaxe des vérifications nulles, il améliore la lisibilité du code et réduit le risque d'exceptions de pointeur nul.

7 : Promotion de la propriété du constructeur – Rationalisation de l'initialisation des objets

La promotion des propriétés du constructeur dans PHP 8 permet aux développeurs de déclarer et d'initialiser les propriétés de classe directement dans le constructeur, réduisant ainsi le besoin de code passe-partout répétitif.

Exemple:


class MainPoints {
  public float $x;
public float $y;
  public function __construct(float $x, float $y) {
    $this->x = $x;
$this->y = $y;
  }
}

class MainPointsWithPromotion {
  public function __construct(public float $x, public float $y) {}
}

La promotion des propriétés du constructeur améliore la maintenabilité du code en réduisant la redondance dans l'initialisation des propriétés. La promotion des propriétés du constructeur prend en charge les modificateurs de visibilité (public, protégé, privé) et d'autres modificateurs de propriété tels que static.

Type de déclarations avec promotion :

La promotion des propriétés des constructeurs prend en charge les déclarations de type, améliorant ainsi la clarté du code et contribuant à la sécurité des types.

Exemple:

class Order {
  public function __construct(
public string $orderId,
public array $items,
public DateTime $orderDate
) {

  }
}

Dans cet exemple, le Order la classe garantit que $orderDate est un exemple de DateTimecontribuant à des déclarations de type plus précises.

8 : Exceptions d'erreur dans PHP 8

Erreurs nommées :

En PHP 8, les erreurs nommées fournissent une manière plus descriptive et significative de gérer les erreurs. Auparavant, les développeurs devaient s'appuyer sur des codes d'erreur ou des constantes pour identifier des erreurs spécifiques. Les erreurs nommées rendent la gestion des erreurs plus expressive et plus facile à comprendre.

Exemple:

try {

} catch (MyCustomError $error) {

echo "Caught MyCustomError: " . $error->getMessage();
} catch (AnotherError $error) {

echo "Caught AnotherError: " . $error->getMessage();
} catch (Exception $e) {

echo "Caught generic exception: " . $e->getMessage();
}

Ici, MyCustomError et AnotherError sont des erreurs nommées qui fournissent plus de contexte sur la nature de l’erreur détectée.

Interface jetable :

PHP 8 introduit le Throwable interface, qui est l'interface de base pour toutes les erreurs et exceptions en PHP. Cette unification permet aux développeurs de détecter à la fois les erreurs et les exceptions à l'aide d'un seul bloc catch.

Exemple:

try {

} catch (Throwable $throwable) {

echo "Caught throwable: " . $throwable->getMessage();
}

Désormais, un seul bloc catch peut gérer n'importe quel objet qui implémente le Throwable interface, offrant une approche plus cohérente de la gestion des erreurs.

Expression de lancement :

PHP 8 introduit l'expression throw, permettant de lancer des exceptions dans les expressions. Cette fonctionnalité améliore la concision du code en permettant aux développeurs de lancer des exceptions directement dans une expression.

Exemple:

function divide($numerator, $denominator) {

  $result = $denominator !== 0 ? $numerator / $denominator : throw new Exception("Cannot divide by zero");
  return $result;
}

Dans cet exemple, le throw new Exception(...) l'expression fait partie de l'opérateur conditionnel (? :), permettant une gestion concise des erreurs dans l'expression elle-même.

9 : Cartes faibles dans PHP 8 – Gestion des références d’objets

En PHP, les tableaux ou objets traditionnels qui font référence à d'autres objets peuvent par inadvertance empêcher la récupération de ces objets. Cela peut entraîner des fuites de mémoire et une utilisation accrue des ressources. Weak Maps répond à ce défi en permettant aux développeurs d'associer des données à des objets sans créer de références fortes. Cela signifie que l'objet référencé dans une Weak Map peut toujours être récupéré si aucune autre référence n'existe.

La syntaxe de base de Weak Maps implique la création d'un nouvel objet WeakMap et l'utilisation de son set et get méthodes pour associer et récupérer des données, respectivement.

$weakMap = new WeakMap();


$object = new stdClass();
$weakMap->set($object, 'Associated Data');


$data = $weakMap->get($object);


$weakMap->delete($object);

Mise en cache :

Les cartes faibles sont utiles pour implémenter des mécanismes de mise en cache dans lesquels les données sont associées à des objets, mais n'empêchent pas le garbage collection de ces objets.

class Cache {

  private WeakMap $cache;

publique fonction __construction() {

    $this->cache = new WeakMap();
  }
  public function getData(object $key): ?string{
    return $this->cache->get($key);
  }
  public function cacheData(object $key, string $data) {
    $this->cache->set($key, $data);
  }
}

Mémorisation :

Les cartes faibles peuvent être utilisées dans la mémorisation pour stocker des valeurs calculées associées à des objets spécifiques, permettant aux objets d'être récupérés lorsqu'ils ne sont plus nécessaires.

class Calculator {

  private WeakMap $results;

publique fonction __construction() {

    $this->results = new WeakMap();
  }
  public function calculateExpensiveOperation(object $input): int{

    if ($this->results->has($input)) {
      return $this->results->get($input);
    }

    $result = ;

$ ceci->résultats->ensemble($entrée, $résultat);

retour $résultat;

  }
}

Avantages des cartes faibles :

  1. Prévention des fuites de mémoire : Les cartes faibles empêchent les fuites de mémoire involontaires en permettant aux objets d'être récupérés lorsqu'ils ne sont plus utilisés.
  2. Gestion plus propre des ressources : Lorsqu'il s'agit de références d'objets, Weak Maps fournit un moyen plus propre d'associer des données sans créer de références fortes qui entravent le garbage collection.
  3. Mise en cache efficace : Dans les scénarios où la mise en cache est impliquée, Weak Maps garantit que les données mises en cache sont associées aux objets uniquement tant que ces objets sont accessibles.

Conclusion : adopter l'avenir du développement PHP

En conclusion, PHP 8 a inauguré une nouvelle ère pour le développement PHP, offrant une suite de fonctionnalités qui améliorent les performances, la lisibilité et la maintenabilité. En tant que développeurs, l'adoption de ces améliorations peut conduire à des bases de code plus efficaces et plus robustes. Cependant, il est crucial de rester attentif aux problèmes de droits d'auteur lors de l'intégration d'exemples de code et d'extraits de sources externes. Attribuez et demandez toujours l'autorisation si nécessaire, garantissant ainsi un partage éthique et responsable des connaissances au sein de la communauté des développeurs. Avec PHP 8, l'avenir du développement Web s'annonce plus prometteur que jamais, et en restant informés et en respectant les droits de propriété intellectuelle, les développeurs peuvent naviguer de manière responsable dans ce paysage passionnant.



Le meilleur outil 2023 pour ta croissance Instagram !



Source link