Beispielanalyse, wie PHP Iteration zum Kopieren, Löschen und Anzeigen der Größe von Ordnern verwendet

Dieser Artikel stellt hauptsächlich die Methode von PHP vor, um das Kopieren, Löschen, Überprüfen der Größe und andere Vorgänge auf der Grundlage von Iterationen zu realisieren. Er erläutert kurz das Prinzip der Iteration und analysiert es anhand von Beispielen. Es wird ein iterativer Algorithmus verwendet, um Ordner zu realisieren Kopieren, Löschen und Verwandte Implementierungskenntnisse allgemeiner Vorgänge wie das Überprüfen der Größe finden Freunde in Not unter

Dieser Artikel beschreibt die PHP-Methode zum Implementieren des Kopierens, Löschens, Überprüfens der Größe und anderer Vorgänge von Ordnern Iteration. Teilen Sie es als Referenz mit allen:

Vorheriger Artikel PHP implementiert rekursiv Vorgänge zum Kopieren, Löschen und Anzeigen der Größe von Ordnern. Die Techniken zur Verwendung rekursiver Vorgänge werden hier analysiert Techniken zur Iteration.

„Da die Rekursion das Problem sehr gut lösen kann, warum sollte man dann Iteration verwenden?“ Der Hauptgrund sind Effizienzprobleme...

Das Konzept der Rekursion besteht darin, die Funktion selbst aufzurufen und ein komplexes Problem in mehrere ähnliche zu lösende Teilprobleme zu zerlegen, wodurch die Codemenge erheblich reduziert und die Funktion vereinfacht werden kann Das Programm sieht sehr elegant aus.

Weil das System jedem Funktionsaufruf laufenden Speicherplatz zuweist und ihn mithilfe von Stack Push aufzeichnet. Nachdem der Funktionsaufruf beendet ist, muss das System Speicherplatz freigeben und den Stapel öffnen, um den Haltepunkt wiederherzustellen. Daher sind die Rekursionskosten immer noch relativ hoch.

Auch wenn das Sprachdesign Funktionsaufrufe so perfekt optimiert hat, dass die durch die Rekursion verursachte Ressourcenverschwendung ignoriert werden kann, wird die Rekursionstiefe dennoch durch die Systemstapelkapazität begrenzt, andernfalls wird ein StackOverflowError ausgelöst.

Und die Iteration kann die Eigenschaften von Computern nutzen, die für wiederholte Operationen geeignet sind, und theoretisch können alle rekursiven Funktionen in iterative Funktionen umgewandelt werden. Versuchen Sie daher, eine Rekursion ohne Rekursion zu vermeiden, und verwenden Sie die Iteration. Verwenden Sie die Iteration stattdessen.

Ordnergröße anzeigen

Die Idee der Iteration besteht darin, den Computer bei jeder Ausführung wiederholt eine Reihe von Anweisungen ausführen zu lassen Befehlssatz, andere neue Werte werden vom ursprünglichen Wert der Variablen abgeleitet... Dieser Vorgang wird wiederholt, bis die Endbedingung erreicht ist oder kein neuer Wert generiert wird.

Da die Rekursion einer Schleife plus einem Stapel entspricht, kann der Stapel in der Iteration zum Konvertieren von Rekursion und Iteration verwendet werden.

/**
 * 文件夹大小
 * @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;
}

Ordner kopieren

Sowohl Iteration als auch Rekursion verfügen über Initialisierungsvariablen und Endbedingungen für die Beurteilung Die vier Schritte zur Durchführung tatsächlicher Operationen und zur Generierung neuer Variablen befinden sich lediglich an unterschiedlichen Orten.

Zum Beispiel steht der Schritt der Variableninitialisierung am Anfang der Funktion in der Iteration, während er sich bei der Rekursion auf den Prozess der Übergabe von Parametern an andere Funktionen bezieht;

Der Schritt des Beurteilens die Endbedingung. Sie wird in der Iteration verwendet, um zu bestimmen, ob die Schleife fortgesetzt wird, und in der Rekursion wird sie verwendet, um die Endposition der Rekursion zu bestimmen;

Das Ausführen tatsächlicher Operationen ist der Kernbestandteil der Funktion in beiden Rekursionen und Iteration, vor dem Schritt der Generierung neuer Variablen;

Die Generierung neuer Variablen in der Iteration ist die Bedingung für die Fortsetzung der Iteration, und in der Rekursion ist sie die Grundlage für die nächste Rekursion Rekursion oder Iteration, um fortzufahren.

/**
 * 复制文件夹
 * @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;
}

Ordner löschen

Abgesehen von den Sprachfunktionen wirkt sich dies am meisten auf die Leistung aus Redundanzcode, redundanter Code wird normalerweise durch unzureichendes Design verursacht.

In den meisten Fällen weist die Rekursion mehr redundanten Code als die Iteration auf, was ebenfalls ein wesentlicher Faktor für die geringe Effizienz der Rekursion ist.

Aber wenn der rekursive Code präzise genug und die Redundanz niedrig genug ist, ist die Leistung der Iteration möglicherweise nicht höher als die der Rekursion.

Diese durch Iteration implementierte Funktion zum Löschen von Ordnern ist beispielsweise 20 % langsamer als die Rekursion. Der Hauptgrund ist die Beurteilung eines leeren Ordners. Wenn der Ordner keine Unterordner hat, löscht die Funktion direkt alle Dateien und aktuellen Ordner wird die Rekursion beendet.

Auch wenn der Ordner während der Iteration leer ist, muss er im Stapel gespeichert werden. Bei der nächsten Iteration wird beurteilt, ob er leer ist, bevor er gelöscht werden kann. Im Vergleich zur Rekursion sind hier redundantere Vorgänge erforderlich, z. B. das Feststellen, dass die Datei leer ist, das Speichern auf dem Stapel und das Herausnehmen von Iterationen, sodass die Verarbeitungsgeschwindigkeit langsamer ist als bei der Rekursion.

/**
 * 删除文件夹
 * @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));
}

Ausführungszeit anzeigen

Dies ist eine Ansicht der Codeausführungszeit (in Millisekunden). ) Die Funktion führt den Zielcode (oder die Zielfunktion) über einen Rückruf aus und berechnet schließlich die Ausführungszeit (Millisekunden). Mit diesem Tool können Sie die Leistungslücke zwischen Funktionen vergleichen. Es ist ein sehr einfaches und praktisches Tool.

/**
 * 函数执行毫秒数
 * @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 () {
  /* 执行的耗时操作 */
});

Das obige ist der detaillierte Inhalt vonBeispielanalyse, wie PHP Iteration zum Kopieren, Löschen und Anzeigen der Größe von Ordnern verwendet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!