Évitez les boucles infinies récursives dans le développement du langage PHP

Dans le développement PHP, les fonctions récursives sont souvent utilisées pour résoudre certains problèmes. Les fonctions récursives aident les programmeurs à résoudre les problèmes en s'appelant eux-mêmes, simplifiant ainsi le problème. Cependant, si les fonctions récursives sont mal écrites, elles peuvent entraîner des boucles infinies, occuper trop de mémoire et éventuellement faire planter le serveur. Par conséquent, lors de l’écriture de code PHP, vous devez suivre certaines règles pour vous assurer d’éviter le problème des boucles infinies récursives.

1. Condition de fin récursive claire

Toute fonction récursive doit avoir une condition de fin claire pour garantir que la fonction peut quitter la récursion et renvoyer une valeur. S'il n'y a pas de condition de fin appropriée, la fonction peut se répéter indéfiniment, conduisant finalement à une boucle infinie. Par conséquent, lors de l’écriture d’une fonction récursive, considérez d’abord la condition de fin. Par exemple, nous pouvons envisager d'utiliser une instruction if dans une fonction récursive pour déterminer si les paramètres de la fonction remplissent certaines conditions. Lorsque les conditions ne sont pas remplies, la récursion se termine.

Ce qui suit est un exemple de fonction récursive qui trouve factorielle, en utilisant une condition de fin explicite :

function factorial($n) {
  if ($n == 0) {
    return 1;
  } else {
    return $n * factorial($n - 1);
  }
}

Dans cette fonction, lorsque $n=0$, la fonction renvoie 1. Terminez la récursion.

2. Évitez une profondeur de récursion excessive

La pile d'appels de la fonction récursive créera une nouvelle image lors de chaque récursion et enregistrera les paramètres et l'état d'exécution dans la pile. Si la profondeur de récursion est trop grande, elle occupera trop de mémoire et risque de provoquer un crash du serveur. Par conséquent, lors de l'écriture de fonctions récursives, essayez d'éviter une profondeur de récursion excessive et réfléchissez également à la manière d'optimiser le code.

Ce qui suit est une fonction récursive de la séquence de Fibonacci. Puisque chaque récursion s'appelle deux fois, la profondeur de récursion est très grande et un débordement de pile est susceptible de se produire :

function fibonacci($n) {
  if ($n == 0 || $n == 1) {
    return $n;
  } else {
    return fibonacci($n - 1) + fibonacci($n - 2);
  }
}

#🎜 🎜#You. peut utiliser l'itération pour résoudre ce problème, comme indiqué ci-dessous :

function fibonacci($n) {
  $a = 0;
  $b = 1;
  for ($i = 0; $i < $n; $i++) {
    $c = $a + $b;
    $a = $b;
    $b = $c;
  }
  return $a;
}

Cette fonction utilise l'itération pour réduire la profondeur de récursion à 1, évitant ainsi le problème de débordement de pile.

3. Évitez d'utiliser des variables globales dans les fonctions récursives

La pile d'appels d'une fonction récursive contient non seulement les paramètres de la fonction et l'état d'exécution, mais contient également toutes les variables utilisées dans la fonction . Si des variables globales sont utilisées dans des fonctions récursives, la valeur de la variable peut être écrasée. Par conséquent, lors de l’écriture de fonctions récursives, évitez d’utiliser des variables globales et utilisez plutôt des paramètres de fonction ou des variables locales.

Ce qui suit est un exemple de fonction récursive incorrecte qui utilise des variables globales :

$count = 0;

function count_nodes($node) {
  global $count;
  $count++;
  foreach ($node->children() as $child) {
    count_nodes($child);
  }
  return $count;
}

Cette fonction compte le nombre de nœuds dans un document XML, mais en raison de l'utilisation de variables globales $count, provoquant la réécriture de la valeur de $count à chaque fois pendant la récursion, conduisant finalement à des erreurs de comptage. Vous pouvez utiliser des paramètres de fonction pour remplacer les variables globales, comme indiqué ci-dessous :

function count_nodes($node, $count = 0) {
  $count++;
  foreach ($node->children() as $child) {
    $count = count_nodes($child, $count);
  }
  return $count;
}

Dans cette fonction, le paramètre de fonction $count est utilisé pour remplacer les variables globales afin de garantir l'exactitude du décompte.

Pour résumer, les fonctions récursives présentent de grands avantages dans la résolution de problèmes, mais elles peuvent aussi causer de sérieux problèmes. Lors de l'écriture de fonctions récursives, vous devez suivre certaines règles, telles que des conditions de fin claires, éviter une profondeur de récursion excessive, éviter d'utiliser des variables globales, etc., pour garantir l'exactitude et la robustesse du code.

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!