Node.js sistema de archivos

El módulo de sistema de archivos de Node.js (fsmódulo) proporciona una API rica para leer, escribir, eliminar archivos y realizar otras operaciones del sistema de archivos.

El módulo fs admite tanto métodos síncronos como asíncronos, lo que permite a los desarrolladores elegir la forma adecuada de manejar las operaciones de archivos según sus necesidades específicas.

Importar el módulo fs

Primero, necesitas importar el módulo fs:

var fs = require("fs")

Asíncrono y síncrono

Los métodos del módulo de sistema de archivos de Node.js (módulo fs) tienen versiones asíncronas y síncronas. Por ejemplo, la función para leer el contenido de un archivo tiene fs.readFile() asíncrono y fs.readFileSync() síncrono.

En los métodos asíncronos, el último parámetro es la función de callback, y el primer parámetro de la función de callback contiene la información de error.

Se recomienda usar métodos asíncronos; en comparación con los síncronos, los métodos asíncronos tienen mayor rendimiento, son más rápidos y no bloquean.

Ejemplo

Crea el archivo example.txt, con el siguiente contenido:

Ejemplo官网地址：www.example.com
文件读取实例

Crea el archivo file.js, con el siguiente código:

Ejemplo

var fs = require("fs");

// Lectura asíncrona
fs.readFile('input.txt', function (err, data) {
   if (err) {
       return console.error(err);
   }
   console.log("Lectura asíncrona: " + data.toString());
});

// Lectura síncrona
var data = fs.readFileSync('example.txt');
console.log("Lectura síncrona: " + data.toString());

console.log("El programa ha terminado.");

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
同步读取: Ejemplo官网地址：www.example.com
文件读取实例

程序执行完毕。
异步读取: Ejemplo官网地址：www.example.com
文件读取实例

Escribir en un archivo

Escritura asíncrona en archivo:

fs.writeFile('example.txt', 'Hello, World!', (err) => {
    if (err) {
        console.error('Error writing file:', err);
        return;
    }
    console.log('File written successfully');
});

Escritura síncrona en archivo:

try {
    fs.writeFileSync('example.txt', 'Hello, World!');
    console.log('File written successfully');
} catch (err) {
    console.error('Error writing file:', err);
}

Añadir contenido a un archivo

Añadir contenido de forma asíncrona:

fs.appendFile('example.txt', '\nAppending some text', (err) => {
    if (err) {
        console.error('Error appending to file:', err);
        return;
    }
    console.log('Text appended successfully');
});

Añadir contenido de forma síncrona:

try {
    fs.appendFileSync('example.txt', '\nAppending some text');
    console.log('Text appended successfully');
} catch (err) {
    console.error('Error appending to file:', err);
}

Eliminar un archivo

Eliminación asíncrona de archivo:

fs.unlink('example.txt', (err) => {
    if (err) {
        console.error('Error deleting file:', err);
        return;
    }
    console.log('File deleted successfully');
});

Eliminación síncrona de archivo:

try {
    fs.unlinkSync('example.txt');
    console.log('File deleted successfully');
} catch (err) {
    console.error('Error deleting file:', err);
}

Crear un directorio

Creación asíncrona de directorio:

fs.mkdir('new_directory', (err) => {
    if (err) {
        console.error('Error creating directory:', err);
        return;
    }
    console.log('Directory created successfully');
});

Creación síncrona de directorio:

try {
    fs.mkdirSync('new_directory');
    console.log('Directory created successfully');
} catch (err) {
    console.error('Error creating directory:', err);
}

Leer el contenido de un directorio

Lectura asíncrona del contenido de un directorio:

fs.readdir('new_directory', (err, files) => {
    if (err) {
        console.error('Error reading directory:', err);
        return;
    }
    console.log('Directory contents:', files);
});

Lectura síncrona del contenido de un directorio:

try {
    const files = fs.readdirSync('new_directory');
    console.log('Directory contents:', files);
} catch (err) {
    console.error('Error reading directory:', err);
}

Verificar si un archivo o directorio existe

Verificación asíncrona:

fs.access('example.txt', fs.constants.F_OK, (err) => {
    if (err) {
        console.log('File does not exist');
    } else {
        console.log('File exists');
    }
});

Verificación síncrona:

try {
    fs.accessSync('example.txt', fs.constants.F_OK);
    console.log('File exists');
} catch (err) {
    console.log('File does not exist');
}

Uso avanzado

1. Flujo de archivos

Los flujos de archivos se pueden usar para leer y escribir archivos grandes de manera eficiente, sin cargar todo el archivo en la memoria de una sola vez.

Flujo de lectura de archivos:

const fs = require('fs');

const readableStream = fs.createReadStream('large_file.txt', 'utf8');

readableStream.on('data', (chunk) => {
    console.log('Received chunk:', chunk);
});

readableStream.on('end', () => {
    console.log('No more data.');
});

Flujo de escritura de archivos:

const fs = require('fs');

const writableStream = fs.createWriteStream('output.txt');

writableStream.write('Hello, ');
writableStream.write('World!\n');

writableStream.end();

writableStream.on('finish', () => {
    console.log('All writes are now complete.');
});

2. Información estadística del sistema de archivos

Se puede usarfs.statofs.lstatpara obtener la información estadística de un archivo o directorio.

Obtener información estadística de forma asíncrona:

fs.stat('example.txt', (err, stats) => {
    if (err) {
        console.error('Error getting stats:', err);
        return;
    }
    console.log('Is file?', stats.isFile());
    console.log('Is directory?', stats.isDirectory());
    console.log('Size:', stats.size);
});

Obtener información estadística de forma síncrona:

try {
    const stats = fs.statSync('example.txt');
    console.log('Is file?', stats.isFile());
    console.log('Is directory?', stats.isDirectory());
    console.log('Size:', stats.size);
} catch (err) {
    console.error('Error getting stats:', err);
}

A continuación, vamos a conocer en detalle los métodos del sistema de archivos de Node.js.

Abrir un archivo

Sintaxis

La siguiente es la sintaxis para abrir un archivo en modo asíncrono:

fs.open(path, flags[, mode], callback)

Parámetros

La descripción de los parámetros es la siguiente:

  • path- La ruta del archivo.

  • flags- El comportamiento de apertura del archivo. Vea los valores específicos a continuación.

  • mode- Establece el modo (permisos) del archivo, el permiso predeterminado para archivos nuevos es 0666 (lectura y escritura).

  • callback- Función de callback, con dos parámetros como: callback(err, fd).

El parámetro flags puede tener los siguientes valores:

FlagDescripción
rAbre el archivo en modo de solo lectura. El archivo debe existir. Si el archivo no existe, se lanzará una excepción.
r+Abre el archivo en modo lectura y escritura. El archivo debe existir.
rsAbre el archivo en modo de solo lectura de forma síncrona. Es una operación bloqueante, pero en algunos sistemas operativos puede ofrecer mejor estabilidad.
rs+Abre el archivo en modo lectura y escritura de forma síncrona. Es una operación bloqueante, pero en algunos sistemas operativos puede ofrecer mejor estabilidad.
wAbre el archivo en modo de solo escritura. Si el archivo no existe, se crea; si existe, se trunca.
wxSimilar a 'w', pero falla si la ruta existe.
w+Abre el archivo en modo lectura y escritura. Si el archivo no existe, se crea; si existe, se trunca.
wx+Similar a 'w+', pero falla si la ruta existe.
aAbre el archivo en modo de agregar (append). Si el archivo no existe, se crea.
axSimilar a 'a', pero falla si la ruta existe.
a+Abre el archivo en modo lectura y agregar. Si el archivo no existe, se crea.
ax+Similar a 'a+', pero falla si la ruta existe.

Ejemplo

A continuación, creamos el archivo file.js y abrimos input.txt para lectura y escritura, el código es el siguiente:

var fs = require("fs");

// 异步打开文件
console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
  console.log("文件打开成功！");     
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
准备打开文件！
文件打开成功！

Obtener información del archivo

Sintaxis

La siguiente es la sintaxis para obtener información del archivo en modo asíncrono:

fs.stat(path, callback)

Parámetros

La descripción de los parámetros es la siguiente:

  • path- Ruta del archivo.

  • callback- Función de callback, con dos parámetros como: (err, stats),statsstats es el objeto fs.Stats.

Después de ejecutar fs.stat(path), se devuelve una instancia de la clase stats a su función de callback. Se pueden usar los métodos proporcionados por la clase stats para determinar las propiedades del archivo. Por ejemplo, para determinar si es un archivo:

var fs = require('fs');

fs.stat('/Users/liuht/code/itbilu/demo/fs.js', function (err, stats) {
    console.log(stats.isFile());         //true
})

Los métodos de la clase stats incluyen:

MétodoDescripción
stats.isFile()Devuelve true si es un archivo; de lo contrario, devuelve false.
stats.isDirectory()Devuelve true si es un directorio; de lo contrario, devuelve false.
stats.isBlockDevice()Devuelve true si es un dispositivo de bloques; de lo contrario, devuelve false.
stats.isCharacterDevice()Devuelve true si es un dispositivo de caracteres; de lo contrario, devuelve false.
stats.isSymbolicLink()Devuelve true si es un enlace simbólico; de lo contrario, devuelve false.
stats.isFIFO()Devuelve true si es FIFO; de lo contrario, devuelve false. FIFO es un tipo especial de tubería de comandos en UNIX.
stats.isSocket()Devuelve true si es un socket; de lo contrario, devuelve false.

Ejemplo

A continuación, creamos el archivo file.js, el código es el siguiente:

var fs = require("fs");

console.log("准备打开文件！");
fs.stat('input.txt', function (err, stats) {
   if (err) {
       return console.error(err);
   }
   console.log(stats);
   console.log("读取文件信息成功！");
   
   // 检测文件类型
   console.log("是否为文件(isFile) ? " + stats.isFile());
   console.log("是否为目录(isDirectory) ? " + stats.isDirectory());    
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
准备打开文件！
{ dev: 16777220,
  mode: 33188,
  nlink: 1,
  uid: 501,
  gid: 20,
  rdev: 0,
  blksize: 4096,
  ino: 40333161,
  size: 61,
  blocks: 8,
  atime: Mon Sep 07 2015 17:43:55 GMT+0800 (CST),
  mtime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST),
  ctime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST) }
读取文件信息成功！
是否为文件(isFile) ? true
是否为目录(isDirectory) ? false

Escribir en un archivo

Sintaxis

La siguiente es la sintaxis para escribir en un archivo en modo asíncrono:

fs.writeFile(file, data[, options], callback)

writeFile abre directamente el archivo; el modo predeterminado eswmodo, por lo que si el archivo existe, el contenido escrito por este método sobrescribirá el contenido anterior.

Parámetros

La descripción de los parámetros es la siguiente:

  • file- Nombre del archivo o descriptor de archivo.

  • data- Datos a escribir en el archivo, pueden ser un objeto String (cadena) o Buffer (búfer).

  • options- Este parámetro es un objeto que contiene {encoding, mode, flag}. La codificación predeterminada es utf8, el modo es 0666 y flag es 'w'.

  • callback- Función de callback, que solo contiene el parámetro de información de error (err), devuelto cuando falla la escritura.

Ejemplo

A continuación, creamos el archivo file.js, el código es el siguiente:

var fs = require("fs");

console.log("准备写入文件");
fs.writeFile('input.txt', '我是通 过fs.writeFile 写入文件的内容',  function(err) {
   if (err) {
       return console.error(err);
   }
   console.log("数据写入成功！");
   console.log("--------我是分割线-------------")
   console.log("读取写入的数据！");
   fs.readFile('input.txt', function (err, data) {
      if (err) {
         return console.error(err);
      }
      console.log("异步读取文件数据: " + data.toString());
   });
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
准备写入文件
数据写入成功！
--------我是分割线-------------
读取写入的数据！
异步读取文件数据: 我是通 过fs.writeFile 写入文件的内容

Leer un archivo

Sintaxis

La siguiente es la sintaxis para leer archivos en modo asíncrono:

fs.read(fd, buffer, offset, length, position, callback)

Este método utiliza un descriptor de archivo para leer el archivo.

Parámetros

La descripción del uso de los parámetros es la siguiente:

  • fd- El descriptor de archivo devuelto por el método fs.open().

  • buffer- El búfer donde se escriben los datos.

  • offset- El desplazamiento de escritura en el búfer.

  • length- El número de bytes que se van a leer del archivo.

  • position- La posición inicial de lectura del archivo. Si el valor de position es null, se leerá desde la posición actual del puntero del archivo.

  • callback- La función de devolución de llamada tiene tres parámetros: err, bytesRead, buffer. err es el mensaje de error, bytesRead indica el número de bytes leídos y buffer es el objeto del búfer.

Ejemplo

El contenido del archivo input.txt es:

Ejemplo官网地址：www.example.com

A continuación, creamos el archivo file.js, el código es el siguiente:

var fs = require("fs");
var buf = new Buffer.alloc(1024);

console.log("准备打开已存在的文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   console.log("准备读取文件：");
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }
      console.log(bytes + "  字节被读取");
      
      // 仅输出读取的字节
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }
   });
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
准备打开已存在的文件！
文件打开成功！
准备读取文件：
42  字节被读取
Ejemplo官网地址：www.example.com

Cerrar un archivo

Sintaxis

La siguiente es la sintaxis para cerrar archivos en modo asíncrono:

fs.close(fd, callback)

Este método utiliza un descriptor de archivo para leer el archivo.

Parámetros

La descripción del uso de los parámetros es la siguiente:

  • fd- El descriptor de archivo devuelto por el método fs.open().

  • callback- La función de devolución de llamada, sin parámetros.

Ejemplo

El contenido del archivo input.txt es:

Ejemplo官网地址：www.example.com

A continuación, creamos el archivo file.js, el código es el siguiente:

var fs = require("fs");
var buf = new Buffer.alloc(1024);

console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   console.log("准备读取文件！");
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }

      // 仅输出读取的字节
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }

      // 关闭文件
      fs.close(fd, function(err){
         if (err){
            console.log(err);
         } 
         console.log("文件关闭成功");
      });
   });
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
准备打开文件！
文件打开成功！
准备读取文件！
Ejemplo官网地址：www.example.com
文件关闭成功

Truncar un archivo

Sintaxis

La siguiente es la sintaxis para truncar archivos en modo asíncrono:

fs.ftruncate(fd, len, callback)

Este método utiliza un descriptor de archivo para leer el archivo.

Parámetros

La descripción del uso de los parámetros es la siguiente:

  • fd- El descriptor de archivo devuelto por el método fs.open().

  • len- La longitud del truncado del contenido del archivo.

  • callback- La función de devolución de llamada, sin parámetros.

Ejemplo

El contenido del archivo input.txt es:

site:www.example.com

A continuación, creamos el archivo file.js, el código es el siguiente:

var fs = require("fs");
var buf = new Buffer.alloc(1024);

console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   console.log("截取10字节内的文件内容，超出部分将被去除。");
   
   // 截取文件
   fs.ftruncate(fd, 10, function(err){
      if (err){
         console.log(err);
      } 
      console.log("文件截取成功。");
      console.log("读取相同的文件"); 
      fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
         if (err){
            console.log(err);
         }

         // 仅输出读取的字节
         if(bytes > 0){
            console.log(buf.slice(0, bytes).toString());
         }

         // 关闭文件
         fs.close(fd, function(err){
            if (err){
               console.log(err);
            } 
            console.log("文件关闭成功！");
         });
      });
   });
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
准备打开文件！
文件打开成功！
截取10字节内的文件内容，超出部分将被去除。
文件截取成功。
读取相同的文件
site:www.r
文件关闭成功

Eliminar un archivo

Sintaxis

La siguiente es la sintaxis para eliminar archivos:

fs.unlink(path, callback)

Parámetros

La descripción del uso de los parámetros es la siguiente:

  • path- La ruta del archivo.

  • callback- La función de devolución de llamada, sin parámetros.

Ejemplo

El contenido del archivo input.txt es:

site:www.example.com

A continuación, creamos el archivo file.js, el código es el siguiente:

var fs = require("fs");

console.log("准备删除文件！");
fs.unlink('input.txt', function(err) {
   if (err) {
       return console.error(err);
   }
   console.log("文件删除成功！");
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
准备删除文件！
文件删除成功！

Al volver a revisar el archivo input.txt, se descubre que ya no existe.

Crear un directorio

Sintaxis

La siguiente es la sintaxis para crear directorios:

fs.mkdir(path[, options], callback)

Parámetros

La descripción del uso de los parámetros es la siguiente:

  • path- La ruta del archivo.

  • El parámetro options puede ser:

    • recursive - Si se crea el directorio de forma recursiva, el valor predeterminado es false.
    • mode- Establece los permisos del directorio, el valor predeterminado es 0777.

  • callback- La función de devolución de llamada, sin parámetros.

Ejemplo

A continuación, creamos el archivo file.js, el código es el siguiente:

var fs = require("fs");
// tmp 目录必须存在
console.log("创建目录 /tmp/test/");
fs.mkdir("/tmp/test/",function(err){
   if (err) {
       return console.error(err);
   }
   console.log("目录创建成功。");
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
创建目录 /tmp/test/
目录创建成功。

Se puede agregar el parámetro recursive: true, sin importar si los directorios /tmp y /tmp/a existen o no:

fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
  if (err) throw err;
});

Leer un directorio

Sintaxis

La siguiente es la sintaxis para leer directorios:

fs.readdir(path, callback)

Parámetros

La descripción del uso de los parámetros es la siguiente:

  • path- La ruta del archivo.

  • callback- La función de devolución de llamada. La función de devolución de llamada tiene dos parámetros: err, files. err es el mensaje de error, y files es la lista de archivos en el directorio.

Ejemplo

A continuación, creamos el archivo file.js, el código es el siguiente:

var fs = require("fs");

console.log("查看 /tmp 目录");
fs.readdir("/tmp/",function(err, files){
   if (err) {
       return console.error(err);
   }
   files.forEach( function (file){
       console.log( file );
   });
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
查看 /tmp 目录
input.out
output.out
test
test.txt

Eliminar un directorio

Sintaxis

La siguiente es la sintaxis para eliminar directorios:

fs.rmdir(path, callback)

Parámetros

La descripción del uso de los parámetros es la siguiente:

  • path- La ruta del archivo.

  • callback- La función de devolución de llamada, sin parámetros.

Ejemplo

A continuación, creamos el archivo file.js, el código es el siguiente:

var fs = require("fs");
// 执行前创建一个空的 /tmp/test 目录
console.log("准备删除目录 /tmp/test");
fs.rmdir("/tmp/test",function(err){
   if (err) {
       return console.error(err);
   }
   console.log("读取 /tmp 目录");
   fs.readdir("/tmp/",function(err, files){
      if (err) {
          return console.error(err);
      }
      files.forEach( function (file){
          console.log( file );
      });
   });
});

El resultado de ejecutar el código anterior es el siguiente:

$ node file.js 
准备删除目录 /tmp/test
读取 /tmp 目录
……

Manual de referencia de métodos del módulo de archivos

La siguiente es la lista de métodos del módulo de archivos de Node.js:

NúmeroMétodo & Descripción
1fs.rename(oldPath, newPath, callback)
rename() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
2fs.ftruncate(fd, len, callback)
ftruncate() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
3fs.ftruncateSync(fd, len)
ftruncate() síncrono.
4fs.truncate(path, len, callback)
truncate() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
5fs.truncateSync(path, len)
truncate() síncrono.
6fs.chown(path, uid, gid, callback)
chown() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
7fs.chownSync(path, uid, gid)
chown() síncrono.
8fs.fchown(fd, uid, gid, callback)
fchown() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
9fs.fchownSync(fd, uid, gid)
fchown() síncrono.
10fs.lchown(path, uid, gid, callback)
lchown() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
11fs.lchownSync(path, uid, gid)
lchown() síncrono.
12fs.chmod(path, mode, callback)
chmod() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
13fs.chmodSync(path, mode)
chmod() síncrono.
14fs.fchmod(fd, mode, callback)
fchmod() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
15fs.fchmodSync(fd, mode)
fchmod() síncrono.
16fs.lchmod(path, mode, callback)
lchmod() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción. Solo disponible en Mac OS X.
17fs.lchmodSync(path, mode)
lchmod() síncrono.
18fs.stat(path, callback)
stat() asíncrono. La función de devolución de llamada tiene dos parámetros: err, stats. stats es un objeto fs.Stats.
19fs.lstat(path, callback)
lstat() asíncrono. La función de devolución de llamada tiene dos parámetros: err, stats. stats es un objeto fs.Stats.
20fs.fstat(fd, callback)
fstat() asíncrono. La función de devolución de llamada tiene dos parámetros: err, stats. stats es un objeto fs.Stats.
21fs.statSync(path)
stat() síncrono. Devuelve una instancia de fs.Stats.
22fs.lstatSync(path)
lstat() síncrono. Devuelve una instancia de fs.Stats.
23fs.fstatSync(fd)
fstat() síncrono. Devuelve una instancia de fs.Stats.
24fs.link(srcpath, dstpath, callback)
link() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
25fs.linkSync(srcpath, dstpath)
link() síncrono.
26fs.symlink(srcpath, dstpath[, type], callback)
symlink() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción. El parámetro type puede establecerse en 'dir', 'file' o 'junction' (por defecto es 'file').
27fs.symlinkSync(srcpath, dstpath[, type])
symlink() síncrono.
28fs.readlink(path, callback)
readlink() asíncrono. La función de devolución de llamada tiene dos parámetros: err, linkString.
29fs.realpath(path[, cache], callback)
realpath() asíncrono. La función de devolución de llamada tiene dos parámetros: err, resolvedPath.
30fs.realpathSync(path[, cache])
realpath() síncrono. Devuelve la ruta absoluta.
31fs.unlink(path, callback)
unlink() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
32fs.unlinkSync(path)
unlink() síncrono.
33fs.rmdir(path, callback)
rmdir() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
34fs.rmdirSync(path)
rmdir() síncrono.
35fs.mkdir(path[, mode], callback)
mkdir(2) asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción. El permiso de acceso predeterminado es 0777.
36fs.mkdirSync(path[, mode])
mkdir() síncrono.
37fs.readdir(path, callback)
readdir(3) asíncrono. Lee el contenido del directorio.
38fs.readdirSync(path)
readdir() síncrono. Devuelve la lista de archivos.
39fs.close(fd, callback)
close() asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
40fs.closeSync(fd)
close() síncrono.
41fs.open(path, flags[, mode], callback)
Abrir archivo de forma asíncrona.
42fs.openSync(path, flags[, mode])
Versión síncrona de fs.open().
43fs.utimes(path, atime, mtime, callback)
 
44fs.utimesSync(path, atime, mtime)
Modificar la marca de tiempo del archivo, especificado mediante la ruta del archivo.
45fs.futimes(fd, atime, mtime, callback)
 
46fs.futimesSync(fd, atime, mtime)
Modificar la marca de tiempo del archivo, especificado mediante el descriptor de archivo.
47fs.fsync(fd, callback)
fsync asíncrono. La función de devolución de llamada no tiene parámetros, pero puede lanzar una excepción.
48fs.fsyncSync(fd)
fsync síncrono.
49fs.write(fd, buffer, offset, length[, position], callback)
Escribir el contenido del búfer en el archivo especificado por el descriptor de archivo.
50fs.write(fd, data[, position[, encoding]], callback)
Escribir el contenido del archivo mediante el descriptor de archivo fd.
51fs.writeSync(fd, buffer, offset, length[, position])
Versión síncrona de fs.write().
52fs.writeSync(fd, data[, position[, encoding]])
Versión síncrona de fs.write().
53fs.read(fd, buffer, offset, length, position, callback)
Leer el contenido del archivo mediante el descriptor de archivo fd.
54fs.readSync(fd, buffer, offset, length, position)
Versión síncrona de fs.read.
55fs.readFile(filename[, options], callback)
Lee el contenido del archivo de forma asíncrona.
56fs.readFileSync(filename[, options])
57fs.writeFile(filename, data[, options], callback)
Escribe el contenido del archivo de forma asíncrona.
58fs.writeFileSync(filename, data[, options])
Versión síncrona de fs.writeFile.
59fs.appendFile(filename, data[, options], callback)
Añade contenido al archivo de forma asíncrona.
60fs.appendFileSync(filename, data[, options])
La versión síncrona de fs.appendFile.
61fs.watchFile(filename[, options], listener)
Ver los cambios del archivo.
62fs.unwatchFile(filename[, listener])
Dejar de observar los cambios de filename.
63fs.watch(filename[, options][, listener])
Observar los cambios de filename; filename puede ser un archivo o un directorio. Devuelve un objeto fs.FSWatcher.
64fs.exists(path, callback)
Comprueba si la ruta especificada existe.
65fs.existsSync(path)
Versión síncrona de fs.exists.
66fs.access(path[, mode], callback)
Prueba los permisos de usuario de la ruta especificada.
67fs.accessSync(path[, mode])
Versión síncrona de fs.access.
68fs.createReadStream(path[, options])
Devuelve un objeto ReadStream.
69fs.createWriteStream(path[, options])
Devuelve un objeto WriteStream.
70fs.symlink(srcpath, dstpath[, type], callback)
symlink() asíncrono. La función de callback no tiene parámetros, pero puede lanzar una excepción.

Para más contenido, consulta la descripción del módulo de archivos en el sitio oficial:File System。

Otras extensiones