Nó js cria arquivo. Nodejs. Gravação e leitura de arquivos. Instalei o Node, e agora?

A transição do código síncrono para o assíncrono foi considerada. Na segunda parte, examinarei a transição da leitura byte por byte para a leitura linha por linha de um arquivo. Como a operação de codificação de uma codificação para outra é bastante trivial, falarei um pouco mais sobre o lado teórico da questão.

Parte 2: Como ler uma linha de um arquivo

Fs.readFile("large.txt", ( codificação: "utf8"), (err, data) => ( if (err) throw err; data.split("\n").forEach(line => ( doSomethingWithLine (linha); )); ));

Ele é talvez o mais rápido. Mas também requer mais memória – de 100% a 200% do tamanho do arquivo. 200% é ao mesmo tempo o caso mais comum, pois a codificação de memória da string é UTF-16 e, portanto, o tamanho da memória necessária é multiplicado por dois se o arquivo contiver principalmente caracteres do intervalo UTF-8 de byte único .

Além disso, os desenvolvedores do Node.js não recomendam carregar muitos dados em um processo do Node.js (consulte Qual é o limite de memória em um processo de nó?). Isso não é feito de maneira muito elegante - mesmo que haja memória física suficiente, quando você tenta baixar um arquivo maior que 1 Gb, uma exceção é lançada:

This.parent = new SlowBuffer(this.length); ^ RangeError: comprimento > kMaxLength

Se o arquivo for menor, você poderá obter algo assim:

ERRO FATAL: Falha na alocação de CALL_AND_RETRY_0 - processo sem memória

Resta apenas processar o arquivo em partes. Para fazer isso, você precisa lê-lo por partes e o Node.js fornece pelo menos 5 maneiras para isso:

1. Use streams “antigos” - abra um stream e inscreva-se no evento “dados”.
2. Use fluxos "novos" - inscreva-se no evento "legível" e use o método read().
3. Crie seu próprio WritableStream e envie um fluxo de arquivo para ele usando o método “pipe()”.
4. Use descritores de arquivo e um conjunto de métodos open(), read(), close().
5. Use opções síncronas - openSync(), readSync(), closeSync().

As opções 1 a 3 são mais elegantes, pois operam com uma abstração conveniente - um fluxo. Isso permite considerar um programa como um diagrama de fluxo de dados e usar termos como fusão, divisão e transformação ao projetar uma arquitetura.

Além disso, as opções 1 e 2 diferem na capacidade de ler caracteres de um arquivo. Nas opções 3 e 4, os dados do arquivo são gravados em um buffer e depois devem ser convertidos em texto.

// Opção #1 - streams "antigos" var stream = fs.createReadStream(file, ( encoding: "utf8" )); stream.on("dados", (_, dados) => processData(dados)); stream.on("fim", concluído); // Opção #2 - "novos" streams var stream = fs.createReadStream(file, ( encoding: "utf8" )); stream.on("legível", () => processData(stream.read())); stream.on("fim", concluído); // Opção nº 3 - pipe var stream = fs.createReadStream(file, (encoding: "utf8" )); var writeStream = new gravável(); writeStream._write = (pedaço, codificação, retorno de chamada) => ( processData(pedaço); callback(); ); writeStream.on("fim", concluído); stream.pipe(writeStream); // Opção #4 - métodos fs assíncronos fs.open(file, "r", (err, fd) => ( var buffer = new Buffer(1000*1000); (function next() ( fs.read(fd, buffer, 0, buffer.length, null, (err, bytesRead, buffer) => ( if (bytesRead === 0) ( fs.close(fd, pronto); ) else ( processData(buffer); next(); ) )); )()); ));

A diferença mais conceitual está em termos de recuperação de dados de um arquivo. As opções 1 a 2 recebem o próximo fragmento assim que o manipulador de eventos do fragmento atual for concluído. No caso de código assíncrono no manipulador, a sequência de sua execução é imprevisível:

Função processData(chunk) ( console.log("primeiro") setImmediate(() => ( console.log("segundo"); setImmediate(() => console.log("terceiro")); )); ) var stream = fs.createReadStream(arquivo, (codificação: "utf8" )); stream.on("legível", () => processData(stream.read())); ... primeiro terceiro segundo terceiro primeiro segundo ...

A situação pode ser corrigida usando os métodos pause()/resume().

Função processData(chunk, pronto) ( console.log("primeiro") setImmediate(() => ( console.log("segundo"); setImmediate(() => ( console.log("terceiro"); feito( ); )); )); ) var stream = fs.createReadStream(file, ( codificação: "utf8" )); stream.on("legível", () => ( stream.pause(); processData(stream.read(), () => stream.resume()); )); ... primeiro segundo terceiro primeiro segundo terceiro ...

Nas opções 3 e 4, o próximo fragmento será recebido somente após transferência de controle (opção 3) ou solicitação (opção 4).

Acho que há informações suficientes para implementar a função createTextReader() da primeira parte do artigo. De todas as opções, a quarta é a mais adequada, pois seu fluxo de controle é semelhante ao da interface (request-callback).

Função createTextReader (arquivo, opções, concluído) ( var comprimento, codificação, separador; if ("função" === tipo de opções) ( concluído = opções; opções = ( ); ) comprimento = 4 * 1024; codificação = opções.encoding || "utf8"; separator = (options.separator || "\n"); fs.open(file, "r", (err, fd) => ( var eof, tail, buffer, decoder, lines; if (err) (feito(err); return; ) eof = false; buffer = new Buffer(comprimento); tail = ""; linhas = ; decodificador = new StringDecoder(codificação); feito(null, ( readLine: pronto => (var linha; if (linhas.comprimento > 0) (linha = linhas.shift(); feito(nulo, linha); ) else if (eof) (feito(nulo, nulo); ) else ( (função leitura() ( fs.read(fd, buffer, 0, length, null, function (err, bytesRead, buffer) ( var index, position; if (bytesRead === 0) ( eof = true; done(null, tail); ) else ( tail = tail + decoder.write(buffer.slice(0, bytesRead)); index = -1; while (-1 !== (position = tail.indexOf(separator, index))) ( lines.push( tail.substring(índice, posição));índice = posição + separador.comprimento; ) cauda = cauda.substring(índice); if (lines.length === 0) ( read(); ) else ( line = lines.shift(); done(null, line); ) ) )); )()); ) ), fechar: feito => ( fs.close(fd, () => ( if (feito) ( feito(err || nulo); ) )); ) )); )); )

Posfácio

Em duas partes deste artigo, tentei delinear tudo o que foi útil para mim ao criar o módulo https://github.com/AlexAtNet/async-read-lines. Infelizmente, muita coisa ficou fora do escopo e não houve tempo para tudo. Portanto, se você encontrar algum erro ou digitação, escreva em mensagens privadas. Se você tiver dúvidas sobre o tema do artigo, terei prazer em responder nos comentários. Se você encontrar bugs no módulo, crie uma solicitação nos problemas do github. Você pode entrar em contato comigo pessoalmente através do site alexatnet.com.

Boa sorte na programação!

Sobre o autor: Alexander Netkachev é desenvolvedor sênior em C# e F#. Mantém o site alexatnet.com, realiza webinars (Code&Coffe), ajuda desenvolvedores novatos com código (CodeReview4U).

Se você deseja criar um servidor web em Node.js ou apenas algum tipo de aplicativo, você precisa ser capaz de ler arquivos.

Node fornece uma biblioteca para trabalhar com o sistema de arquivos. Por exemplo, para ler arquivos.

Leitura assíncrona de arquivo (sem bloqueio)

A maneira “normal” de ler arquivos em Node.js é lê-los de maneira assíncrona. Isso significa que você chama o comando para ler o arquivo e passa um retorno de chamada que será chamado quando a leitura for concluída. Isso permite trabalhar com várias solicitações de leitura em paralelo.

Para isso podemos usar o método readFile da classe fs.

exemplos/node/non-blocking-read-file.js

Var fs = requer("fs"); fs.readFile("DADOS", "utf8", função(err, conteúdo) ( console.log(conteúdo); )); console.log("após chamar readFile");

Primeiro, carregamos a classe fs usando o comando require. Em seguida chamamos o método readFile, que recebe 3 parâmetros: o nome do arquivo (“DATA” no nosso caso), a codificação do arquivo (“utf8” no exemplo) e a função. Esta função será chamada quando a operação de leitura do arquivo for concluída. A função receberá dois parâmetros. A primeira são informações sobre quaisquer erros, a segunda é o conteúdo do arquivo.

Assim que o programa for iniciado, o Node começará a ler o arquivo em segundo plano, mas continuará a execução. Então a ligação será feita primeiro console.log("após chamar readFile");, que enviará este texto para o console. Então, quando o conteúdo do arquivo for carregado na memória, o Node chamará a função que passamos no método readFile e imprimirá o conteúdo do arquivo no console.

Leitura síncrona de arquivo (bloqueio)

Pessoas que vêm de outras linguagens de programação (a maioria) consideram a leitura síncrona de arquivos mais óbvia. Não sei em que situação você gostaria de usar operações síncronas no Node.js, mas vejo que muitas funções assíncronas possuem uma opção síncrona, provavelmente alguém a utiliza.

Para ler arquivos você pode usar o método readFileSync da classe fs:

exemplos/node/blocking-read-file.js

Var fs = requer("fs"); var conteúdo = fs.readFileSync("DADOS", "utf8"); console.log(conteúdo);

As operações de arquivo não são novidade no JavaScript - o JScript, integrado ao Windows, possui um conjunto completo de funções para trabalhar com disco. O Node, devido à sua natureza assíncrona, complica um pouco essas tarefas geralmente triviais.

Gostaria de avisá-lo imediatamente sobre um possível erro. Se você, como eu, executa o Node em uma máquina virtual a partir de uma pasta compartilhada, lembre-se de que a VM não pode gravar nesta pasta. As tentativas de criar ou adicionar arquivos nele resultarão apenas em Erro: Permissão negada

Abrindo um arquivo

Acessar arquivos no disco é uma operação lenta. Em média, é dezenas de milhares de vezes mais demorado do que acessar a RAM. Portanto, a maioria das operações de arquivo são assíncronas. Todas as operações com o sistema de arquivos são coletadas em um módulo integrado fs, então vamos começar conectando-o.

Var fs = require("fs"), sys = require("sys");

Módulo sistema precisamos dele para enviar informações para o console. Nos exemplos subsequentes omitirei estas linhas para não me repetir.

A abertura de um arquivo é feita assim:

Fs.aberto( <путь> , <флаги> , <режим доступа> , <функция-обработчик> )

• Caminho para o arquivo. Relativo ao script em execução ou absoluto.
• Bandeira— modo de acesso a arquivos. Pode assumir os seguintes valores:
  • r - somente leitura, ponteiro no início do arquivo
  • r+ - leitura e gravação, ponteiro no início do arquivo
  • w - somente registro, ponteiro no início do arquivo
  • w+ - escrita e leitura, ponteiro no início do arquivo
  • a - registro, ponteiro no final do arquivo
  • a+ - escrita e leitura, ponteiro no final do arquivo
• Modo de acesso usado se o arquivo que está sendo aberto não existir. Neste caso, será criado um novo arquivo vazio com o modo especificado. A notação é padrão para UNIX - por exemplo 0664
• Manipulador— uma função que será executada ao abrir/criar um arquivo. Um sinalizador de erro e um descritor de arquivo são passados ​​como argumentos.

Por exemplo:

Fs.open("readme.txt", "r+", 0644, function(err, file_handle) ( if (!err) ( // operações de abertura de arquivo ) else ( // tratamento de erros ) ));

Escreva no arquivo

Para gravar em um arquivo, use o método fs.write:

Fs.write( <дескриптор> , <данные> , <позиция> , <кодировка> , <обработчик> )

• Descritor arquivo recebido em fs.open .
• Dados que anotamos. Os objetos aqui serão convertidos para o tipo string.
• Posição, a partir do qual a gravação começa. Nulo significa escrever a partir da posição atual.
• Codificação, no qual os dados serão registrados. Talvez " ascii«, « utf8" E " cru«
• Manipulador— uma função que será executada após a gravação. Argumentos - sinalizador de erro e número de bytes gravados

Vamos expandir o exemplo anterior escrevendo uma string :)

Fs.open("readme.txt", "a", 0644, function(err, file_handle) ( if (!err) ( // Escreva a frase "Copyrighted by Me" // no final do arquivo readme.txt ao abrir no modo O ponteiro "a" já está no final do arquivo, e passamos null // como posição fs.write(file_handle, "Copyrighted by Me", null, "ascii", function(err, Writing) ( if (!err) ( // Tudo correu bem ) else ( // Ocorreu um erro ao escrever ) )); ) else ( // Tratamento de erros ao abrir ) ));

Lendo de um arquivo

A leitura é feita assim:

Fs.ler( <дескриптор> , <длина> , <позиция> , <кодировка> , <обработчик> )

Tudo aqui é quase igual ao fs.write .

• Descritor arquivo recebido em fs.open
• Comprimento dados que planejamos ler
• Posição, com o qual começamos a ler. Nulo - da posição atual
• Codificação, no qual os dados são lidos. Talvez " ascii«, « utf8" E " cru". É melhor não cometer erros aqui)
• Manipulador- uma função que será executada após a leitura. Argumentos - sinalizador de erro, dados, número de bytes lidos

A leitura de um arquivo é um processo muito simples:

Fs.open("readme.txt", "r", 0644, function(err, file_handle) ( if (!err) ( // Lê 10 kilobytes desde o início do arquivo, em ascii fs.read(file_handle, 10000 , null, "ascii", function(err, data) ( if (!err) ( // Tudo correu bem, imprima o que lemos no console sys.puts(data); ) else ( // Ocorreu um erro durante a leitura ) )); ) else ( // Tratamento de erros ao abrir um arquivo ) ));

Após a conclusão da leitura/gravação, o arquivo deve ser fechado. O Node pode atender muitos clientes ao mesmo tempo, por isso é melhor liberar recursos imediatamente quando eles não forem mais necessários.

Fs.open("readme.txt", "r", 0644, function(err, file_handle) ( if (!err) ( // Lê 10 kilobytes desde o início do arquivo, em ascii fs.read(file_handle, 10000 , null, "ascii", function(err, data) ( if (!err) ( // Tudo correu bem, imprima o que lemos no console sys.puts(data); fs.close(file_handle); ) else ( // Ocorreu um erro durante a leitura ) )); ) else ( // Tratamento de erros ao abrir um arquivo ) ));

O segundo argumento de fs.close pode receber uma função de retorno de chamada, para a qual uma exceção é passada em caso de erro.

Todas as funções listadas possuem opções síncronas. Sync é adicionado ao seu nome e eles não usam uma função de manipulador como último argumento, mas simplesmente retornam o valor correspondente (ou lançam uma exceção). Observe que readSync retorna uma matriz de dados e o número de bytes lidos.

Var file_handle = fs.openSync("readme.txt", "r", 0644); var dados = fs.readSync(file_handle, 10000, null, "ascii"); sys.puts(dados); fs.closeSync(file_handle);

Não faltam tutoriais de Node.js por aí hoje em dia, mas a maioria deles cobre casos de uso específicos ou tópicos que se aplicam quando você tem o Node.js em execução. Aqui e ali vejo comentários como "Eu baixei o Node.js, o que agora? Este artigo responderá a esta pergunta e explicará como começar desde o início.

O que é Node.js?

Muita confusão para quem é novo no Node.js vem de não entender o que ele realmente é. E a descrição em nodejs.org não ajuda muito a entendê-lo.

É importante entender que o Node não é um servidor web. Por si só não faz nada. Este não é o Apache. Não há nenhum arquivo de configuração que especifique o caminho para os arquivos HTML. Se precisar de um servidor HTTP, você precisará escrever um servidor HTTP (usando bibliotecas integradas). Node.js é apenas outra maneira de executar código em seu computador. É simplesmente um ambiente para executar JavaScript.

Instalação de nó

Instalar o Node.js é muito fácil. Se você estiver usando Windows ou Mac, os arquivos de instalação estão disponíveis na página de download.

Instalei o Node, e agora?

Imediatamente após a instalação, o comando new node fica disponível para você. Pode ser usado de duas maneiras diferentes. A primeira maneira é sem argumentos. Isso abrirá um shell interativo (REPL: read-eval-print-loop) onde você pode executar código JavaScript normal.

$ node > console .log("Olá Mundo"); Olá mundo indefinido

No exemplo acima, escrevi console.log("Hello World") no shell e pressionei Enter. Node.js executará este código e veremos uma mensagem. undefined é impresso depois porque o shell exibe o valor de retorno de cada comando e console.log não retorna nada.

Além disso, podemos passar um arquivo JavaScript ao Node para execução. Isso é o que você quase sempre fará.

olá.js

console .log("Olá Mundo");

Agora vamos executá-lo no terminal:

$node hello.js Olá mundo

Neste exemplo, movi console.log para um arquivo, que passei para o comando node como argumento. O Node então executa JavaScript a partir deste arquivo e gera Hello World.

Fazendo algo útil – trabalhando com arquivos

Apenas executar código JavaScript é divertido e tudo, mas não é muito útil. É por isso que o Node.js também inclui um poderoso conjunto de bibliotecas (módulos) para tarefas sérias. Neste primeiro exemplo, vou abrir um arquivo de log e processá-lo.

exemplo_log.txt

2013-08-09T13 :50 :33.166Z A 2 2013-08-09T13 :51 :33.166Z B 1 2013-08-09T13 :52 :33.166Z C 6 2013-08-09T13 :53 :33.166Z B 8 201 3-08-09T13 : 54:33.166ZB5

Não importa o significado dos dados nos logs, mas essencialmente cada mensagem contém uma data, uma letra e um valor. Digamos que eu queira somar os valores de cada letra.

meu_parser.js

var fs = require("fs"); função (errar, logData){ //Se ocorrer um erro, lançamos uma exceção // e a aplicação termina se (errar) lançar errar; //logData é do tipo Buffer, converta-o para string var texto = logData.toString(); ));

Trabalhar com arquivos em Node.js é muito fácil graças ao módulo integrado do sistema de arquivos fs. Este módulo contém a função readFile, que usa um caminho de arquivo e um retorno de chamada como argumentos. O retorno de chamada será chamado quando o arquivo terminar de ser lido. Os dados do arquivo vêm na forma de um objeto Buffer, que é essencialmente uma matriz de bytes. Podemos convertê-lo em uma string usando a função toString().

Agora vamos começar a processar os logs. Este é um código JavaScript bastante básico, então não entrarei em detalhes.

meu_parser.js

var fs = require("fs"); //Lê o conteúdo do arquivo na memória fs.readFile("exemplo_log.txt", função (errar, logData){ //Se ocorrer um erro, lançamos uma exceção, // e o aplicativo será encerrado. se (errar) lançar errar; //logData é do tipo Buffer, converta-o em uma string var texto = logData.toString(); var resultados=(); //Dividindo o arquivo linha por linha var linhas = text.split("\n" ); linhas.forEach( função (linha)(var partes = line.split(" "); var letra = partes; var contagem = parseInt (partes); if (!resultados) ( resultados = 0 ; ) resultados += parseInt (contagem); )); console .log(resultados); // ( A: 2, B: 14, C: 6 ) ));

Agora, quando você passar este arquivo para o nó como argumento, ele imprimirá o resultado e sairá.

$node meu_parser.js (A: 2, B: 14, C: 6)

Costumo usar o Node.js para tarefas como esta. É uma alternativa simples e poderosa aos scripts bash.

Retornos de chamada assíncronos

Como você pode ver no exemplo anterior, um padrão típico em Node.js é usar retornos de chamada assíncronos. Essencialmente, você diz para ele fazer algo e, quando estiver pronto, chama sua função (retorno de chamada). Isso ocorre porque o Node.js é de thread único. Enquanto você espera a chamada do retorno de chamada, o Node.js pode se distrair e fazer outras coisas em vez de bloquear o thread enquanto aguarda a conclusão do processamento da solicitação.

Isto é especialmente importante para servidores web. Acessar bancos de dados em aplicações web modernas é comum. Enquanto você aguarda uma resposta do banco de dados, o Node.js pode processar mais solicitações. Isso permite lidar com milhares de conexões simultâneas com muito pouca sobrecarga, comparável à criação de um thread separado para cada conexão.

Fazendo algo útil - servidor HTTP

Como eu disse anteriormente, o Node.js não faz nada pronto para uso. Um dos módulos integrados permite criar facilmente um servidor HTTP simples, conforme mostrado no exemplo do site Node.js.

meu_web_server.js

var http = requer("http"); http.createServer( função (req, res)( res.writeHead(200, ("Content-Type" : "text/plain" )); res.end("Olá Mundo\n" ); )).listen(8080); console.log( "Servidor rodando na porta 8080.");

Quando digo simples, significa simples. Este não é um servidor HTTP sofisticado. Não funciona com HTML ou imagens. Na verdade, tudo o que você pedir, ele retornará Hello World. Porém, você pode executá-lo, acesse http://localhost:8080 no seu navegador e veja este texto.

$node meu_web_server.js

Você pode notar uma pequena diferença: seu aplicativo não fecha. Isso acontece porque você criou o servidor e agora ele continuará funcionando e respondendo às solicitações até que você mesmo elimine o nó.

Se quiser transformar este aplicativo em um servidor web completo, você terá que trabalhar muito. Você precisará verificar o que é solicitado, ler os arquivos correspondentes e devolver o conteúdo. No entanto, a boa notícia é que outros já fizeram esse trabalho árduo por você.

Última atualização: 23/05/2019

O módulo foi projetado para trabalhar com arquivos em Node.js. Vejamos como trabalhar com isso.

Lendo de um arquivo

Digamos que na mesma pasta do arquivo da aplicação app.js exista um arquivo de texto hello.txt com texto simples, por exemplo:

Olá, Node JS!

Para ler um arquivo de forma síncrona, use a função fs.readFileSync():

Deixe fileContent = fs.readFileSync("hello.txt", "utf8");

O método recebe o caminho do arquivo relativo ao arquivo do aplicativo app.js e a codificação para receber o conteúdo de texto do arquivo é especificada como o segundo parâmetro. Na saída obtemos o texto lido.

Para ler um arquivo de forma assíncrona, use a função fs.readFile:

Fs.readFile("olá.txt", "utf8", função(erro,dados)( ));

O primeiro e o segundo parâmetros da função são novamente o caminho para o arquivo e a codificação, respectivamente. E como terceiro parâmetro, é passada uma função de callback, que é executada após a conclusão da leitura. O primeiro parâmetro desta função armazena informações sobre o erro, se houver, e o segundo - os dados reais lidos.

Para ler o arquivo, defina o seguinte código no arquivo app.js:

Const fs = requer("fs"); // leitura assíncrona fs.readFile("hello.txt", "utf8", function(error,data)( console.log("Leitura assíncrona de arquivo"); if(error) throw error; // se ocorrer um erro console .log(data); // exibe os dados lidos )); // leitura síncrona console.log("Leitura síncrona de arquivo") let fileContent = fs.readFileSync("hello.txt", "utf8"); console.log(fileContent);

E aqui é importante notar que apesar da função fs.readFile() ser chamada primeiro, por ser assíncrona, ela não bloqueia o thread de execução, então seu resultado é impresso bem no final.

Escreva um arquivo

Para escrever um arquivo de forma síncrona, use a função fs.writeFileSync(), que leva como parâmetro o caminho para o arquivo e os dados a serem escritos:

Fs.writeFileSync("olá.txt", "Olá mi mi mi!")

Você também pode usar a função assíncrona fs.writeFile() para escrever um arquivo, que usa os mesmos parâmetros:

Fs.writeFile("olá.txt", "Olá MIG-29!")

Como parâmetro auxiliar, uma função de retorno de chamada pode ser passada para a função, que é executada após a conclusão da gravação:

Const fs = requer("fs"); fs.writeFile("hello.txt", "Hello world!", function(error)( if(error) throw error; // se ocorrer um erro console.log("Escrita assíncrona do arquivo concluída. Conteúdo do arquivo:"); let data = fs.readFileSync("hello.txt", "utf8"); console.log(data); // exibe os dados lidos ));

Deve-se observar que esses métodos substituem completamente o arquivo. Se você precisar adicionar um arquivo, os métodos serão usados fs.appendFile()/fs.appendFileSync():

Const fs = requer("fs"); fs.appendFileSync("hello.txt", "Olá mi mi mi!"); fs.appendFile("hello.txt", "Hello MFA!", function(error)( if(error) throw error; // se ocorrer um erro console.log("Gravação do arquivo concluída. Conteúdo do arquivo:"); let data = fs.readFileSync("hello.txt", "utf8"); console.log(data); // exibe os dados lidos ));

Excluindo um arquivo

Para excluir um arquivo na versão síncrona, utilize a função fs.unlinkSync(), que leva como parâmetro o caminho do arquivo a ser excluído:

Fs.unlinkSync("olá.txt")

Você também pode usar a função assíncrona fs.unlink() para excluir um arquivo, que leva o caminho para o arquivo e uma função chamada quando a exclusão é concluída:

Fs.unlink("hello.txt", (err) => ( if (err) console.log(err); // se ocorreu um erro else console.log("hello.txt foi excluído"); ));