Node.js - sistema de arquivos
O Node implementa E / S de arquivo usando wrappers simples em torno de funções POSIX padrão. O módulo Node File System (fs) pode ser importado usando a seguinte sintaxe -
var fs = require("fs")
Síncrono vs Assíncrono
Cada método no módulo fs tem formulários síncronos e assíncronos. Os métodos assíncronos usam o último parâmetro como retorno de chamada da função de conclusão e o primeiro parâmetro da função de retorno de chamada como erro. É melhor usar um método assíncrono em vez de um método síncrono, pois o primeiro nunca bloqueia um programa durante sua execução, enquanto o segundo o faz.
Exemplo
Crie um arquivo de texto chamado input.txt com o seguinte conteúdo -
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Vamos criar um arquivo js chamado main.js com o seguinte código -
var fs = require("fs");
// Asynchronous read
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("Asynchronous read: " + data.toString());
});
// Synchronous read
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());
console.log("Program Ended");
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Synchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Program Ended
Asynchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
As seções a seguir neste capítulo fornecem um conjunto de bons exemplos sobre os principais métodos de E / S de arquivo.
Abra um arquivo
Sintaxe
A seguir está a sintaxe do método para abrir um arquivo no modo assíncrono -
fs.open(path, flags[, mode], callback)
Parâmetros
Aqui está a descrição dos parâmetros usados -
path - Esta é a string com o nome do arquivo incluindo o caminho.
flags- Sinalizadores indicam o comportamento do arquivo a ser aberto. Todos os valores possíveis foram mencionados abaixo.
mode- Define o modo do arquivo (permissão e bits pegajosos), mas somente se o arquivo foi criado. O padrão é 0666, legível e gravável.
callback - Esta é a função de retorno de chamada que obtém dois argumentos (err, fd).
Bandeiras
Sinalizadores para operações de leitura / gravação são -
Sr. Não. | Sinalizador e descrição |
---|---|
1 | r Abra o arquivo para leitura. Uma exceção ocorre se o arquivo não existir. |
2 | r+ Abra o arquivo para leitura e escrita. Uma exceção ocorre se o arquivo não existir. |
3 | rs Abra o arquivo para leitura no modo síncrono. |
4 | rs+ Abra o arquivo para leitura e gravação, pedindo ao SO para abri-lo de forma síncrona. Consulte as notas para 'rs' sobre como usar isso com cuidado. |
5 | w Abra o arquivo para gravação. O arquivo é criado (se não existir) ou truncado (se existir). |
6 | wx Como 'w', mas falha se o caminho existir. |
7 | w+ Abra o arquivo para leitura e escrita. O arquivo é criado (se não existir) ou truncado (se existir). |
8 | wx+ Como 'w +', mas falha se o caminho existir. |
9 | a Abra o arquivo para anexar. O arquivo é criado se não existir. |
10 | ax Como 'a', mas falha se o caminho existir. |
11 | a+ Abra o arquivo para ler e anexar. O arquivo é criado se não existir. |
12 | ax+ Como 'a +', mas falha se o caminho existir. |
Exemplo
Vamos criar um arquivo js chamado main.js tendo o seguinte código para abrir um arquivo input.txt para leitura e gravação.
var fs = require("fs");
// Asynchronous - Opening File
console.log("Going to open file!");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("File opened successfully!");
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to open file!
File opened successfully!
Obter informações do arquivo
Sintaxe
A seguir está a sintaxe do método para obter as informações sobre um arquivo -
fs.stat(path, callback)
Parâmetros
Aqui está a descrição dos parâmetros usados -
path - Esta é a string com o nome do arquivo incluindo o caminho.
callback - Esta é a função de retorno de chamada que obtém dois argumentos (err, estatísticas) onde stats é um objeto do tipo fs.Stats que é impresso a seguir no exemplo.
Além dos atributos importantes que são impressos abaixo no exemplo, existem vários métodos úteis disponíveis em fs.Statsclasse que pode ser usada para verificar o tipo de arquivo. Esses métodos são fornecidos na tabela a seguir.
Sr. Não. | Método e Descrição |
---|---|
1 | stats.isFile() Retorna verdadeiro se o tipo de arquivo de um arquivo simples. |
2 | stats.isDirectory() Retorna verdadeiro se o tipo de arquivo de um diretório. |
3 | stats.isBlockDevice() Retorna verdadeiro se o tipo de arquivo de um dispositivo de bloco. |
4 | stats.isCharacterDevice() Retorna verdadeiro se o tipo de arquivo de um dispositivo de caractere. |
5 | stats.isSymbolicLink() Retorna verdadeiro se o tipo de arquivo de um link simbólico. |
6 | stats.isFIFO() Retorna verdadeiro se o tipo de arquivo de um FIFO. |
7 | stats.isSocket() Retorna verdadeiro se o tipo de arquivo for asocket. |
Exemplo
Vamos criar um arquivo js chamado main.js com o seguinte código -
var fs = require("fs");
console.log("Going to get file info!");
fs.stat('input.txt', function (err, stats) {
if (err) {
return console.error(err);
}
console.log(stats);
console.log("Got file info successfully!");
// Check file type
console.log("isFile ? " + stats.isFile());
console.log("isDirectory ? " + stats.isDirectory());
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to get file info!
{
dev: 1792,
mode: 33188,
nlink: 1,
uid: 48,
gid: 48,
rdev: 0,
blksize: 4096,
ino: 4318127,
size: 97,
blocks: 8,
atime: Sun Mar 22 2015 13:40:00 GMT-0500 (CDT),
mtime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT),
ctime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT)
}
Got file info successfully!
isFile ? true
isDirectory ? false
Gravando um Arquivo
Sintaxe
A seguir está a sintaxe de um dos métodos para gravar em um arquivo -
fs.writeFile(filename, data[, options], callback)
Este método sobrescreverá o arquivo se ele já existir. Se você deseja gravar em um arquivo existente, deve usar outro método disponível.
Parâmetros
Aqui está a descrição dos parâmetros usados -
path - Esta é a string com o nome do arquivo incluindo o caminho.
data - Esta é a String ou Buffer a ser gravada no arquivo.
options- O terceiro parâmetro é um objeto que conterá {codificação, modo, sinalizador}. Por padrão. a codificação é utf8, o modo é o valor octal 0666. e o sinalizador é 'w'
callback - Esta é a função de retorno de chamada que obtém um único erro de parâmetro que retorna um erro no caso de qualquer erro de escrita.
Exemplo
Vamos criar um arquivo js chamado main.js tendo o seguinte código -
var fs = require("fs");
console.log("Going to write into existing file");
fs.writeFile('input.txt', 'Simply Easy Learning!', function(err) {
if (err) {
return console.error(err);
}
console.log("Data written successfully!");
console.log("Let's read newly written data");
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("Asynchronous read: " + data.toString());
});
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to write into existing file
Data written successfully!
Let's read newly written data
Asynchronous read: Simply Easy Learning!
Lendo um arquivo
Sintaxe
A seguir está a sintaxe de um dos métodos para ler de um arquivo -
fs.read(fd, buffer, offset, length, position, callback)
Este método usará o descritor de arquivo para ler o arquivo. Se você quiser ler o arquivo diretamente usando o nome do arquivo, deverá usar outro método disponível.
Parâmetros
Aqui está a descrição dos parâmetros usados -
fd - Este é o descritor de arquivo retornado por fs.open ().
buffer - Este é o buffer no qual os dados serão gravados.
offset - Este é o deslocamento no buffer para iniciar a gravação.
length - Este é um número inteiro que especifica o número de bytes a serem lidos.
position- Este é um número inteiro que especifica onde começar a leitura do arquivo. Se a posição for nula, os dados serão lidos da posição atual do arquivo.
callback - Esta é a função de retorno de chamada que obtém os três argumentos (err, bytesRead, buffer).
Exemplo
Vamos criar um arquivo js chamado main.js com o seguinte código -
var fs = require("fs");
var buf = new Buffer(1024);
console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("File opened successfully!");
console.log("Going to read the file");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
if (err){
console.log(err);
}
console.log(bytes + " bytes read");
// Print only read bytes to avoid junk.
if(bytes > 0){
console.log(buf.slice(0, bytes).toString());
}
});
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to open an existing file
File opened successfully!
Going to read the file
97 bytes read
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Fechando um Arquivo
Sintaxe
A seguir está a sintaxe para fechar um arquivo aberto -
fs.close(fd, callback)
Parâmetros
Aqui está a descrição dos parâmetros usados -
fd - Este é o descritor de arquivo retornado pelo método file fs.open ().
callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.
Exemplo
Vamos criar um arquivo js chamado main.js tendo o seguinte código -
var fs = require("fs");
var buf = new Buffer(1024);
console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("File opened successfully!");
console.log("Going to read the file");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
if (err) {
console.log(err);
}
// Print only read bytes to avoid junk.
if(bytes > 0) {
console.log(buf.slice(0, bytes).toString());
}
// Close the opened file.
fs.close(fd, function(err) {
if (err) {
console.log(err);
}
console.log("File closed successfully.");
});
});
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to open an existing file
File opened successfully!
Going to read the file
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
File closed successfully.
Truncar um arquivo
Sintaxe
A seguir está a sintaxe do método para truncar um arquivo aberto -
fs.ftruncate(fd, len, callback)
Parâmetros
Aqui está a descrição dos parâmetros usados -
fd - Este é o descritor de arquivo retornado por fs.open ().
len - Este é o comprimento do arquivo após o qual o arquivo será truncado.
callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.
Exemplo
Vamos criar um arquivo js chamado main.js tendo o seguinte código -
var fs = require("fs");
var buf = new Buffer(1024);
console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("File opened successfully!");
console.log("Going to truncate the file after 10 bytes");
// Truncate the opened file.
fs.ftruncate(fd, 10, function(err) {
if (err) {
console.log(err);
}
console.log("File truncated successfully.");
console.log("Going to read the same file");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
if (err) {
console.log(err);
}
// Print only read bytes to avoid junk.
if(bytes > 0) {
console.log(buf.slice(0, bytes).toString());
}
// Close the opened file.
fs.close(fd, function(err) {
if (err) {
console.log(err);
}
console.log("File closed successfully.");
});
});
});
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to open an existing file
File opened successfully!
Going to truncate the file after 10 bytes
File truncated successfully.
Going to read the same file
Tutorials
File closed successfully.
Excluir um arquivo
Sintaxe
A seguir está a sintaxe do método para excluir um arquivo -
fs.unlink(path, callback)
Parâmetros
Aqui está a descrição dos parâmetros usados -
path - Este é o nome do arquivo incluindo o caminho.
callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.
Exemplo
Vamos criar um arquivo js chamado main.js tendo o seguinte código -
var fs = require("fs");
console.log("Going to delete an existing file");
fs.unlink('input.txt', function(err) {
if (err) {
return console.error(err);
}
console.log("File deleted successfully!");
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to delete an existing file
File deleted successfully!
Crie um diretório
Sintaxe
A seguir está a sintaxe do método para criar um diretório -
fs.mkdir(path[, mode], callback)
Parâmetros
Aqui está a descrição dos parâmetros usados -
path - Este é o nome do diretório incluindo o caminho.
mode- Esta é a permissão de diretório a ser definida. O padrão é 0777.
callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.
Exemplo
Vamos criar um arquivo js chamado main.js tendo o seguinte código -
var fs = require("fs");
console.log("Going to create directory /tmp/test");
fs.mkdir('/tmp/test',function(err) {
if (err) {
return console.error(err);
}
console.log("Directory created successfully!");
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to create directory /tmp/test
Directory created successfully!
Leia um diretório
Sintaxe
A seguir está a sintaxe do método para ler um diretório -
fs.readdir(path, callback)
Parâmetros
Aqui está a descrição dos parâmetros usados -
path - Este é o nome do diretório incluindo o caminho.
callback- Esta é a função de retorno de chamada que obtém dois argumentos (errar, arquivos) onde arquivos é uma matriz dos nomes dos arquivos no diretório, excluindo '.' e '..'.
Exemplo
Vamos criar um arquivo js chamado main.js tendo o seguinte código -
var fs = require("fs");
console.log("Going to read directory /tmp");
fs.readdir("/tmp/",function(err, files) {
if (err) {
return console.error(err);
}
files.forEach( function (file) {
console.log( file );
});
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to read directory /tmp
ccmzx99o.out
ccyCSbkF.out
employee.ser
hsperfdata_apache
test
test.txt
Remover um diretório
Sintaxe
A seguir está a sintaxe do método para remover um diretório -
fs.rmdir(path, callback)
Parâmetros
Aqui está a descrição dos parâmetros usados -
path - Este é o nome do diretório incluindo o caminho.
callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.
Exemplo
Vamos criar um arquivo js chamado main.js tendo o seguinte código -
var fs = require("fs");
console.log("Going to delete directory /tmp/test");
fs.rmdir("/tmp/test",function(err) {
if (err) {
return console.error(err);
}
console.log("Going to read directory /tmp");
fs.readdir("/tmp/",function(err, files) {
if (err) {
return console.error(err);
}
files.forEach( function (file) {
console.log( file );
});
});
});
Agora execute o main.js para ver o resultado -
$ node main.js
Verifique a saída.
Going to read directory /tmp
ccmzx99o.out
ccyCSbkF.out
employee.ser
hsperfdata_apache
test.txt
Referência de Métodos
Sr. Não | Método e Descrição |
---|---|
1 | fs.rename(oldPath, newPath, callback) Renomear assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
2 | fs.ftruncate(fd, len, callback) Ftruncate assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
3 | fs.ftruncateSync(fd, len) Ftruncate síncrono (). |
4 | fs.truncate(path, len, callback) Truncate assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
5 | fs.truncateSync(path, len) Truncamento síncrono (). |
6 | fs.chown(path, uid, gid, callback) Chown assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
7 | fs.chownSync(path, uid, gid) Chown síncrono (). |
8 | fs.fchown(fd, uid, gid, callback) Fchown assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
9 | fs.fchownSync(fd, uid, gid) Fchown síncrono (). |
10 | fs.lchown(path, uid, gid, callback) Lchown assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
11 | fs.lchownSync(path, uid, gid) Lchown síncrono (). |
12 | fs.chmod(path, mode, callback) Chmod assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
13 | fs.chmodSync(path, mode) Chmod síncrono (). |
14 | fs.fchmod(fd, mode, callback) Fchmod assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
15 | fs.fchmodSync(fd, mode) Fchmod síncrono (). |
16 | fs.lchmod(path, mode, callback) Lchmod assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. Disponível apenas no Mac OS X. |
17 | fs.lchmodSync(path, mode) Lchmod síncrono (). |
18 | fs.stat(path, callback) Stat assíncrono (). O retorno de chamada obtém dois argumentos (err, estatísticas) onde estatísticas é um objeto fs.Stats. |
19 | fs.lstat(path, callback) Lstat assíncrono (). O retorno de chamada obtém dois argumentos (err, estatísticas) onde estatísticas é um objeto fs.Stats. lstat () é idêntico a stat (), exceto que se o caminho for um link simbólico, então o próprio link é stat-ed, não o arquivo ao qual se refere. |
20 | fs.fstat(fd, callback) Fstat assíncrono (). O retorno de chamada obtém dois argumentos (err, estatísticas) onde estatísticas é um objeto fs.Stats. fstat () é idêntico a stat (), exceto que o arquivo a ser stat-ed é especificado pelo descritor de arquivo fd. |
21 | fs.statSync(path) Stat síncrono (). Retorna uma instância de fs.Stats. |
22 | fs.lstatSync(path) Lstat síncrono (). Retorna uma instância de fs.Stats. |
23 | fs.fstatSync(fd) Fstat síncrono (). Retorna uma instância de fs.Stats. |
24 | fs.link(srcpath, dstpath, callback) Link assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
25 | fs.linkSync(srcpath, dstpath) Link síncrono (). |
26 | fs.symlink(srcpath, dstpath[, type], callback) Link simbólico assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. O argumento de tipo pode ser definido como 'dir', 'arquivo' ou 'junção' (o padrão é 'arquivo') e está disponível apenas no Windows (ignorado em outras plataformas). Observe que os pontos de junção do Windows exigem que o caminho de destino seja absoluto. Ao usar 'junção', o argumento de destino será normalizado automaticamente para o caminho absoluto. |
27 | fs.symlinkSync(srcpath, dstpath[, type]) Link simbólico síncrono (). |
28 | fs.readlink(path, callback) Readlink assíncrono (). O retorno de chamada obtém dois argumentos (err, linkString). |
29 | fs.realpath(path[, cache], callback) Realpath assíncrono (). O retorno de chamada obtém dois argumentos (err, resolvidoPath). Pode usar process.cwd para resolver caminhos relativos. cache é um objeto literal de caminhos mapeados que pode ser usado para forçar uma resolução de caminho específica ou evitar chamadas fs.stat adicionais para caminhos reais conhecidos. |
30 | fs.realpathSync(path[, cache]) Realpath síncrono (). Retorna o caminho resolvido. |
31 | fs.unlink(path, callback) Desvinculação assíncrona (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
32 | fs.unlinkSync(path) Desvinculação síncrona (). |
33 | fs.rmdir(path, callback) Rmdir assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
34 | fs.rmdirSync(path) Rmdir síncrono (). |
35 | fs.mkdir(path[, mode], callback) Mkdir assíncrono (2). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. modo padrão é 0777. |
36 | fs.mkdirSync(path[, mode]) Mkdir síncrono (). |
37 | fs.readdir(path, callback) Readdir assíncrono (3). Lê o conteúdo de um diretório. O retorno de chamada obtém dois argumentos (err, arquivos) onde arquivos é uma matriz dos nomes dos arquivos no diretório, excluindo '.' e '..'. |
38 | fs.readdirSync(path) Readdir síncrono (). Retorna uma matriz de nomes de arquivos, excluindo '.' e '..'. |
39 | fs.close(fd, callback) Close assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
40 | fs.closeSync(fd) Fechamento síncrono (). |
41 | fs.open(path, flags[, mode], callback) Arquivo assíncrono aberto. |
42 | fs.openSync(path, flags[, mode]) Versão síncrona de fs.open (). |
43 | fs.utimes(path, atime, mtime, callback)
|
44 | fs.utimesSync(path, atime, mtime) Altere os carimbos de data / hora do arquivo referenciado pelo caminho fornecido. |
45 | fs.futimes(fd, atime, mtime, callback)
|
46 | fs.futimesSync(fd, atime, mtime) Altere os carimbos de data / hora de um arquivo referenciado pelo descritor de arquivo fornecido. |
47 | fs.fsync(fd, callback) Fsync assíncrono. Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. |
48 | fs.fsyncSync(fd) Fsync síncrono. |
49 | fs.write(fd, buffer, offset, length[, position], callback) Buffer de gravação no arquivo especificado por fd. |
50 | fs.write(fd, data[, position[, encoding]], callback) Grava dados no arquivo especificado por fd. Se os dados não forem uma instância do Buffer, o valor será forçado para uma string. |
51 | fs.writeSync(fd, buffer, offset, length[, position]) Versões síncronas de fs.write (). Retorna o número de bytes gravados. |
52 | fs.writeSync(fd, data[, position[, encoding]]) Versões síncronas de fs.write (). Retorna o número de bytes gravados. |
53 | fs.read(fd, buffer, offset, length, position, callback) Leia os dados do arquivo especificado por fd. |
54 | fs.readSync(fd, buffer, offset, length, position) Versão síncrona de fs.read. Retorna o número de bytesRead. |
55 | fs.readFile(filename[, options], callback) Lê de forma assíncrona todo o conteúdo de um arquivo. |
56 | fs.readFileSync(filename[, options]) Versão síncrona de fs.readFile. Retorna o conteúdo do nome do arquivo. |
57 | fs.writeFile(filename, data[, options], callback) Grava dados de maneira assíncrona em um arquivo, substituindo o arquivo se ele já existir. os dados podem ser uma string ou um buffer. |
58 | fs.writeFileSync(filename, data[, options]) A versão síncrona de fs.writeFile. |
59 | fs.appendFile(filename, data[, options], callback) Anexar dados de maneira assíncrona a um arquivo, criando o arquivo se ele não existir. os dados podem ser uma string ou um buffer. |
60 | fs.appendFileSync(filename, data[, options]) A versão síncrona de fs.appendFile. |
61 | fs.watchFile(filename[, options], listener) Observe as mudanças no nome do arquivo. O ouvinte de retorno de chamada será chamado sempre que o arquivo for acessado. |
62 | fs.unwatchFile(filename[, listener]) Pare de observar as mudanças no nome do arquivo. Se listener for especificado, apenas esse listener específico será removido. Caso contrário, todos os ouvintes serão removidos e você terá efetivamente parado de assistir a filename. |
63 | fs.watch(filename[, options][, listener]) Observe as mudanças no nome do arquivo, onde nome do arquivo é um arquivo ou um diretório. O objeto retornado é um fs.FSWatcher. |
64 | fs.exists(path, callback) Teste se o caminho fornecido existe ou não, verificando com o sistema de arquivos. Em seguida, chame o argumento de retorno de chamada com verdadeiro ou falso. |
65 | fs.existsSync(path) Versão síncrona de fs.exists. |
66 | fs.access(path[, mode], callback) Testa as permissões de um usuário para o arquivo especificado por caminho. mode é um número inteiro opcional que especifica as verificações de acessibilidade a serem realizadas. |
67 | fs.accessSync(path[, mode]) Versão síncrona de fs.access. Ele lança se alguma verificação de acessibilidade falhar e não faz nada de outra forma. |
68 | fs.createReadStream(path[, options]) Retorna um novo objeto ReadStream. |
69 | fs.createWriteStream(path[, options]) Retorna um novo objeto WriteStream. |
70 | fs.symlink(srcpath, dstpath[, type], callback) Link simbólico assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido ao retorno de chamada de conclusão. O argumento de tipo pode ser definido como 'dir', 'arquivo' ou 'junção' (o padrão é 'arquivo') e está disponível apenas no Windows (ignorado em outras plataformas). Observe que os pontos de junção do Windows exigem que o caminho de destino seja absoluto. Ao usar 'junção', o argumento de destino será normalizado automaticamente para o caminho absoluto. |