Um guia básico para manipular o sistema de arquivos no Node.js

Um dos recursos integrados do Node.js é a manipulação do sistema de arquivos do sistema operacional usando o módulo fs. Este módulo Node.js contém muitas funções úteis para trabalhar com arquivos e diretórios.

Os arquivos são simplesmente referidos como objetos persistentes ou blocos de dados que normalmente são armazenados em uma mídia rígida conhecida como disco ou memória. Os arquivos podem ser de vários tipos, desde arquivos de texto a arquivos de imagem, arquivos de áudio e muito mais.

Então, o que é um sistema de arquivos e como você pode interagir facilmente com o sistema de arquivos de um sistema operacional no Node.js?

O que é um sistema de arquivos?

Um sistema de arquivos define como um sistema operacional pode identificar, organizar, armazenar e acessar arquivos, juntamente com outras operações.

O sistema de arquivos de um sistema operacional também faz o trabalho de agrupar arquivos em coleções conhecidas como diretórios ou pastas. Arquivos e diretórios comuns são as partes mais comuns de um sistema de arquivos que frequentemente interagem entre muitos outros.

Alguns exemplos de sistemas de arquivos incluem New Technology File System (NTFS), UNIX File System (UFS) e Hierarchical File System (HFS).

O que é o módulo Node.js fs?

O Node.js fs module é uma biblioteca integrada fornecida pelo Node.js para trabalhar com o sistema de arquivos de qualquer sistema operacional compatível com Node. O fs módulo é facilmente acessível e é a biblioteca para operações de arquivo como lendo de arquivos ou gravando dados em arquivos no Node.js.

É muito usado com caminho e os módulos para executar várias operações em arquivos. Para usar o fs módulo em seus programas, você pode importá-lo em seu código-fonte, conforme mostrado no código abaixo.

// CommonJS
const fs = exigir('fs')
// ES6
importar fs de 'fs'

O que é o módulo de caminho Node.js?

Você pode usar o Node.js caminho módulo para manipular caminhos de arquivo. Ele inclui utilitários para interagir facilmente com caminhos de arquivos e diretórios. Usando o fs e caminho módulos em conjunto para concluir uma tarefa é uma prática padrão. Isto porque a maioria dos fs as funções do módulo dependem dos caminhos para os arquivos ou diretórios de destino para funcionar.

Você pode importar o caminho module em seu código com a sintaxe abaixo:

// CommonJS
const caminho = exigir('caminho')
// ES6
importar caminho de 'caminho'

Funções comuns para acessar o sistema de arquivos no Node.js

Aqui estão os Node.js mais usados fs e caminho funções do módulo e como usá-las para interagir com arquivos e diretórios.

Trabalhando com Caminhos

1. path.resolve: Esta é a função para resolver um caminho de uma lista de instruções de caminho passadas como parâmetros. Por exemplo:

   path.resolve('home', 'projetos', 'web');
   // retorna /home/projects/web
   path.resolve('home/projects/web', '../mobile');
   // retorna /home/projects/mobile
   

2. path.normalize: O normalizar A função retorna o caminho correto e normalizado de um determinado caminho de entrada. Por exemplo:

   path.normalize('home/projects/web/../mobile/./code');
   // retorna home/projects/mobile/code
   

3. path.join: Esta função constrói um caminho a partir de vários segmentos. Por exemplo:

   path.join('home', 'projects', '../', 'movies');
   // retorna para casa/filmes
   

4. path.basename: O nome base função retorna o segmento de caminho final. Você pode usá-lo de duas maneiras:

   path.basename('home/projects/web/index.js');
   // retorna index.js
   path.basename('home/projects/web/index.js', '.js');
   // remove a extensão e retorna 'index'
   

5. path.dirname: Esta função retorna o caminho para o último diretório de um determinado caminho. Exemplo:

   path.dirname('home/projects/web/index.js');
   // retorna home/projects/web
   

6. path.extname: Com esta função, você pode obter a extensão de um arquivo de um determinado caminho.

   path.extname('home/projects/web/index.js');
   // retorna '.js'
   

Abrindo e Fechando Arquivos

1. fs.open: Esta é a função para abrir ou criar um arquivo de forma síncrona no Node.js. A forma síncrona de fs.open é fs.openSync. fs.abra umaceita quatro argumentos que são o caminho do arquivo, sinalizadores, modo aberto e uma função de retorno de chamada. Bandeiras e abrirmodo têm um valor padrão e você pode aprender mais sobre eles no Node.js fs.open documentação.

   const filePath = path.join (__dirname, '/videos/novoVídeo.mp4');
   // __dirname retorna o caminho para o diretório de trabalho atual.
   // caminho do arquivo = /videos/newVideo.mp4
   fs.open (filePath, (erro, fileDescriptor) => {
   // trata erros
   console.log (arquivoDescriptor); // imprime um inteiro representando o descritor do arquivo
   })
   

2. fs.close: É uma boa prática sempre fechar todos os arquivos abertos quando eles não forem mais necessários. Node.js tem o fs.close função para isso:

   fs.open (filePath, (erro, fileDescriptor) => {
   // lida com erros, como 'arquivo/diretório não existe'
   console.log (arquivoDescriptor);
   // fecha o arquivo
    fs.close (arquivoDescriptor, (erro) => {
   // trata erros
   console.log('Arquivo fechado com sucesso');
    });
   })
   

Criando e Excluindo

1. fs.mkdir: Isso funciona exatamente como o mkdir comando terminal que cria um novo diretório. Leva em um caminho, modo (opcional) e função de retorno de chamada como parâmetros. Você pode usar assim:

   const dirPath = path.join (__dirname, 'newDirectory');
   fs.mkdir (dirPath, (erro) => {
   // trata erros
   console.log('Novo diretório criado com sucesso');
   });
   

2. fs.unlink: Esta função remove ou exclui o arquivo no caminho passado como um argumento. Considere o exemplo de código abaixo:

   const filePath = path.join (_dirname, 'oldFile.js');
   fs.unlink (filePath, (erro) => {
   // trata erros
   console.log('Arquivo excluído com sucesso');
   });
   

3. fs.rmdir: Este método exclui o diretório em um determinado caminho. É muito semelhante ao uso do método unlink:

   const dirPath = path.resolve('home', 'projetos', 'web');
   fs.rmdir (dirPath, (erro) => {
   // trata erros
   console.log('Diretório deletado com sucesso');
   })
   

1. fs.existe: O existe O método verifica se o arquivo em um determinado caminho existe. A implementação é a seguinte:

   deixar filePath = path.join (__dirname, 'index.html');
   fs.exists (filePath, (exists) => {
   console.log (existe) // verdadeiro ou falso
   })
   

2. fs.stat: Esta é uma função síncrona que retorna as propriedades de um arquivo. Ele retorna um fs. Estatísticas objeto que expõe alguns métodos para acessar as propriedades do arquivo. Aqui está um exemplo:

   fs.stat('index.js', (erro, estatísticas) => {
   console.log (estatísticas); // imprime propriedades de baixo nível do arquivo
    stats.isFile(); // retorna verdadeiro
    stats.isDirectory(); // retorna falso
   })
   

Manipulando o sistema de arquivos no Node.js

A vastidão do fs módulo torna muito fácil acessar e interagir com arquivos em qualquer sistema operacional. Quando você o usa junto com o caminho módulo, você está aberto a mais funcionalidades e pode manipular o sistema de arquivos como quiser.

Uma grande vantagem do Node.js é sua portabilidade. Você pode desenvolver seus aplicativos em qualquer plataforma e implantá-los em qualquer lugar sem se preocupar com problemas básicos de compatibilidade.