Javascript 循环浏览文件夹 Node.JS 中的文件

Looping through files in a folder Node.JS

提问by Prolasis

I am trying to loop through and pick up files in a directory, but I have some trouble implementing it. How to pull in multiple files and then move them to another folder?

我试图循环并拾取目录中的文件，但在实现它时遇到了一些麻烦。如何拉入多个文件，然后将它们移动到另一个文件夹？

var dirname = 'C:/FolderwithFiles';
console.log("Going to get file info!");
fs.stat(dirname, function (err, stats) {
    if (err) {
        return console.error(err);
    }
    console.log(stats);
    console.log("Got file info successfully!");

    // Check file type
    console.log("isFile ? " + stats.isFile());
    console.log("isDirectory ? " + stats.isDirectory());
});

回答by Mikey A. Leonetti

Older answer with callbacks

带有回调的旧答案

You want to use the fs.readdirfunction to get the directory contents and the fs.renamefunction to actually do the renaming. Both these functions have synchronous versions if you needto wait for them to finishing before running the code afterwards.

您想使用fs.readdir函数来获取目录内容，并使用fs.rename函数来实际进行重命名。如果您需要等待它们完成后再运行代码，这两个函数都有同步版本。

I wrote a quick script that does what you described.

我写了一个快速脚本来完成你所描述的。

var fs = require('fs');
var path = require('path');
// In newer Node.js versions where process is already global this isn't necessary.
var process = require("process");

var moveFrom = "/home/mike/dev/node/sonar/moveme";
var moveTo = "/home/mike/dev/node/sonar/tome"

// Loop through all the files in the temp directory
fs.readdir(moveFrom, function (err, files) {
  if (err) {
    console.error("Could not list the directory.", err);
    process.exit(1);
  }

  files.forEach(function (file, index) {
    // Make one pass and make the file complete
    var fromPath = path.join(moveFrom, file);
    var toPath = path.join(moveTo, file);

    fs.stat(fromPath, function (error, stat) {
      if (error) {
        console.error("Error stating file.", error);
        return;
      }

      if (stat.isFile())
        console.log("'%s' is a file.", fromPath);
      else if (stat.isDirectory())
        console.log("'%s' is a directory.", fromPath);

      fs.rename(fromPath, toPath, function (error) {
        if (error) {
          console.error("File moving error.", error);
        } else {
          console.log("Moved file '%s' to '%s'.", fromPath, toPath);
        }
      });
    });
  });
});

Tested on my local machine.

在我的本地机器上测试。

node testme.js 
'/home/mike/dev/node/sonar/moveme/hello' is a file.
'/home/mike/dev/node/sonar/moveme/test' is a directory.
'/home/mike/dev/node/sonar/moveme/test2' is a directory.
'/home/mike/dev/node/sonar/moveme/test23' is a directory.
'/home/mike/dev/node/sonar/moveme/test234' is a directory.
Moved file '/home/mike/dev/node/sonar/moveme/hello' to '/home/mike/dev/node/sonar/tome/hello'.
Moved file '/home/mike/dev/node/sonar/moveme/test' to '/home/mike/dev/node/sonar/tome/test'.
Moved file '/home/mike/dev/node/sonar/moveme/test2' to '/home/mike/dev/node/sonar/tome/test2'.
Moved file '/home/mike/dev/node/sonar/moveme/test23' to '/home/mike/dev/node/sonar/tome/test23'.
Moved file '/home/mike/dev/node/sonar/moveme/test234' to '/home/mike/dev/node/sonar/tome/test234'.

Update: fs.promises functions with async/await

更新：带有 async/await 的 fs.promises 函数

Inspired by ma11hew28's answer (shown here), here is the same thing as above but with the async functions in fs.promises. As noted by ma11hew28, this may have memory limitations versus fs.promises.opendiradded in v12.12.0.

受 ma11hew28 的回答（此处显示）的启发，这里与上面的内容相同，但在fs.promises 中使用了 async 函数。正如 ma11hew28 所指出的，与v12.12.0 中添加的 fs.promises.opendir相比，这可能具有内存限制。

Quick code below.

下面的快速代码。

//jshint esversion:8
//jshint node:true
const fs = require( 'fs' );
const path = require( 'path' );

const moveFrom = "/tmp/movefrom";
const moveTo = "/tmp/moveto";

// Make an async function that gets executed immediately
(async ()=>{
    // Our starting point
    try {
        // Get the files as an array
        const files = await fs.promises.readdir( moveFrom );

        // Loop them all with the new for...of
        for( const file of files ) {
            // Get the full paths
            const fromPath = path.join( moveFrom, file );
            const toPath = path.join( moveTo, file );

            // Stat the file to see if we have a file or dir
            const stat = await fs.promises.stat( fromPath );

            if( stat.isFile() )
                console.log( "'%s' is a file.", fromPath );
            else if( stat.isDirectory() )
                console.log( "'%s' is a directory.", fromPath );

            // Now move async
            await fs.promises.rename( fromPath, toPath );

            // Log because we're crazy
            console.log( "Moved '%s'->'%s'", fromPath, toPath );
        } // End for...of
    }
    catch( e ) {
        // Catch anything bad that happens
        console.error( "We've thrown! Whoops!", e );
    }

})(); // Wrap in parenthesis and call now

回答by ma11hew28

fs.readdir(path[, options], callback)(which Mikey A. Leonetti used in his answer) and its variants (fsPromises.readdir(path[, options])and fs.readdirSync(path[, options])) each reads all of a directory's entries into memory at once. That's good for most cases, but if the directory has very many entries and/or you want to lower your application's memory footprint, you could instead iterate over the directory's entries one at a time.

fs.readdir(path[, options], callback)（Mikey A. Leonetti 在他的回答中使用了它）及其变体（fsPromises.readdir(path[, options])和fs.readdirSync(path[, options])）每个都会一次将目录的所有条目读入内存。这对大多数情况来说都很好，但是如果目录有很多条目和/或您想降低应用程序的内存占用，您可以改为一次迭代一个目录条目。

Asynchronously

异步

Directories are async iterable, so you could do something like this:

目录是异步可迭代的，因此您可以执行以下操作：

const fs = require('fs')

async function ls(path) {
  const dir = await fs.promises.opendir(path)
  for await (const dirent of dir) {
    console.log(dirent.name)
  }
}

ls('.').catch(console.error)

Or, you could use dir.read()and/or dir.read(callback)directly.

或者，您可以直接使用dir.read()和/或dir.read(callback)。

Synchronously

同步

Directories aren't sync iterable, but you could use dir.readSync()directly. For example:

目录不可同步迭代，但您可以dir.readSync()直接使用。例如：

const fs = require('fs')

const dir = fs.opendirSync('.')
let dirent
while ((dirent = dir.readSync()) !== null) {
  console.log(dirent.name)
}
dir.closeSync()

Or, you could make directories sync iterable. For example:

或者，您可以使目录同步可迭代。例如：

const fs = require('fs')

function makeDirectoriesSyncIterable() {
  const p = fs.Dir.prototype
  if (p.hasOwnProperty(Symbol.iterator)) { return }
  const entriesSync = function* () {
    try {
      let dirent
      while ((dirent = this.readSync()) !== null) { yield dirent }
    } finally { this.closeSync() }
  }
  if (!p.hasOwnProperty(entriesSync)) { p.entriesSync = entriesSync }
  Object.defineProperty(p, Symbol.iterator, {
    configurable: true,
    enumerable: false,
    value: entriesSync,
    writable: true
  })
}
makeDirectoriesSyncIterable()

And then, you could do something like this:

然后，你可以做这样的事情：

const dir = fs.opendirSync('.')
for (const dirent of dir) {
  console.log(dirent.name)
}

---

---

Note: "In busy processes, use the asynchronous versions of these calls. The synchronous versions will block the entire process until they complete, halting all connections."

注意：“在繁忙的进程中，使用这些调用的异步版本。同步版本将阻塞整个进程，直到它们完成，停止所有连接。”

References:

参考：

• Node.js Documentation: File System: Class fs.Dir
• Node.js source code: fs.Dir
• GitHub: nodejs/node: Issues: streaming / iterative fs.readdir #583

• Node.js 文档：文件系统： Class fs.Dir
• Node.js 源代码： fs.Dir
• GitHub: nodejs/node: 问题: 流/迭代 fs.readdir #583