O Node fornece diferentes opções para gravar em arquivos em seu sistema por meio do built-in fs módulo. Esses incluem escreverArquivo(), appendFile(), e criarWriteStream().

Como muitos idiomas, o Node.js permite que você escolha entre sobrescrever um arquivo existente ou anexá-lo. Você também deve aprender sobre as compensações entre escrever um arquivo de uma só vez e transmiti-lo.

Usando writeFile()

escreverArquivo() talvez seja o método mais fácil que você pode usar para escrever um arquivo no Node.

fs.writeFile (nome do arquivo, dados, retorno de chamada)

Aqui está um exemplo mostrando como criar um arquivo de texto simples usando writeFile(). Claro que você pode criar outros tipos de arquivo, como CSV ou JSON.

const fs = exigir("fs")
fs.writeFile("test.txt", "Novo conteúdo", err => {
E se (erro) {
console.log (erro)
 }
});

writeFile() suporta async/await do em vez de usar callbacks como no exemplo acima, você pode criar o arquivo da seguinte forma.

const fs = exigir("fs").promete
assíncronofunçãowriteToFile() 





instagram viewer

{
tentar {
aguardam fs.writeFile("teste.txt", "Novo conteúdo")
 } truque (erro) {
console.log (erro);
 }
}
writeToFile()

Por padrão, writeFile() funciona substituindo o conteúdo do arquivo especificado por um novo conteúdo se o arquivo existir. No entanto, existem sinalizadores que você pode usar para substituir essa funcionalidade, como:

  • r+ - abre o arquivo para ler e escrever.
  • w+ - abre o arquivo para ler e escrever no início do arquivo
  • uma - abre o arquivo para escrever no final do arquivo.
  • a+ - abre o arquivo para ler e escrever no final do arquivo.

Por exemplo, você pode usar o sinalizador a+ assim:

const fs = exigir("fs")
fs.writeFile("test.txt", "Conteúdo mais recente", { bandeira: "a+" }, erro => {
E se (erro) {
console.log (erro)
 }
});

Existem muitos outros sinalizadores de sistema de arquivos sobre os quais você pode aprender no Documentação do nó para o módulo fs.

o fs módulo também oferece writeFileSync, a versão síncrona de escreverArquivo().

const fs = exigir("fs")
fs.writeFileSync("test.txt", "Conteúdo mais recente", { bandeira: "a+" }, erro => {
E se (erro) {
console.log (erro)
 }
});

Usando createWriteStream()

A desvantagem de usar escreverArquivo() é que você precisa armazenar todo o conteúdo do arquivo de uma só vez, o que não é escalável para arquivos grandes. criarWriteStream() no entanto, suporta escrita sequencial. Isso significa que você pode gravar um bloco de dados em um arquivo por vez. Aqui está o sistema geral para criar um fluxo gravável.

fs.createWriteStream (caminho, opções)

O código abaixo grava dados em um arquivo de texto usando fluxos

const fs = exigir("fs")
// cria um fluxo gravável
deixar writeableStream = fs.createWriteStream("test.txt") 
// Grava no arquivo usando o fluxo gravável
writeableStream.write("Novo conteúdo");

Aqui está outro exemplo mostrando como você pode canalizar dados para o fluxo gravável. Este programa grava todas as entradas do terminal no arquivo test.txt enquanto o terminal estiver aberto.

const fs = exigir("fs")
deixar writableStream = fs.createWriteStream("test.txt"); 
process.stdin.pipe (writableStream);

Se você executar este programa a partir da linha de comando, poderá fechá-lo com Ctrl + d ou Ctrl + c.

Você também pode gravar de outro arquivo no fluxo gravável. Considere o seguinte exemplo:

const fs = exigir("fs")
deixar readableStream = fs.createReadStream("test.txt");
deixar writableStream = fs.createWriteStream("test2.txt");
readableStream.on("dados", função(pedaço) {
 writableStream.write (pedaço);
});

A criação de um fluxo legível do arquivo que você deseja copiar permite que você leia seu conteúdo em partes. Assim, para cada pedaço recebido, o programa gravará no arquivo de destino.

Usando appendFile()

appendFile() é um método direto de adicionar conteúdo ao final do arquivo. Aqui está um exemplo.

const fs = exigir("fs")
fs.appendFile("test.txt", "conteúdo adicionado", err => {
E se (erro) {
console.erro (erro);
 }
});

Você também pode usar async/await.

const fs = exigir("fs").promete
assíncronofunçãoappendToFile() {
tentar {
aguardam fs.appendFile("test.txt", "conteúdo adicionado")
 } truque (erro) {
console.log (erro);
 }
}
appendToFile()

Curti escreverArquivo(), appendFile também tem uma versão síncrona:

fs.appendFileSync("test.txt", "conteúdo adicionado");

Use fluxos para gravar arquivos grandes

Este artigo discutiu várias abordagens para escrever arquivos no Node. Embora writeFile() seja muito simples, é mais adequado para tamanhos de arquivo pequenos, pois não permite gravações sequenciais. Se você estiver lidando com arquivos grandes, é melhor usar fluxos graváveis.