PHP implémente la copie, la suppression, la taille d'affichage, etc. de dossiers en fonction de l'itération

Cet article présente principalement la méthode PHP pour réaliser la copie, la suppression, la vérification de la taille et d'autres opérations basées sur l'itération. Il explique brièvement le principe de l'itération et l'analyse sous forme d'exemples. copie, suppression et Découvrez les techniques de mise en œuvre pertinentes pour les opérations courantes telles que la taille. Les amis dans le besoin peuvent se référer à

Les détails sont les suivants :

Le concept de récursivité est d'appeler le. fonctionner lui-même, en décomposant un problème complexe en plusieurs problèmes similaires. La résolution de sous-problèmes peut réduire considérablement la quantité de code et donner au programme un aspect très élégant.

Parce que le système doit allouer de l'espace d'exécution pour chaque appel de fonction et utiliser le stack push pour l'enregistrer. Une fois l'appel de fonction terminé, le système doit libérer de l'espace et ouvrir la pile pour restaurer le point d'arrêt. Le coût de la récursivité reste donc relativement élevé.

Même si la conception du langage a si parfaitement optimisé les appels de fonction que le gaspillage de ressources provoqué par la récursivité peut être ignoré, la profondeur de la récursion sera toujours limitée par la capacité de la pile du système, sinon une StackOverflowError sera levée.

Et l'itération peut faire bon usage des caractéristiques des ordinateurs qui sont adaptées aux opérations répétées, et théoriquement, toutes les fonctions récursives peuvent être converties en fonctions itératives, alors essayez d'éviter la récursion sans récursion et utilisez l'itération Utilisez l'itération plutôt.

Afficher la taille du dossier

L'idée de l'itération est de laisser l'ordinateur exécuter à plusieurs reprises un ensemble d'instructions, à chaque fois qu'il l'exécute ensemble d'instructions, d'autres nouvelles valeurs sont déduites de la valeur originale de la variable... Ce processus est répété jusqu'à ce que la condition finale soit atteinte ou qu'aucune nouvelle valeur ne soit générée.

Puisque la récursion est équivalente à une boucle plus une pile, la pile peut être utilisée en itération pour convertir la récursivité et l'itération.

/**
 * 文件夹大小
 * @param $path
 * @return int
 */
function dirsize($path)
{
  /* 初始条件 */
  $size = 0;
  $stack = array();
  if (file_exists($path)) {
    $path = realpath($path) . '/';
    array_push($stack, '');
  } else {
    return -1;
  }
  /* 迭代条件 */
  while (count($stack) !== 0) {
    $dir = array_pop($stack);
    $handle = opendir($path . $dir);
    /* 执行过程 */
    while (($item = readdir($handle)) !== false) {
      if ($item == '.' || $item == '..') continue;
      $_path = $path . $dir . $item;
      if (is_file($_path)) $size += filesize($_path);
      /* 更新条件 */
      if (is_dir($_path)) array_push($stack, $dir . $item . '/');
    }
    closedir($handle);
  }
  return $size;
}

Copier le dossier

L'itération et la récursivité ont des variables initialisées, Le quatre étapes consistant à déterminer la condition finale, à effectuer des opérations réelles et à générer de nouvelles variables se situent simplement à des endroits différents.

Par exemple, l'étape d'initialisation des variables est située au début de la fonction en itération, tandis qu'en récursivité elle fait référence au processus de transmission des paramètres à d'autres fonctions

L'étape de jugement ; la condition de fin, elle est utilisée en itération pour déterminer si la boucle continue, et en récursion, elle est utilisée pour déterminer la position finale de la récursion ;

L'exécution d'opérations réelles est la partie essentielle de la fonction dans les deux récursions et itération, avant l'étape de génération de nouvelles variables ;

La génération de nouvelles variables en itération est la condition de la suite de l'itération, et en récursion c'est la base de la prochaine récursion. La génération de nouvelles variables permet la. récursivité ou itération pour continuer.

/**
 * 复制文件夹
 * @param $source
 * @param $dest
 * @return string
 */
function copydir($source, $dest)
{
  /* 初始条件 */
  $stack = array();
  $target = '';
  if (file_exists($source)) {
    if (!file_exists($dest)) mkdir($dest);
    $source = realpath($source) . '/';
    $dest = realpath($dest) . '/';
    $target = realpath($dest);
    array_push($stack, '');
  }
  /* 迭代条件 */
  while (count($stack) !== 0) {
    $dir = array_pop($stack);
    $handle = opendir($source . $dir);
    if (!file_exists($dest . $dir)) mkdir($dest . $dir);
    /* 执行过程 */
    while (($item = readdir($handle)) !== false) {
      if ($item == '.' || $item == '..') continue;
      $_source = $source . $dir . $item;
      $_dest = $dest . $dir . $item;
      if (is_file($_source)) copy($_source, $_dest);
      /* 更新条件 */
      if (is_dir($_source)) array_push($stack, $dir . $item . '/');
    }
    closedir($handle);
  }
  return $target;
}

Supprimer le dossier

Laissez de côté les fonctionnalités linguistiques qui affectent les performances du la plupart des codes sont redondants. Le code redondant est généralement dû à une conception inadéquate.

Dans la plupart des cas, la récursion a plus de code redondant que l'itération, ce qui est également un facteur majeur dans la faible efficacité de la récursivité.

Mais lorsque le code récursif est suffisamment concis et que la redondance est suffisamment faible, les performances de l'itération ne peuvent pas être supérieures à celles de la récursivité.

Par exemple, cette fonction de suppression de dossier implémentée par itération est 20 % plus lente que la récursion. La raison principale est le jugement de dossier vide, lorsque le dossier n'a pas de sous-dossier, la fonction supprimera directement tous les fichiers. et le dossier actuel, la récursion se termine.

Même si le dossier est vide lors de l'itération, il doit être stocké dans la pile. Il sera jugé s'il est vide lors de l'itération suivante avant de pouvoir être supprimé. Par rapport à la récursivité, cela implique des opérations plus redondantes telles que déterminer que le fichier est vide, le stocker sur la pile et supprimer des itérations, de sorte que la vitesse de traitement sera plus lente que la récursivité.

/**
 * 删除文件夹
 * @param $path
 * @return bool
 */
function rmdirs($path)
{
  /* 初始化条件 */
  $stack = array();
  if (!file_exists($path)) return false;
  $path = realpath($path) . '/';
  array_push($stack, '');
  /* 迭代条件 */
  while (count($stack) !== 0) {
    $dir = end($stack);
    $items = scandir($path . $dir);
    /* 执行过程 */
    if (count($items) === 2) {
      rmdir($path . $dir);
      array_pop($stack);
      continue;
    }
    /* 执行过程 */
    foreach ($items as $item) {
      if ($item == '.' || $item == '..') continue;
      $_path = $path . $dir . $item;
      if (is_file($_path)) unlink($_path);
      /* 更新条件 */
      if (is_dir($_path)) array_push($stack, $dir . $item . '/');
    }
  }
  return !(file_exists($path));
}

Afficher le temps d'exécution

Ceci est une vue du temps d'exécution du code (millisecondes), exécutez le code cible (ou la fonction) via le rappel, et enfin calculez le temps d'exécution (millisecondes). Grâce à cet outil, vous pouvez comparer l'écart de performances entre les fonctions. C'est un outil très simple et pratique.

/**
 * 函数执行毫秒数
 * @param $func
 * @return int
 */
function exec_time($func)
{
  $start = explode(' ', microtime());
  $func();// 执行耗时操作
  $end = explode(' ', microtime());
  $sec_time = floatval($end[0]) - floatval($start[0]);
  $mic_time = floatval($end[1]) - floatval($start[1]);
  return intval(($sec_time + $mic_time) * 1000);
}
echo exec_time(function () {
  /* 执行的耗时操作 */
});

Recommandations associées :

PHP (Itération+Récursion ) Explication détaillée de l'implémentation de la classification à niveau infini

PHP utilise des variables statiques de fonction pour implémenter un itération spécifié nombre d'étapes Explication détaillée

Explication détaillée de l'utilisation de PHPIterator et Iterator

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!