Arquivos Node js na pasta. Nodejs. Gravação e leitura de arquivos. ▍Lendo o conteúdo de uma pasta

Olá a todos! Neste artigo, veremos como escrever e ler arquivos no NodeJS.

Para fazer isso precisaremos usar o módulo FS (sistema de arquivos). var fs =require(`fs`)-

Para demonstrar a leitura do conteúdo dos arquivos, vamos criar um arquivo chamado readme.txt.

Vídeo: node.js »módulo fs» gravando em arquivo

//conteúdo do arquivo readme.txt
Aqui está algum conteúdo do arquivo

var texto = fs.readFileSync(`readme.txt`,`utf8`)-
console.log(texto)-

Usamos um método no qual passamos o nome do arquivo como primeiro parâmetro e a codificação como segundo. Como o nome sugere, este método é síncrono. Isso significa que todo o código a seguir só será executado quando todo o arquivo for lido. Em seguida, simplesmente escrevemos os dados recebidos em uma variável, que exibimos na tela.

Vídeo: Node.js - criando um arquivo Excel usando um modelo

Agora vamos tentar escrever o conteúdo do arquivo que lemos em um novo arquivo.

Para fazer isso, escreveremos o seguinte:

fs.writeFileSync(`writeme.txt`, texto)-

Agora, após executar o código, você verá que foi criado um novo arquivo chamado writeme.txt, que conterá o conteúdo gravado na variável de texto do arquivo readme.txt.

Vídeo: Noções básicas de Node.JS. 2. Trabalhando com arquivos

Vejamos como usar métodos de forma assíncrona.

Por exemplo, vejamos o arquivo readme.txt:

console.log(dados)-
})-

console.log(`será gerado antes dos dados do arquivo`)-

O uso é quase o mesmo, mas agora também passamos a função como terceiro parâmetro, onde o primeiro argumento é o erro e o segundo é o conteúdo do arquivo, que então geramos.

Abaixo escrevi outra saída de texto para mostrar que o método é realmente assíncrono, portanto enquanto o arquivo estiver sendo lido, o código abaixo será executado, e só então o texto do arquivo será gerado.

Vídeo: Trabalhando com arquivos, módulo fs

Agora vamos ler o conteúdo do arquivo readme.txt novamente e gravá-lo no arquivo writeme.txt, mas desta vez de forma assíncrona.

fs.readFile(`readme.txt`,`utf8`,function(erro, dados)(
fs.writeFile(`writeme.txt`, dados)-
})-

E isso é tudo para mim hoje. Obrigado pela sua atenção!

(Sem avaliações ainda)

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 2 013-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ê.

Olá a todos! Neste artigo veremos, como escrever e ler arquivos em NodeJS.

Plataforma NodeJS permite que você grave e leia arquivos no sistema operacional. Para fazer isso precisaremos usar o módulo FS(sistema de arquivo).

Var fs = requer("fs");

Para demonstrar a leitura do conteúdo dos arquivos, vamos criar um arquivo chamado leia-me.txt.

//conteúdo do arquivo readme.txt
Aqui está algum conteúdo do arquivo

Var text = fs.readFileSync("readme.txt", "utf8");
console.log(texto);

Agora vamos tentar escrever o conteúdo do arquivo que lemos em um novo arquivo. Para fazer isso, escreveremos o seguinte:

Fs.writeFileSync("writeme.txt", texto);

Agora depois de executar o código você verá que um novo arquivo foi criado com o nome escreva-me.txt, que conterá o conteúdo escrito na variável texto De arquivo leia-me.txt.

Vejamos como usar métodos de forma assíncrona. Por exemplo, consideramos o arquivo leia-me.txt:

console.log(dados);
});

Console.log("será gerado antes dos dados do arquivo");

O uso é quase o mesmo, mas agora também passamos a função como terceiro parâmetro, onde o primeiro argumento é o erro e o segundo é o conteúdo do arquivo, que então geramos. Abaixo escrevi outra saída de texto para mostrar que o método é realmente assíncrono, portanto enquanto o arquivo estiver sendo lido, o código abaixo será executado, e só então o texto do arquivo será gerado.

Agora vamos contar o conteúdo do arquivo novamente leia-me.txt e grave-o em um arquivo escreva-me.txt, mas só agora de forma assíncrona.

Fs.readFile("readme.txt", "utf8", function(erro, dados) (
fs.writeFile("writeme.txt", dados);
});

E isso é tudo para mim hoje. Obrigado pela sua atenção!

Hoje, na nona parte da tradução do guia Node.js, falaremos sobre como trabalhar com arquivos. Em particular, falaremos sobre os módulos fs e path - sobre descritores de arquivos, sobre caminhos para arquivos, sobre como obter informações sobre arquivos, sobre como lê-los e gravá-los, sobre como trabalhar com diretórios.

Trabalhando com descritores de arquivos em Node.js

Antes de poder interagir com arquivos residentes no sistema de arquivos do seu servidor, você precisa obter um identificador de arquivo.

O identificador pode ser obtido usando o método assíncrono open() do módulo fs para abrir o arquivo:

Const fs = require("fs") fs.open("/Users/flavio/test.txt", "r", (err, fd) => ( //fd é um descritor de arquivo ))

Observe o segundo parâmetro, r, usado ao chamar o método fs.open(). Este é um sinalizador que informa ao sistema que o arquivo está sendo aberto para leitura. Aqui estão alguns outros sinalizadores que são frequentemente usados ao trabalhar com este e alguns outros métodos:

r+ - abre um arquivo para leitura e gravação.
w+ - abre um arquivo para leitura e gravação, configurando o ponteiro do stream para o início do arquivo. Se o arquivo não existir, ele será criado.
a - abre um arquivo para gravação, definindo o ponteiro do fluxo para o final do arquivo. Se o arquivo não existir, ele será criado.
a+ - abre um arquivo para leitura e gravação, definindo o ponteiro do stream para o final do arquivo. Se o arquivo não existir, ele será criado.

Os arquivos também podem ser abertos usando o método síncrono fs.openSync(), que, em vez de fornecer um descritor de arquivo no retorno de chamada, o retorna:

Const fs = require("fs") try ( const fd = fs.openSync("/Users/flavio/test.txt", "r") ) catch (err) ( console.error(err) )

Depois de receber o descritor usando qualquer um dos métodos descritos acima, você poderá realizar as operações necessárias com ele.

Dados do arquivo

Cada arquivo está associado a um conjunto de dados sobre ele; você pode explorar esses dados usando Node.js. Em particular, isso pode ser feito usando o método stat() do módulo fs.

Chame este método, passando-lhe o caminho para o arquivo, e após o Node.js ter as informações necessárias sobre o arquivo, ele chamará o retorno de chamada passado para o método stat(). Isto é o que parece:

Const fs = require("fs") fs.stat("/Users/flavio/test.txt", (err, stats) => ( if (err) ( console.error(err) return ) //informações do arquivo contidas no argumento `stats`))

Node.js tem a capacidade de recuperar informações do arquivo de forma síncrona. Com esta abordagem, o thread principal é bloqueado até que as propriedades do arquivo sejam recuperadas:

Const fs = require("fs") try ( const stats = fs.statSync ("/Users/flavio/test.txt") ) catch (err) ( console.error(err) )

As informações sobre o arquivo irão para a constante de estatísticas. Que tipo de informação é essa? Na verdade, o objeto correspondente nos fornece um grande número de propriedades e métodos úteis:

Os métodos .isFile() e .isDirectory() permitem descobrir, respectivamente, se o arquivo que está sendo examinado é um arquivo normal ou um diretório.
O método .isSymbolicLink() permite descobrir se um arquivo é um link simbólico.
O tamanho do arquivo pode ser encontrado usando a propriedade .size.

Existem outros métodos, mas estes são os mais utilizados. Veja como usá-los:

Const fs = require("fs") fs.stat("/Users/flavio/test.txt", (err, stats) => ( if (err) ( console.error(err) return ) stats.isFile() //true stats.isDirectory() //false stats.isSymbolicLink() //false stats.size //1024000 //= 1MB ))

Caminhos de arquivo em Node.js e o módulo de caminho

O caminho para um arquivo é o endereço do local no sistema de arquivos onde ele está localizado.

No Linux e no macOS, o caminho pode ser assim:

/users/flavio/file.txt

No Windows, os caminhos parecem um pouco diferentes:

C: usuáriosflaviofile.txt

As diferenças nos formatos de gravação de caminho ao usar diferentes sistemas operacionais devem ser levadas em consideração, levando em consideração o sistema operacional usado para implantar o servidor Node.js.

Node.js possui um módulo de caminho padrão projetado para funcionar com caminhos de arquivos. Antes de utilizar este módulo no programa, ele deve estar conectado:

▍Obter informações sobre o caminho para um arquivo

Se você tiver um caminho para um arquivo, usando os recursos do módulo de caminho, poderá descobrir detalhes sobre esse caminho de uma forma conveniente para percepção e processamento posterior. Se parece com isso:

Const notas = "/users/flavio/notes.txt" path.dirname(notes) // /users/flavio path.basename(notes) // notas.txt path.extname(notes) // .txt

Aqui, na linha de notas, o caminho para o arquivo é armazenado. Os seguintes métodos do módulo path são usados para analisar o caminho:

dirname() – retorna o diretório pai do arquivo.
basename() - retorna o nome do arquivo.
extname() – retorna a extensão do arquivo.

Você pode descobrir o nome do arquivo sem extensão chamando o método .basename() e passando a ele um segundo argumento representando a extensão:

Path.basename(notas, path.extname(notas)) //notas

▍Trabalhando com caminhos de arquivo

Várias partes do caminho podem ser unidas usando o método path.join():

Const nome = "flavio" path.join("/", "usuários", nome, "notes.txt") //"/users/flavio/notes.txt"

Você pode encontrar o caminho absoluto de um arquivo com base em seu caminho relativo usando o método path.resolve():

Path.resolve("flavio.txt") //"/Users/flavio/flavio.txt" ao executar a partir da minha pasta pessoal

Nesse caso, o Node.js simplesmente adiciona /flavio.txt ao caminho que leva ao diretório de trabalho atual. Ao chamar este método, se passar outro parâmetro representando o caminho da pasta, o método o utiliza como base para determinar o caminho absoluto:

Path.resolve("tmp", "flavio.txt") // "/Users/flavio/tmp/flavio.txt" ao executar a partir da minha pasta pessoal

Se o caminho passado como primeiro parâmetro começar com uma barra, significa que é um caminho absoluto.

Path.resolve("/etc", "flavio.txt") // "/etc/flavio.txt"

Aqui está outro método útil - path.normalize() . Ele permite que você encontre o caminho real de um arquivo usando um caminho que contém especificadores de caminho relativos, como um ponto (.), dois pontos (..) ou duas barras:

Path.normalize("/users/flavio/..//test.txt") // /users/test.txt

Os métodos resolve() e normalize() não verificam a existência de um diretório. Eles simplesmente encontram um caminho com base nos dados que lhes são fornecidos.

Lendo arquivos em Node.js

A maneira mais simples de ler arquivos em Node.js é usar o método fs.readFile(), passando para ele o caminho do arquivo e um callback que será chamado passando os dados do arquivo (ou um objeto de erro):

Fs.readFile("/Users/flavio/test.txt", (err, dados) => ( if (err) ( console.error(err) return ) console.log(data) ))

Se necessário, você pode usar a versão síncrona deste método - fs.readFileSync() :

Const fs = require("fs") try ( const data = fs.readFileSync("/Users/flavio/test.txt") console.log(data) ) catch (err) ( console.error(err) )

Por padrão, ao ler arquivos, a codificação é utf8, mas você mesmo pode definir a codificação passando o parâmetro apropriado para o método.

Os métodos fs.readFile() e fs.readFileSync() leem todo o conteúdo de um arquivo na memória. Isso significa que trabalhar com arquivos grandes usando esses métodos afetará seriamente o consumo de memória e o desempenho do seu aplicativo. Se você precisar trabalhar com esses arquivos, é melhor usar streams.

Escrevendo arquivos em Node.js

No Node.js, a maneira mais fácil de gravar arquivos é usando o método fs.writeFile():

Const fs = require("fs") const content = "Algum conteúdo!" fs.writeFile("/Users/flavio/test.txt", content, (err) => ( if (err) ( console.error(err) return ) //arquivo gravado com sucesso ))

Há também uma versão síncrona do mesmo método - fs.writeFileSync() :

Const fs = require("fs") const content = "Algum conteúdo!" try (const data = fs.writeFileSync("/Users/flavio/test.txt", content) //arquivo gravado com sucesso) catch (err) ( console.error(err) )

Esses métodos, por padrão, substituem o conteúdo dos arquivos existentes. Você pode alterar seu comportamento padrão usando o sinalizador correspondente:

Fs.writeFile("/Users/flavio/test.txt", conteúdo, (sinalizador: "a+"), (err) => ())

As flags que já listamos na seção sobre descritores podem ser utilizadas aqui. Detalhes sobre as bandeiras podem ser encontrados.

Anexando dados a um arquivo

O método fs.appendFile() (e sua versão síncrona, fs.appendFileSync()) é útil para anexar dados ao final de um arquivo:

Const content = "Algum conteúdo!" fs.appendFile("arquivo.log", content, (err) => ( if (err) ( console.error(err) return ) //feito! ))

Sobre o uso de threads

Acima, descrevemos métodos que, ao gravar em um arquivo, gravam toda a quantidade de dados transferidos para ele, após o que, se suas versões síncronas forem utilizadas, eles devolvem o controle ao programa, e se forem utilizadas versões assíncronas, eles chamam retornos de chamada . Se você não estiver satisfeito com esse estado de coisas, seria melhor usar streams.

Trabalhando com diretórios em Node.js

O módulo fs fornece ao desenvolvedor muitos métodos convenientes que podem ser usados para trabalhar com diretórios.

▍Verificando a existência de uma pasta

Para verificar se existe um diretório e se o Node.js pode acessá-lo com permissões, você pode usar o método fs.access().

▍Criando uma nova pasta

Para criar novas pastas, você pode usar os métodos fs.mkdir() e fs.mkdirSync():

Const fs = require("fs") const folderName = "/Users/flavio/test" try ( if (!fs.existsSync(dir))( fs.mkdirSync(dir) ) ) catch (err) ( console.error( errar))

▍Lendo o conteúdo de uma pasta

Para ler o conteúdo de uma pasta, você pode usar os métodos fs.readdir() e fs.readdirSync(). Este exemplo lê o conteúdo de uma pasta — ou seja, quais arquivos e subdiretórios ela contém — e retorna seus caminhos relativos:

Const fs = require("fs") const path = require("path") const folderPath = "/Users/flavio" fs.readdirSync(folderPath)

É assim que você pode obter o caminho completo para o arquivo:

Fs.readdirSync(folderPath).map(fileName => ( return path.join(folderPath, fileName) )

Os resultados podem ser filtrados para retornar apenas arquivos e excluir diretórios da saída:

Const isFile = fileName => ( return fs.lstatSync(fileName).isFile() ) fs.readdirSync(folderPath).map(fileName => ( return path.join(folderPath, fileName)).filter(isFile) )

▍Renomeando uma pasta

Para renomear uma pasta, você pode usar os métodos fs.rename() e fs.renameSync(). O primeiro parâmetro é o caminho da pasta atual, o segundo é o novo:

Const fs = require("fs") fs.rename("/Users/flavio", "/Users/roger", (err) => ( if (err) ( console.error(err) return ) // pronto ) )

Você também pode renomear uma pasta usando o método síncrono fs.renameSync():

Const fs = require("fs") try ( fs.renameSync("/Users/flavio", "/Users/roger") ) catch (err) ( console.error(err) )

▍Excluindo uma pasta

Para excluir uma pasta, você pode usar os métodos fs.rmdir() ou fs.rmdirSync(). Deve-se observar que excluir uma pasta que contém algo é uma tarefa um pouco mais difícil do que excluir uma pasta vazia. Se você precisar remover essas pastas, use o pacote fs-extra, que é bastante popular e bem suportado. É um substituto do módulo fs, ampliando suas capacidades.

O método remove() do pacote fs-extra pode remover pastas que já contêm algo.

Você pode instalar este módulo assim:

Npm instala fs-extra

Aqui está um exemplo de seu uso:

Const fs = require("fs-extra") const folder = "/Users/flavio" fs.remove(folder, err => ( console.error(err) ))

Seus métodos podem ser usados como promessas:

Fs.remove(pasta).then(() => ( //feito )).catch(err => ( console.error(err) ))

Também é possível usar a construção async/await:

Função assíncrona removeFolder(folder) ( try ( await fs.remove(folder) // done ) catch (err) ( console.error(err) ) ) const folder = "/Users/flavio" removeFolder(folder)

módulo fs

Acima já encontramos alguns métodos do módulo fs usados ao trabalhar com o sistema de arquivos. Na verdade, contém muito mais coisas úteis. Lembramos que não requer instalação, para utilizá-lo no programa basta conectá-lo:

Const fs = requer("fs")

Depois disso, você terá acesso aos seus métodos, entre os quais destacamos os seguintes, alguns dos quais já lhe são familiares:

fs.access(): verifica se um arquivo existe e pode ser acessado com base nas permissões.
fs.appendFile(): acrescenta dados a um arquivo. Se o arquivo não existir, ele será criado.
fs.chmod(): altera as permissões do arquivo fornecido. Métodos semelhantes: fs.lchmod() , fs.fchmod() .
fs.chown(): altera o proprietário e o grupo de um determinado arquivo. Métodos semelhantes: fs.fchown() , fs.lcown() .
fs.close(): fecha um identificador de arquivo.
fs.copyFile(): Copia um arquivo.
fs.createReadStream(): Cria um fluxo de leitura de arquivo.
fs.createWriteStream(): Cria um fluxo de gravação de arquivo.
fs.link() : Cria um novo link físico para um arquivo.
fs.mkdir(): Cria um novo diretório.
fs.mkdtemp(): Cria um diretório temporário.
fs.open(): Abre um arquivo.
fs.readdir(): Lê o conteúdo de um diretório.
fs.readFile(): Lê o conteúdo de um arquivo. Método semelhante: fs.read() .
fs.readlink(): Lê o valor de um link simbólico.
fs.realpath(): permite um caminho de arquivo relativo construído usando símbolos. e.., até o fim.
fs.rename(): Renomeia um arquivo ou pasta.
fs.rmdir(): Exclui uma pasta.
fs.stat(): Retorna informações do arquivo. Métodos semelhantes: fs.fstat() , fs.lstat() .
fs.symlink(): Cria um novo link simbólico para um arquivo.
fs.truncate(): trunca o arquivo no comprimento especificado. Método semelhante: fs.ftruncate() .
fs.unlink(): Remove um arquivo ou link simbólico.
fs.unwatchFile(): Desativa a observação de alterações de arquivos.
fs.utimes(): altera o carimbo de data/hora de um arquivo. Método semelhante: fs.futimes() .
fs.watchFile() : permite observar alterações no arquivo. Método semelhante: fs.watch() .
fs.writeFile(): Grava dados em um arquivo. Método semelhante: fs.write() .

Uma característica interessante do módulo fs é o fato de que todos os seus métodos são assíncronos por padrão, mas também existem versões síncronas deles, cujos nomes são obtidos adicionando a palavra Sync aos nomes dos métodos assíncronos.

Por exemplo:

fs.renomear()
fs.renameSync()
fs.write()
fs.writeSync()

O uso de métodos síncronos tem um sério impacto no funcionamento do programa.

O Node.js 10 tem suporte experimental para essas APIs baseadas em promessas.

Vamos explorar o método fs.rename(). Aqui está uma versão assíncrona deste método usando retornos de chamada:

Const fs = require("fs") fs.rename("before.json", "after.json", (err) => ( if (err) ( return console.error(err) ) //feito ))

Ao usar sua versão síncrona, uma construção try/catch é usada para tratar erros:

Const fs = require("fs") try ( fs.renameSync("before.json", "after.json") //feito) catch (err) ( console.error(err) )

A principal diferença entre essas opções de utilização deste método é que no segundo caso, a execução do script será bloqueada até que a operação do arquivo seja concluída.

módulo de caminho

O módulo path, cujos recursos já discutimos, contém muitas ferramentas úteis que permitem interagir com o sistema de arquivos. Como já dito, não há necessidade de instalá-lo, pois faz parte do Node.js. Para utilizá-lo, basta conectá-lo:

Const caminho = require("caminho")

A propriedade path.sep deste módulo fornece o caractere usado para separar segmentos de caminho (; no Windows e / no Linux e macOS), e a propriedade path.delimiter fornece o caractere usado para separar vários caminhos (; no Windows e: no Linux e macOS).

Vejamos e ilustremos com exemplos alguns métodos do módulo path.

▍caminho.nomebase()

Retorna o último fragmento do caminho. Ao passar o segundo parâmetro para este método, você pode remover a extensão do arquivo.

Require("caminho").basename("/test/something") //algo require("path").basename("/test/something.txt") //something.txt require("path").basename ("/test/alguma coisa.txt", ".txt") //alguma coisa

▍caminho.dirname()

Retorna a parte do caminho que representa o nome do diretório:

Require("caminho").dirname("/teste/algo") // /teste require("caminho").dirname("/teste/algo/arquivo.txt") // /teste/algo

▍caminho.extname()

Retorna a parte do caminho que representa a extensão do arquivo: require("caminho").dirname("/test/something") // "" require("path").dirname("/test/something/file.txt") // ".txt"

▍path.isAbsolute()

Retorna verdadeiro se o caminho for absoluto:

Require("caminho").isAbsolute("/teste/alguma coisa") // verdadeiro require("caminho").isAbsolute("./teste/alguma coisa") // falso

▍caminho.join()

Conecta várias partes do caminho:

Const nome = "flavio" require("caminho").join("/", "usuários", nome, "notes.txt") //"/users/flavio/notes.txt"

▍path.normalize()

Tenta descobrir o caminho real com base em um caminho que contém caracteres usados na construção de caminhos relativos como. , .. E // :

Require("caminho").normalize("/users/flavio/..//test.txt") ///users/test.txt

▍caminho.parse()

Converte um caminho em um objeto cujas propriedades representam as partes individuais do caminho:

raiz: diretório raiz.
dir: caminho para o arquivo, começando no diretório raiz
base: nome e extensão do arquivo.
nome: nome do arquivo.
ext: extensão do arquivo.

Aqui está um exemplo de uso deste método:

Exigir("caminho").parse("/users/test.txt")

Como resultado de seu trabalho, obtém-se o seguinte objeto:

( root: "/", dir: "/users", base: "test.txt", ext: ".txt", nome: "test" )

▍caminho.relativo()

Aceita 2 caminhos como argumentos. Retorna o caminho relativo do primeiro caminho para o segundo, com base no diretório de trabalho atual:

Require("caminho").relative("/Users/flavio", "/Users/flavio/test.txt") //"test.txt" require("path").relative("/Users/flavio", "/Users/flavio/something/test.txt") //"something/test.txt"

▍caminho.resolver()

Encontra um caminho absoluto com base no caminho relativo passado para ele:

Path.resolve("flavio.txt") //"/Users/flavio/flavio.txt" ao executar a partir da minha pasta pessoal.

Resultados

Hoje vimos os módulos fs e path do Node.js, que são usados para trabalhar com o sistema de arquivos. Na próxima parte desta série, onde ela termina, discutiremos os módulos os , events , http, falaremos sobre como trabalhar com threads e como trabalhar com sistemas de gerenciamento de banco de dados em Node.js.

Queridos leitores! Quais pacotes npm você usa ao trabalhar com o sistema de arquivos no Node.js?

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, leva dezenas de milhares de vezes mais tempo 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);