PHP implements folder copying, deletion, viewing size, etc. based on iteration

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 Check out the related implementation skills of common operations such as size. Friends who need it can refer to

. The details are as follows:

The concept of recursion is to call the function itself, decomposing a complex problem into many similar ones. Solving sub-problems can greatly reduce the amount of code and make the program look 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 not to use 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 and end of judgment The four steps of conditions, performing actual operations, 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 redundancy. Redundant code is usually caused by 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 using 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 view of code execution time (milliseconds ) function, 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 () {
  /* 执行的耗时操作 */
});

Related recommendations:

PHP (Iteration Recursion) to achieve unlimited Detailed explanation of level classification

PHP uses function static variables to implement the specified iterationnumber of steps

PHPIterator and Iterator Detailed explanation of usage

The above is the detailed content of PHP implements folder copying, deletion, viewing size, etc. based on iteration. For more information, please follow other related articles on the PHP Chinese website!