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

Um dos recursos internos 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 chamados de objetos persistentes ou pedaços de dados que normalmente são armazenados em um meio rígido conhecido como disco ou memória. Os arquivos podem ser de vários tipos, desde arquivos de texto até arquivos de imagem, arquivos de áudio e muito mais.

classificar amazon pelo número de comentários

MAKEUSEO VÍDEO DO DIA

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 com as quais interage com muitas outras.

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 que suporte 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 utilizado com o caminho e os módulos para realizar 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 = require('fs') 
  
// ES6 
import fs from 'fs'

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

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

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

como verificar dpi da imagem

// CommonJS 
const path = require('path') 
  
// ES6 
import path from 'path'

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

caminho.resolver: 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', 'projects', 'web'); 
// returns <path_to_current_directory>/home/projects/web 
  
path.resolve('home/projects/web', '../mobile'); 
// returns <path_to_current_directory>/home/projects/mobile

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'); 
// returns home/projects/mobile/code 
```
path.join: Esta função cria um caminho de vários segmentos. Por exemplo:
```
path.join('home', 'projects', '../', 'movies'); 
// returns home/movies 
```

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

path.basename('home/projects/web/index.js'); 
// returns index.js 
  
path.basename('home/projects/web/index.js', '.js'); 
// removes the extension and returns 'index'

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'); 
// returns home/projects/web 
```
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'); 
// returns '.js' 
```

Abrindo e Fechando Arquivos

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.abrir é fs.openSync . fs.abra um aceita quatro argumentos que são o caminho do arquivo, sinalizadores, modo aberto e uma função de retorno de chamada. Bandeiras e abrir modo 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/newVideo.mp4'); 
// __dirname returns the path to the current working directory. 
// filePath = <path_to_current_directory>/videos/newVideo.mp4 
  
fs.open(filePath, (error, fileDescriptor) => { 
    // handle errors 
    console.log(fileDescriptor); // prints an integer representing the file descriptor 
}) 
```

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.fechar função para isso:

fs.open(filePath, (error, fileDescriptor) => { 
    // handle errors, such as 'file/directory does not exist' 
    console.log(fileDescriptor); 
  
    // close the file 
    fs.close(fileDescriptor, (error) => { 
        // handle errors 
        console.log('File closed successfully'); 
    }); 
})

Criando e excluindo

fs.mkdir: Isso funciona exatamente como o mkdir comando de terminal que cria um novo diretório. Ele recebe um caminho, modo (opcional) e função de retorno de chamada como parâmetros. Você pode usá-lo assim:
```
const dirPath = path.join(__dirname, 'newDirectory'); 
fs.mkdir(dirPath, (error) => { 
    // handle errors 
    console.log('New directory created successfully'); 
}); 
```

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

const filePath = path.join(_dirname, 'oldFile.js'); 
  
fs.unlink(filePath, (error) => { 
    // handle errors 
    console.log('File has been deleted successfully'); 
});

fs.rmdir: Este método exclui o diretório em um determinado caminho. É muito semelhante em uso ao método de desvinculação:

const dirPath = path.resolve('home', 'projects', 'web'); 
  
fs.rmdir(dirPath, (error) => { 
    // handle errors 
    console.log('Directory successfully deleted'); 
})

Metadados de arquivo

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

let filePath = path.join(__dirname, 'index.html'); 
  
fs.exists(filePath, (exists) => { 
    console.log(exists) // true or false 
})

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

fs.stat('index.js', (error, stats) => { 
    console.log(stats); // prints low level properties of the file 
    stats.isFile(); // returns true 
    stats.isDirectory(); // returns false 
})