PHP uses iteration to implement folder-related operations (copy, delete, etc.)

This article mainly introduces the method of PHP to realize folder copying, deleting, checking size and other operations based on iteration. It briefly explains the principle of iteration and analyzes it in the form of examples. It uses iterative algorithm to realize folder copying, deletion and For related implementation skills of common operations such as checking the size, friends in need can refer to the following

This article describes the method of PHP based on iteration to implement folder copying, deletion, checking size and other operations. Share it with everyone for your reference, the details are as follows:

The previous article PHP recursively implements folder copy, delete, and check size operations. The techniques for using recursive operations are analyzed. Here, let’s analyze the iterative operation techniques.

"Since recursion can solve it very well, why use iteration?" The main reason is efficiency issues...

The concept of recursion is to call the function itself, decomposing a complex problem into multiple similar sub-problems to solve, which can greatly reduce the amount of code and make the program look like Very elegant.

Because the system needs to allocate running space for each function call and use stack push to record it. After the function call ends, the system needs to free up space and pop the stack to restore the breakpoint. So the cost of recursion is still relatively large.

Even if the language design has optimized function calls so perfectly that the waste of resources caused by recursion can be ignored, the depth of recursion will still be limited by the system stack capacity, otherwise a StackOverflowError will be thrown.

And iteration can make good use of the characteristics of computers that are suitable for repeated operations, and theoretically, all recursive functions can be converted into iterative functions, so try to avoid recursion without recursion, and use iteration Use iteration instead.

View the folder size

The idea of ​​iteration is to let the computer repeatedly execute a set of instructions. Each time this set of instructions is executed, , other new values ​​are deduced from the original value of the variable... This process is repeated until the end condition is reached or no new value is generated.

Since recursion is equivalent to a loop plus a stack, the stack can be used in iteration to convert recursion and iteration.

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

Copy folder

Both iteration and recursion have initialization variables, judging end conditions, and execution The four steps of actual operation and generating new variables are just in different locations.

For example, the step of initializing variables is located at the beginning of the function in iteration, while in recursion it refers to the process of passing parameters to other functions;

The step of judging the end condition, It is used in iteration to determine whether the loop continues, and in recursion it is used to determine the end position of the recursion;

Performing actual operations is the core part of the function in both recursion and iteration, before the step of generating new variables;

The generation of new variables is the condition for the continuation of the iteration in the iteration, and is the basis for the next recursion in the recursion. The generation of new variables allows the recursion or iteration to continue.

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

Delete folder

Putting aside language features, the thing that affects performance the most is redundant code. , redundant code is usually produced due to inadequate design.

In most cases, recursion has more redundant code than iteration, which is also a major factor causing low recursion efficiency.

But when the recursive code is concise enough and the redundancy is low enough, the performance of iteration may not be higher than that of recursion.

For example, this folder deletion function implemented by iteration is 20% slower than recursion. The main reason is the judgment of empty folder. In recursion, when the folder has no subfolders, the function will directly Delete all files and current folder, recursion ends.

Even if the folder is empty during iteration, it needs to be stored in the stack. It will be judged whether it is empty in the next iteration before it can be deleted. Compared with recursion, this has more redundant operations such as determining that the file is empty, storing it on the stack, and taking out iterations, so the processing speed will be slower than recursion.

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

View execution time

This is a function to view code execution time (milliseconds) , execute the target code (or function) through callback, and finally calculate the execution time (milliseconds). Through this tool, you can compare the performance gap between functions. It is a very simple and practical 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 () {
  /* 执行的耗时操作 */
});

The above is the detailed content of PHP uses iteration to implement folder-related operations (copy, delete, etc.). For more information, please follow other related articles on the PHP Chinese website!