34

I am trying to copy a folder using Node fs module. I am familiar with readFileSync() and writeFileSync() methods but I am wondering what method I should use to copy a specified folder?

peteb
  • 18,552
  • 9
  • 50
  • 62
y. lu
  • 341
  • 1
  • 3
  • 4
  • 10
    Possible duplicate of [Copy folder recursively in node.js](http://stackoverflow.com/questions/13786160/copy-folder-recursively-in-node-js) – Chad Robinson Aug 23 '16 at 16:41

6 Answers6

37

You can use fs-extra to copy contents of one folder to another like this

var fs = require("fs-extra");

fs.copy('/path/to/source', '/path/to/destination', function (err) {
  if (err) return console.error(err)
  console.log('success!')
});

There's also a synchronous version.

fs.copySync('/path/to/source', '/path/to/destination')
dinodsaurus
  • 4,937
  • 4
  • 19
  • 24
user3248186
  • 1,518
  • 4
  • 21
  • 34
32

Save yourself the extra dependency with just 10 lines of native node functions

Add the following copyDir function:

const { promises: fs } = require("fs")
const path = require("path")

async function copyDir(src, dest) {
    await fs.mkdir(dest, { recursive: true });
    let entries = await fs.readdir(src, { withFileTypes: true });

    for (let entry of entries) {
        let srcPath = path.join(src, entry.name);
        let destPath = path.join(dest, entry.name);

        entry.isDirectory() ?
            await copyDir(srcPath, destPath) :
            await fs.copyFile(srcPath, destPath);
    }
}

And then use like this:

copyDir("./inputFolder", "./outputFolder")

Further Reading

KyleMit
  • 30,350
  • 66
  • 462
  • 664
  • 1
    I really like the idea of avoiding the extra dependencies. I think that few of us actually realise the capabilities that are inherent in "vanilla node". – Jon Trauntvein Aug 10 '21 at 22:03
  • 1
    Amazing approach, thanks man! –  Dec 05 '21 at 15:19
  • 1
    Thanks man, this is amazing, avoid glob, fs-extra, and other dependencies using this stuff, you're my hero! – DavidZam Jan 17 '22 at 12:32
4

You might want to check out the ncp package. It does exactly what you're trying to do; Recursively copy files from a path to another.

Here's something to get your started : 

const fs = require("fs");
const path = require("path");
const ncp = require("ncp").ncp;
// No limit, because why not?
ncp.limit = 0;

var thePath = "./";
var folder = "testFolder";
var newFolder = "newTestFolder";

ncp(path.join(thePath, folder), path.join(thePath, newFolder), function (err) {
    if (err) {
        return console.error(err);
    }
    console.log("Done !");
});
fdrobidoux
  • 274
  • 4
  • 11
  • 1
    Why would someone choose `ncp` over `fs-extra`? – A. Wentzel Feb 12 '19 at 18:04
  • 1
    There are plenty of reasons to choose one tool over another. Back when I wrote that answer, it was the package I prefered for accomplishing that task. Nowadays it might be better to use `fs-extra`, but that doesn't mean my answer was bad at the time I wrote it. – fdrobidoux Feb 27 '19 at 02:09
  • I was not insinuating your answer was bad. I was just curious for myself. Thanks – A. Wentzel Feb 27 '19 at 21:25
  • 1
    ncp can copy files in a folder recursively whereas fs-extra only copies files directly under the folder – Tianzhen Lin Jun 26 '19 at 14:09
  • fs-extra also copies all the files recursively just like ncp does. I don't see any difference between them in terms of copying a folder. – vivek_reddy Apr 05 '20 at 18:49
2

I liked KyleMit's answer, but thought a parallel version would be preferable.

The code is in TypeScript. If you need JavaScript, just delete the : string type annotations on the line of the declaration of copyDirectory.

import { promises as fs } from "fs"
import path from "path"

export const copyDirectory = async (src: string, dest: string) => {
  const [entries] = await Promise.all([
    fs.readdir(src, { withFileTypes: true }),
    fs.mkdir(dest, { recursive: true }),
  ])

  await Promise.all(
    entries.map((entry) => {
      const srcPath = path.join(src, entry.name)
      const destPath = path.join(dest, entry.name)
      return entry.isDirectory()
        ? copyDirectory(srcPath, destPath)
        : fs.copyFile(srcPath, destPath)
    })
  )
}
Anders
  • 31
  • 1
1

Here's the synchronous version of @KyleMit answer

copyDirectory(source, destination) {
    fs.mkdirSync(destination, { recursive: true });
    
    fs.readdirSync(source, { withFileTypes: true }).forEach((entry) => {
      let sourcePath = path.join(source, entry.name);
      let destinationPath = path.join(destination, entry.name);

      entry.isDirectory()
        ? copyDirectory(sourcePath, destinationPath)
        : fs.copyFileSync(sourcePath, destinationPath);
    });
  }
Eonasdan
  • 7,563
  • 8
  • 55
  • 82
0

There is an elegant syntax. You can use the pwd-fs module.

const FileSystem = require('pwd-fs');
const pfs = new FileSystem();

async () => {
  await pfs.copy('./path', './dest');
}
Stanislav Potemkin
  • 11
  • 1