Uma breve análise dos módulos comuns no nó: módulo path e módulo fs

Como começar rapidamente com o VUE3.0: Entre no

módulo de caminho de

O módulo de caminho é usado para processar caminhos e arquivos e fornece vários métodos.

path.resolve

é concatenar o caminho e o nome do arquivo.

const basePath = '/usuário/por que'
const filename = 'abc.txt'

Então alguém usará a emenda de string para emendar.

const caminho do arquivo = caminhobase + '/' + nome do arquivo
console.log(filePath);

Embora não haja problema com tal resultado, considerando sistemas diferentes, o sistema Windows pode usar ou \ ou / como separador de caminho, enquanto os sistemas operacionais Unix do Mac OS e Linux usam / como o símbolo separador de caminho.

Para resolver o problema acima, podemos usar path.resolve para unir caminhos.

const caminho = require('caminho')

const basePath = '/usuário/por que'
const nome do arquivo = 'abc.txt'

const filePath = path.resolve(basePath, nome do arquivo)

console.log(filePath);

Obtenha informações do caminho

• dirname: Obtenha a pasta pai do arquivo
• basename: Obtenha o nome do arquivo
• extname: Obtenha a extensão do arquivo

const path = require('path')

const filePath = '/User/haha/abc.txt'

console.log(caminho.dirname(filePath));
console.log(caminho.basename(filePath));
console.log(caminho.extname(filePath));

Emenda de caminhos

Se quisermos unir vários caminhos, mas sistemas operacionais diferentes podem usar delimitadores diferentes, podemos usar a função path.join.

const caminho = require('caminho')

const basepath = '/Usuário/haha'
const nome do arquivo = 'abc.txt'

const filePath = path.join(basepath, nome do arquivo)
console.log(filePath);

Unindo um arquivo e uma pasta

Se quisermos unir um arquivo e uma pasta, podemos usar path.resolve.

const basepath = 'Usuário/haha'
const nome do arquivo = 'abc.txt'

Path.resolve e path.join também podem ser usados ​​para unir caminhos, então qual é a diferença entre eles?

const caminho base = '../Usuário/haha'
const nome do arquivo = './abc.txt'
const outro nome = './haha.js'

const filePath1 = path.join (caminho base, nome do arquivo, outro nome)
console.log(filePath1);

const filePath2 = path.resolve(basepath, nome do arquivo, outro nome)

filePath2

);

do módulo fs

fornece três métodos operacionais:

• Operação de arquivo síncrona: o código será bloqueado e não continuará a executar

• a função de retorno de chamada assíncrona. Operação de arquivo: o código não será bloqueado e uma função de retorno de chamada precisa ser. passado quando o resultado é obtido, a função de retorno de chamada executa

• um arquivo de operação Promise assíncrona: o código não será bloqueado. Chamar as operações do método por meio de fs.promises retornará uma Promise, que pode ser processada por meio de then e catch.

Leia o status do arquivo (informações)

método 1 operação síncrona: fs.statSync

const fs = require('fs')

caminho do arquivo const = './abc.txt'
informações const = fs.statSync(caminho do arquivo)
console.log('Código que precisa ser executado posteriormente');
console.log(informações);

Método 2 operação assíncrona

fs.stat(filepath, (err, info) => {
  se(erro) {
    console.log(erro);
    retornar
  }
  console.log(informações);
  console.log(info.isFile()); // Determina se é um arquivo console.log(info.isDirectory()); // Determina se é uma pasta})
console.log('Código que precisa ser executado mais tarde');

Método três: Promise

fs.promises.stat(filepath).then(info => {
  console.log(informações);
}).catch(err => {
  console.log(erro);
})

console.log('Código a ser executado posteriormente');

O

nó descritor de arquivo atribui um descritor de arquivo numérico a todos os arquivos abertos. Todas as operações do sistema de arquivos usam esses descritores de arquivo para identificar e rastrear cada arquivo específico.

O método fs.open() é usado para alocar um novo descritor de arquivo fd. Uma vez alocado, o descritor de arquivo pode ser usado para ler dados do arquivo, gravar dados no arquivo ou solicitar informações sobre o arquivo.

const fs = requer('fs')

fs.open('./abc.txt', (err, fd) => {
  se(erro) {
    console.log(erro);
    retornar
  }

  // Obtenha informações do arquivo através dos descritores de arquivo fs.fstat(fd, (err, info) => {
    console.log(informações);
  })
})

Leitura e gravação de arquivos

fs.readFile(path[, options], callback): Ler o conteúdo do arquivo

fs.writeFile(path[, options], callback): Gravar o conteúdo no arquivo

parâmetros de opção:

flag: modo escrito

codificação:

gravação de arquivo

fs.writeFile('./abc.txt', content, {flag: "a"}, err => {
  console.log(erro);
})

Leitura de arquivo

fs.readFile('./abc.txt', (err, data) => {
  console.log(dados);
})

Se a codificação não for preenchida, o resultado Buffer (binário) será retornado.

fs.readFile('./abc.txt', {codificação: 'utf-8'}, (err, dados) => {
  console.log(dados);
})

Crie uma pasta

Use fs.mkdir() ou fs.mkdirSync para criar uma nova pasta.

const fs = requer('fs')

//Cria a pasta const dirname = './haha'
if(!fs.existsSync(nomediretório)) {
  fs.mkdir(nome do diretório, (err) => {
    console.log(erro);
  })
}

Obtenha o conteúdo da pasta

fs.readdir

fs.readdir(dirname, (err, files) => {
  console.log(arquivos);
})

Obtenha todos os arquivos da pasta Neste momento, o diretório é mostrado na figura abaixo.

const fs = requer('fs')
const caminho = require('caminho')
const nome do diretório = './haha'

function getArquivos(nomediretório) {
  fs.readdir(dirname, {withFileTypes: true}, (err, arquivos) => {
    //console.log(arquivos);
    for(deixar arquivo de arquivos) {
      // Determine se é uma pasta if(file.isDirectory()) {
        const caminho do arquivo = caminho.resolve(dirname, arquivo.name)
        getFiles(caminho do arquivo)
      } outro {
        console.log(arquivo.nome);
      }
    }
  })
}

getFiles(dirname)

rename

Você pode usar fs.rename para renomear a pasta.

fs.rename('./haha', './xixi', err => {
  console.log(erro);
})