O módulo fs (File System) em Node.js é uma ferramenta poderosa para trabalhar com o sistema de arquivos, permitindo que você interaja com arquivos e diretórios em seu servidor. Ele está integrado ao Node.js, então você não precisa instalar nada extra para usá-lo. Vamos explorar como o fs funciona e suas principais funções.

1. O que é o Módulo fs?

O módulo fs fornece uma API para interagir com o sistema de arquivos de uma maneira modelada em torno de funções POSIX padrão. Este módulo é usado para tarefas como leitura e gravação em arquivos, criação de diretórios e muito mais.

2. Configuração básica

Para usar o módulo fs, você precisa solicitá-lo no início do seu script Node.js:

const fs = require('fs');

3. Lendo arquivos

Existem duas maneiras principais de ler arquivos: de forma assíncrona e síncrona.

Leitura Assíncrona

Este método não bloqueia, o que significa que não interromperá a execução do seu programa enquanto lê o arquivo.

fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log(data);
});

• 'example.txt': O arquivo que você deseja ler.
• 'utf8': Especifica a codificação a ser usada.
• Função de retorno de chamada: trata o erro e os dados do arquivo.

Leitura Síncrona

Este método é bloqueador, o que significa que interromperá a execução do seu programa até que o arquivo seja lido.

try {
    const data = fs.readFileSync('example.txt', 'utf8');
    console.log(data);
} catch (err) {
    console.error(err);
}

4. Gravando arquivos

Semelhante à leitura de arquivos, a gravação também pode ser feita de forma assíncrona ou síncrona.

Escrita Assíncrona

fs.writeFile('example.txt', 'Hello, World!', (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('File has been saved!');
});

Escrita Síncrona

try {
    fs.writeFileSync('example.txt', 'Hello, World!');
    console.log('File has been saved!');
} catch (err) {
    console.error(err);
}

5. Anexando aos arquivos

Se você deseja adicionar conteúdo a um arquivo existente sem substituí-lo, use o método appendFile.

Anexação assíncrona

fs.appendFile('example.txt', '\nAppended Content', (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('Content has been appended!');
});

Anexação Síncrona

try {
    fs.appendFileSync('example.txt', '\nAppended Content');
    console.log('Content has been appended!');
} catch (err) {
    console.error(err);
}

6. Excluindo arquivos

Para excluir um arquivo, use o método de desvinculação.

Exclusão assíncrona

fs.unlink('example.txt', (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('File deleted!');
});

Exclusão síncrona

try {
    fs.unlinkSync('example.txt');
    console.log('File deleted!');
} catch (err) {
    console.error(err);
}

7. Trabalhando com diretórios

Criando um diretório

fs.mkdir('newDir', { recursive: true }, (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('Directory created!');
});

Lendo um diretório

fs.readdir('newDir', (err, files) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('Files in directory:', files);
});

Excluindo um diretório

fs.rmdir('newDir', { recursive: true }, (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('Directory deleted!');
});

8. Assistindo arquivos

Você pode observar alterações em um arquivo usando o método fs.watch:

fs.watch('example.txt', (eventType, filename) => {
    if (filename) {
        console.log(`${filename} file Changed!`);
    }
});

9. Trabalhando com Streams

Node.js fornece fluxos fs para lidar com arquivos grandes que podem não caber na memória.

Lendo com Streams

const readStream = fs.createReadStream('example.txt', 'utf8');
readStream.on('data', (chunk) => {
    console.log(chunk);
});

Escrevendo com Streams

const writeStream = fs.createWriteStream('example.txt');
writeStream.write('Hello, ');
writeStream.write('World!');
writeStream.end();

10. Copiando arquivos

Node.js fornece um método simples para copiar arquivos:

fs.copyFile('source.txt', 'destination.txt', (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('File copied successfully!');
});

11. Fs prometido

O módulo fs também possui métodos baseados em promessas, facilitando o trabalho com recursos JavaScript modernos, como async/await.

const fsPromises = require('fs').promises;

async function readFile() {
    try {
        const data = await fsPromises.readFile('example.txt', 'utf8');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
}

readFile();

12. Casos de uso prático

• Arquivos de configuração: leia ou grave arquivos de configuração (por exemplo, arquivos JSON) para armazenar configurações.
• Arquivos de log: anexe aos arquivos de log para acompanhar os eventos do aplicativo.
• Uploads de arquivos: armazene e recupere arquivos carregados.
• Processamento de dados: leia, processe e grave grandes conjuntos de dados com eficiência usando fluxos.

13. Tratamento de erros e melhores práticas

• Sempre lide com erros em funções de retorno de chamada ou use blocos try-catch com código síncrono.
• Use métodos assíncronos para obter melhor desempenho na maioria dos casos.
• Considere usar fs.promises para um código mais limpo e moderno.
• Tenha cuidado com métodos síncronos, pois eles podem bloquear o loop de eventos.
• Use fs.constants para sinalizadores do sistema de arquivos (por exemplo, fs.constants.O_RDONLY para acesso somente leitura).

14. Considerações de Segurança

• Valide e limpe caminhos de arquivos para evitar ataques de passagem de diretório.
• Tenha cuidado ao trabalhar com nomes de arquivos ou caminhos fornecidos pelo usuário.
• Use as permissões de arquivo apropriadas ao criar ou modificar arquivos e diretórios.

15. Conclusão

O módulo fs é versátil e essencial para qualquer aplicativo Node.js que precise interagir com o sistema de arquivos. Ao compreender seus vários métodos, manipular fluxos de maneira eficiente e empregar as práticas recomendadas, você estará bem equipado para gerenciar operações de arquivos em Node.js de maneira eficaz e segura.

Lembre-se de consultar a documentação oficial do Node.js para obter as informações mais atualizadas e recursos adicionais do módulo fs.