40.modulo_fs_do_node.md

O módulo fs do Node.js

O módulo fs fornece muitas funcionalidades úteis para acessare interagir com o sistema de arquivos.

Não há necessidade de instalá-lo. Sendo parte do núcleo do Node.js, ele pode ser usado simplesmente requerindo-o:

const fs = require('fs');

Uma vez fazendo isso, você tem acesso a todos os seus métodos, que incluem:

• fs.access(): verifica se o arquivo existe e o Node.js pode acessá-lo com suas permissões.
• fs.appendFile(): anexa dados a uma rquivo. Se o arquivo não existir, ele será criado.
• fs.chmod(): altera as permissões de um arquivo especificado pelo nome. Relacionado: fs.lchmod(), fs.fchmod().
• fs.chown(): altera o dono e o grupo de um arquivo especificado pelo nome. Relacionado: fs.fchown(), fs.lcown().
• fs.close(): fecha um descritor/manipulador de arquivo.
• fs.copyFile(): copia um arquivo.
• fs.createWriteStream(): cria um fluxo de arquivo gravável.
• fs.link():cria um novo link físico para um arquivo.
• fs.mkdir(): cria uma nova pasta.
• fs.mkdtemp(): cria um diretório temporário.
• fs.open(): abre o arquivo e retorna um descritor/manipulador de arquivo para que possamos manipulá-lo.
• fs.readdir(): lê o conteúdo de um diretório.
• fs.readFile(): lê o conteúdo de um arquivo.
• fs.readlink(): lê o valor de um link simbólico.
• fs.realpath(): resolve ponteiros de caminho de arquivo relativo (., ..) para o caminho completo.
• fs.rename(): para renomear um arquivo ou pasta.
• fs.rmdir(): remove uma pasta.
• fs.stat(): retorna o status do arquivo identificado pelo nome passado. Relacionado: fs.fstat(), fs.lstat().
• fs.symlink(): cria um novo link simbólico para um arquivo.
• fs.truncate(): para truncar o tamanho de um arquivo identificado pelo nome passado. Relacionado: fs.ftruncate().
• fs.unlink(): remove um arquivo ou um link simbólico.
• fs.utimes(): altera o timestamp de um arquivo. Relacionado com: fs.futimes().
• fs.watchFile(): comece a observar as alterações em um arquivo. Relacionado: fs.watch().
• fs.writeFile(): grava dados em um arquivo. Relacionado: fs.write().

Uma coisa peculiar sobre o módulo fs é que todos os métodos são assíncronos por padrão, mas também podem funcionar de forma síncrona anexando Sync.

Por exemplo:

• fs.rename()
• fs.renameSync()
• fs.write()
• fs.writeSync

Isso faz uma enorme diferença no fluxo do seu aplicativo.

O Node.js 10 inclui suporte experimental para uma API baseada em promise.

Por exemplo, vamos examinar o método fs.rename(). A API assíncrona é usada com um callback:

const fs = require('fs');

fs.rename('before.json', 'after.json', err => {
  if (err) {
    return console.error(err);
  }

  // feito
});

Uma API síncrona pode ser usada assim, com um bloco try,/catchpara lidar com erros:

const fs = require('fs');

try {
  fs.renameSync('before.json', 'after.json');
  // feito
} catch (err) {
  console.error(err);
}

A principal diferença aqui é que a execução do seu script será bloqueada no segundo exemplo, até que a operação do arquivo seja bem-sucedida.

Você pode usar a API baseada em promise fornecida pelo módulo fs/promises para evitar o uso da API baseada em callback, o que pode causar callback hell. Aqui um exemplo:

// Examplo: Leia o arquivo e mude seu conteúdo e 
// leia novamente usando API baseada em callback.
const fs = require('fs');

const fileName = '/Users/joe/test.txt';
fs.readFile(fileName, 'utf8', (err, data) => {
  if (err) {
    console.log(err);
    return;
  }
  console.log(data);
  const content = 'Some content!';
  fs.writeFile(fileName, content, err2 => {
    if (err2) {
      console.log(err2);
      return;
    }
    console.log('Wrote some content!');
    fs.readFile(fileName, 'utf8', (err3, data3) => {
      if (err3) {
        console.log(err3);
        return;
      }
      console.log(data3);
    });
  });
});