Système de fichiers Node.js
Node.js fournit un ensemble d'API d'opération de fichiers similaires aux normes UNIX (POSIX). La syntaxe du module de système de fichiers d'importation Node (fs) est la suivante :
var fs = require("fs")Asynchrone et synchrone
Les méthodes du module de système de fichiers Node.js (module fs) sont toutes deux asynchrones et la version synchrone, par exemple, les fonctions de lecture du contenu des fichiers incluent fs.readFile() asynchrone et fs.readFileSync() synchrone.
Le dernier paramètre de la fonction de méthode asynchrone est la fonction de rappel, et le premier paramètre de la fonction de rappel contient des informations d'erreur (erreur).
Il est recommandé d'utiliser des méthodes asynchrones Par rapport à la synchronisation, les méthodes asynchrones ont des performances plus élevées, une vitesse plus rapide et aucun blocage.
Exemple
Créez un fichier input.txt avec le contenu suivant :
php中文网官网地址：www.php.cn 文件读取实例
Créez un fichier file.js avec le code suivant :
var fs = require("fs");
// 异步读取
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("异步读取: " + data.toString());
});
// 同步读取
var data = fs.readFileSync('input.txt');
console.log("同步读取: " + data.toString());
console.log("程序执行完毕。");Le Les résultats de l'exécution du code ci-dessus sont les suivants ：
$ node file.js 同步读取: php中文网官网地址：www.php.cn 文件读取实例 程序执行完毕。 异步读取: php中文网官网地址：www.php.cn 文件读取实例
Ensuite, examinons de plus près la méthode du système de fichiers Node.js.
Ouvrir un fichier
Syntaxe
Voici le format de syntaxe pour ouvrir un fichier en mode asynchrone :
fs.open(path, flags[, mode], callback)
Paramètres
Les instructions d'utilisation des paramètres sont les suivantes :
path - le chemin du fichier.
drapeaux - Comportement d'ouverture de fichier. Voir ci-dessous pour les valeurs spécifiques.
mode - Définir le mode du fichier (autorisations). Les autorisations par défaut pour la création de fichiers sont 0666 (lecture, écriture).
callback - fonction de rappel, avec deux paramètres tels que : callback(err, fd).
Le paramètre flags peut avoir les valeurs suivantes :
| Flag | 描述 |
|---|---|
| r | 以读取模式打开文件。如果文件不存在抛出异常。 |
| r+ | 以读写模式打开文件。如果文件不存在抛出异常。 |
| rs | 以同步的方式读取文件。 |
| rs+ | 以同步的方式读取和写入文件。 |
| w | 以写入模式打开文件，如果文件不存在则创建。 |
| wx | 类似 'w'，但是如果文件路径存在，则文件写入失败。 |
| w+ | 以读写模式打开文件，如果文件不存在则创建。 |
| wx+ | 类似 'w+'， 但是如果文件路径存在，则文件读写失败。 |
| a | 以追加模式打开文件，如果文件不存在则创建。 |
| ax | 类似 'a'， 但是如果文件路径存在，则文件追加失败。 |
| a+ | 以读取追加模式打开文件，如果文件不存在则创建。 |
| ax+ | 类似 'a+'， 但是如果文件路径存在，则文件读取追加失败。 |
Exemple
Ensuite, nous créons le fichier file.js et ouvrons le fichier input.txt en lecture et en écriture. Le code est le suivant :
var fs = require("fs");
// 异步打开文件
console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("文件打开成功！");
});Le résultat de l'exécution du code ci-dessus. est la suivante :
$ node file.js 准备打开文件！ 文件打开成功！
Obtenir les informations sur le fichier
Syntaxe
Ce qui suit est le format de syntaxe pour obtenir des informations sur le fichier via le mode asynchrone :
fs.stat(path, callback)
Paramètres
Paramètres Les instructions d'utilisation sont les suivantes :
chemin - chemin du fichier.
callback - fonction de rappel, avec deux paramètres tels que : (err, stats), stats est un objet fs.Stats.
Une fois fs.stat(path) exécuté, l'instance de la classe stats sera renvoyée à sa fonction de rappel. Vous pouvez déterminer les attributs pertinents du fichier via les méthodes fournies dans la classe stats. Par exemple, pour déterminer s'il s'agit d'un fichier :
var fs = require('fs');
fs.stat('/Users/liuht/code/itbilu/demo/fs.js', function (err, stats) {
console.log(stats.isFile()); //true
})Les méthodes de la classe stats sont :
| 方法 | 描述 |
|---|---|
| stats.isFile() | 如果是文件返回 true，否则返回 false。 |
| stats.isDirectory() | 如果是目录返回 true，否则返回 false。 |
| stats.isBlockDevice() | 如果是块设备返回 true，否则返回 false。 |
| stats.isCharacterDevice() | 如果是字符设备返回 true，否则返回 false。 |
| stats.isSymbolicLink() | 如果是软链接返回 true，否则返回 false。 |
| stats.isFIFO() | 如果是FIFO，返回true，否则返回 false。FIFO是UNIX中的一种特殊类型的命令管道。 |
| stats.isSocket() | 如果是 Socket 返回 true，否则返回 false。 |
Exemple
Ensuite nous créons le fichier file.js, le code est le suivant :
var fs = require("fs");
console.log("准备打开文件！");
fs.stat('input.txt', function (err, stats) {
if (err) {
return console.error(err);
}
console.log(stats);
console.log("读取文件信息成功！");
// 检测文件类型
console.log("是否为文件(isFile) ? " + stats.isFile());
console.log("是否为目录(isDirectory) ? " + stats.isDirectory());
});Le résultat de l'exécution du code ci-dessus est le suivant :
$ node file.js
准备打开文件！
{ dev: 16777220,
mode: 33188,
nlink: 1,
uid: 501,
gid: 20,
rdev: 0,
blksize: 4096,
ino: 40333161,
size: 61,
blocks: 8,
atime: Mon Sep 07 2015 17:43:55 GMT+0800 (CST),
mtime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST),
ctime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST) }
读取文件信息成功！
是否为文件(isFile) ? true
是否为目录(isDirectory) ? falseÉcrire un fichier
Syntaxe
Voici le format de syntaxe pour écrire des fichiers en mode asynchrone :
fs.writeFile(filename, data[, options], callback)
Si le fichier existe, le contenu écrit par cette méthode sera écraser l'ancien contenu du fichier.
Paramètres
Les instructions d'utilisation des paramètres sont les suivantes :
chemin - chemin du fichier.
data - Les données à écrire dans le fichier, qui peuvent être un objet String (string) ou Buffer (stream).
options - Ce paramètre est un objet contenant {encoding, mode, flag}. L'encodage par défaut est utf8, le mode est 0666, le drapeau est 'w'
callback - fonction de rappel, la fonction de rappel ne contient que des paramètres d'informations d'erreur (err ), lors de l'écriture Renvoyé si la saisie échoue.
Exemple
Ensuite, nous créons le fichier file.js, le code est le suivant :
var fs = require("fs");
console.log("准备写入文件");
fs.writeFile('input.txt', '我是通过写入的文件内容！', function(err) {
if (err) {
return console.error(err);
}
console.log("数据写入成功！");
console.log("--------我是分割线-------------")
console.log("读取写入的数据！");
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("异步读取文件数据: " + data.toString());
});
});Le résultat de l'exécution du code ci-dessus est le suivant suit :
$ node file.js 准备写入文件 数据写入成功！ --------我是分割线------------- 读取写入的数据！ 异步读取文件数据: 我是通过写入的文件内容
Lire le fichier
Syntaxe
Voici le format de syntaxe pour lire les fichiers en mode asynchrone :
fs.read(fd, buffer, offset, length, position, callback)
Cette méthode utilise un descripteur de fichier à lire Récupérer le fichier.
Paramètres
Les instructions d'utilisation des paramètres sont les suivantes :
fd - le descripteur de fichier renvoyé par fs.open( ) méthode .
buffer - Le tampon dans lequel les données sont écrites.
offset - Le décalage d'écriture pour les écritures dans le tampon.
longueur - Le nombre d'octets à lire dans le fichier.
position - La position de départ de la lecture du fichier. Si la valeur de position est nulle, elle sera lue à partir de la position du pointeur de fichier actuel.
callback - fonction de rappel avec trois paramètres err, bytesRead, buffer err est le message d'erreur, bytesRead représente le nombre d'octets lus et buffer est le tampon. . objet.
Instance
le contenu du fichier input.txt est :
php中文网官网地址：www.php.cn
Ensuite, nous créons le fichier file.js, le code est le suivant :
var fs = require("fs");
var buf = new Buffer(1024);
console.log("准备打开已存在的文件！");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("文件打开成功！");
console.log("准备读取文件：");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
if (err){
console.log(err);
}
console.log(bytes + " 字节被读取");
// 仅输出读取的字节
if(bytes > 0){
console.log(buf.slice(0, bytes).toString());
}
});
});Le résultat de l'exécution du code ci-dessus est le suivant :
$ node file.js 准备打开已存在的文件！ 文件打开成功！ 准备读取文件： 42 字节被读取 php中文网官网地址：www.php.cn
Fermez le fichier
Syntaxe
Ce qui suit est le format de syntaxe pour la fermeture le fichier en mode asynchrone :
fs.close(fd, callback)
Cette méthode utilise un descripteur de fichier pour lire le fichier.
Paramètres
Les instructions d'utilisation des paramètres sont les suivantes :
fd - le descripteur de fichier renvoyé par fs.open( ) méthode .
callback - fonction de rappel, aucun paramètre.
Instance
le contenu du fichier input.txt est :
php中文网官网地址：www.php.cn
Ensuite, nous créons le fichier file.js, le code est le suivant :
var fs = require("fs");
var buf = new Buffer(1024);
console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("文件打开成功！");
console.log("准备读取文件！");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
if (err){
console.log(err);
}
// 仅输出读取的字节
if(bytes > 0){
console.log(buf.slice(0, bytes).toString());
}
// 关闭文件
fs.close(fd, function(err){
if (err){
console.log(err);
}
console.log("文件关闭成功");
});
});
});Le résultat de l'exécution du code ci-dessus est le suivant :
$ node file.js 准备打开文件！ 文件打开成功！ 准备读取文件！ php中文网官网地址：www.php.cn 文件关闭成功
Intercepter le fichier
Syntaxe
Ce qui suit est le format de syntaxe des fichiers d'interception en mode asynchrone :
fs.ftruncate(fd, len, callback)
Cette méthode utilise un descripteur de fichier pour lire le fichier.
Paramètres
Les instructions d'utilisation des paramètres sont les suivantes :
fd - le descripteur de fichier renvoyé par fs.open( ) méthode .
len - La durée de l'interception du contenu du fichier.
callback - fonction de rappel, aucun paramètre.
Instance
le contenu du fichier input.txt est :
site:www.php.cn
Ensuite, nous créons le fichier file.js, le code est le suivant :
var fs = require("fs");
var buf = new Buffer(1024);
console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("文件打开成功！");
console.log("截取10字节后的文件内容。");
// 截取文件
fs.ftruncate(fd, 10, function(err){
if (err){
console.log(err);
}
console.log("文件截取成功。");
console.log("读取相同的文件");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
if (err){
console.log(err);
}
// 仅输出读取的字节
if(bytes > 0){
console.log(buf.slice(0, bytes).toString());
}
// 关闭文件
fs.close(fd, function(err){
if (err){
console.log(err);
}
console.log("文件关闭成功！");
});
});
});
});Le résultat de l'exécution du code ci-dessus est le suivant :
$ node file.js 准备打开文件！ 文件打开成功！ 截取10字节后的文件内容。 文件截取成功。 读取相同的文件 site:www.r 文件关闭成功
Supprimer le fichier
Syntaxe
Ce qui suit est le format de syntaxe pour supprimer des fichiers :
fs.unlink(path, callback)
Paramètre
Les instructions d'utilisation du paramètre sont les suivantes :
chemin - chemin du fichier.
callback - fonction de rappel, aucun paramètre.
Instance
le contenu du fichier input.txt est :
site:www.php.cn
Ensuite, nous créons le fichier file.js, le code est le suivant :
var fs = require("fs");
console.log("准备删除文件！");
fs.unlink('input.txt', function(err) {
if (err) {
return console.error(err);
}
console.log("文件删除成功！");
});Le résultat de l'exécution du code ci-dessus est le suivant :
$ node file.js 准备删除文件！ 文件删除成功！
Vérifiez à nouveau le fichier input.txt et constatez qu'il n'existe plus.
Créer un répertoire
Syntaxe
Voici le format de syntaxe pour créer un répertoire :
fs.mkdir(path[, mode], callback)
Paramètres
Le les instructions d'utilisation des paramètres sont les suivantes :
path - chemin du fichier.
mode - Définissez les autorisations du répertoire, la valeur par défaut est 0777.
callback - fonction de rappel, aucun paramètre.
Exemple
Ensuite, nous créons le fichier file.js, le code est le suivant :
var fs = require("fs");
console.log("创建目录 /tmp/test/");
fs.mkdir("/tmp/test/",function(err){
if (err) {
return console.error(err);
}
console.log("目录创建成功。");
});Le résultat de l'exécution du code ci-dessus est le suivant suit :
$ node file.js 创建目录 /tmp/test/ 目录创建成功。
Lire le répertoire
Syntaxe
Voici le format de syntaxe pour lire le répertoire :
fs.readdir(path, callback)
Paramètres
Les instructions d'utilisation des paramètres sont les suivantes :
chemin - chemin du fichier.
callback - fonction de rappel, la fonction de rappel prend deux paramètres err, files, err est le message d'erreur et files est la liste des tableaux de fichiers dans le répertoire.
Exemple
Ensuite, nous créons le fichier file.js, le code est le suivant :
var fs = require("fs");
console.log("查看 /tmp 目录");
fs.readdir("/tmp/",function(err, files){
if (err) {
return console.error(err);
}
files.forEach( function (file){
console.log( file );
});
});Le résultat de l'exécution du code ci-dessus est le suivant suit :
$ node file.js 查看 /tmp 目录 input.out output.out test test.txt
Supprimer le répertoire
Syntaxe
Voici le format de syntaxe pour supprimer un répertoire :
fs.rmdir(path, callback)
Paramètres
Les instructions d'utilisation des paramètres sont les suivantes :
path - chemin du fichier.
callback - fonction de rappel, aucun paramètre.
Exemple
Ensuite, nous créons le fichier file.js, le code est le suivant :
var fs = require("fs");
console.log("准备删除目录 /tmp/test");
fs.rmdir("/tmp/test",function(err){
if (err) {
return console.error(err);
}
console.log("读取 /tmp 目录");
fs.readdir("/tmp/",function(err, files){
if (err) {
return console.error(err);
}
files.forEach( function (file){
console.log( file );
});
});
});Le résultat de l'exécution du code ci-dessus est le suivant suit :
$ node file.js 准备删除目录 /tmp/test input.out output.out test test.txt 读取 /tmp 目录 ……
Manuel de référence des méthodes du module de fichiers
Ce qui suit est une liste des mêmes méthodes dans le module de fichiers Node.js :
| Numéro de série | Méthode et description |
|---|---|
| 1 | fs.rename(oldPath , newPath, callback) Asynchronous rename(). La fonction de rappel n'a pas de paramètres, mais peut lever une exception. |
| 2 | fs.ftruncate(fd, len, callback) Ftruncate asynchrone(). mais peut lever une exception. |
| 3 | fs.ftruncateSync(fd, len) Sync ftruncate() |
| 4 | fs.truncate(path, len, callback) Asynchronous truncate() La fonction de rappel n'a pas de paramètres, mais peut lever une exception. |
| 5 | fs.truncateSync(path, len) Sync truncate() |
| 6 | fs.chown(path, uid, gid, callback) Asynchronous chown() La fonction de rappel n'a pas de paramètres, mais peut lever une exception. |
| 7 | fs.chownSync(path, uid, gid) Sync chown() |
| 8 | fs.fchown(fd, uid, gid, callback) Asynchrone fchown() La fonction de rappel n'a pas de paramètres, mais peut lever une exception. |
| 9 | fs.fchownSync(fd, uid, gid) Sync fchown() |
| 10 | fs.lchown(path, uid, gid, callback) Asynchronous lchown() La fonction de rappel n'a aucun paramètre, mais peut lever une exception. |
| 11 | fs.lchownSync(chemin, uid, gid) Sync lchown() |
| 12 | fs.chmod(path, mode, callback) Asynchronous chmod() La fonction de rappel n'a pas de paramètres, mais peut lever une exception. |
| 13 | fs.chmodSync(chemin, mode) Sync chmod(). |
| 14 | fs.fchmod(fd, mode, callback) Asynchrone fchmod() La fonction de rappel n'a aucun paramètre, mais peut lever une exception. |
| 15 | fs.fchmodSync(fd, mode) Sync fchmod(). |
| 16 | fs.lchmod(path, mode, callback) Asynchrone lchmod() La fonction de rappel n'a pas de paramètres, mais peut lever une exception. Uniquement disponible sur Mac OS X. |
| 17 | fs.lchmodSync (chemin, mode) > | 18
| fs.stat(path, callback) | Asynchronous stat() La fonction de rappel a deux paramètres err, stats, stats Est l'objet fs.Stats. | 19
| fs.lstat(path, callback) | Asynchrone lstat() La fonction de rappel a deux paramètres err, stats. , stats est l'objet fs.Stats. | 20
| fs.fstat(fd, callback) | Fstat() asynchrone a deux paramètres err, stats. , stats est l'objet fs.Stats. | 21
| fs.statSync(path) | Sync stat() Renvoie une instance de fs.Stats. | 22
| fs.lstatSync(path) | Synchroniser lstat(). | 23
| fs.fstatSync(fd) | Fstat() synchrone. Renvoie une instance de fs.Stats. |
| 24 | fs.link(srcpath, dstpath, callback) Lien asynchrone(). mais peut lever une exception. |
| 25 | fs.linkSync(srcpath, dstpath) Lien de synchronisation(). |
| 26 | fs.symlink(srcpath, dstpath[, type], callback) Asynchronous symlink() La fonction de rappel n'a aucun paramètre, mais peut lever une exception. . Le paramètre type peut être défini sur « dir », « file » ou « junction » (la valeur par défaut est « file »). |
| 27 | fs.symlinkSync(srcpath, dstpath[, type]) Sync symlink(). |
| 28 | fs.readlink(path, callback) Asynchronous readlink() La fonction de rappel a deux paramètres err, linkString. |
| 29 | fs.realpath(path[, cache], callback) realpath() asynchrone. Erreur de paramètres, chemin résolu. |
| 30 | fs.realpathSync(path[, cache]) Synchroniser realpath(). Renvoie le chemin absolu. |
| 31 | fs.unlink(path, callback) Asynchronous unlink() La fonction de rappel n'a pas de paramètres, mais peut. lancer anormal. |
| 32 | fs.unlinkSync(path) Sync unlink(). |
| 33 | fs.rmdir(path, callback) Asynchrone rmdir() La fonction de rappel n'a pas de paramètres, mais peut lever une exception. |
| 34 | fs.rmdirSync(chemin) Sync rmdir(). |
| 35 | fs.mkdir(path[, mode], callback) S mkdir(2) asynchrone La fonction de rappel n'a pas de paramètres, mais peut lever une exception. le mode par défaut est 0777. |
| 36 | fs.mkdirSync(path[, mode]) Sync mkdir(). |
| 37 | fs.readdir(path, callback) Asynchronous readdir(3). |
| 38 | fs.readdirSync(path) Synchronous readdir() Renvoie une liste de tableaux de fichiers. |
| 39 | fs.close(fd, callback) Asynchronous close() La fonction de rappel n'a pas de paramètres, mais peut. lancer anormal. |
| 40 | fs.closeSync(fd) Sync close(). |
| 41 | fs.open(path, flags[, mode], callback) Ouvrez le fichier de manière asynchrone. |
| 42 | fs.openSync(path, flags[, mode]) Version de synchronisation de fs.open(). |
| 43 | fs.utimes(path, atime, mtime, callback) |
| 44 | fs.utimesSync(path, atime, mtime) Modifiez l'horodatage du fichier et le fichier transmet le chemin de fichier spécifié. |
| 45 | fs.futimes(fd, atime, mtime, callback) |
| 46 | fs.futimesSync(fd, atime, mtime) Modifier l'horodatage du fichier, spécifié par le descripteur de fichier. |
| 47 | fs.fsync(fd, callback) Fsync asynchrone n'a pas de paramètres, mais peut lancer un fsync asynchrone. exception. |
| 48 | fs.fsyncSync(fd) Sync fsync. |
| 49 | fs.write(fd, buffer, offset, length[, position], callback) Écrivez le contenu du tampon dans le fichier spécifié par le descripteur de fichier. |
| 50 | fs.write(fd, data[, position[, encoding]], callback) via le descripteur de fichier fd écrit le contenu du fichier. |
| 51 | fs.writeSync(fd, buffer, offset, length[, position]) Version synchronisée de fs.write (). |
| 52 | fs.writeSync(fd, data[, position[, encoding]]) Version synchronisée de fs.write (). |
| 53 | fs.read(fd, buffer, offset, length, position, callback) via la description du fichier Le symbole fd lit le contenu du fichier. |
| 54 | fs.readSync(fd, buffer, offset, length, position) Version synchronisée de fs.read. |
| 55 | fs.readFile(filename[, options], callback) Lire le contenu du fichier de manière asynchrone. |
| 56 | fs.readFileSync(filename[, options])<br Version synchrone de fs.readfile.<="" td=""> |
| 57 | fs.writeFile(nom de fichier, données[, options], rappel) Écrivez le contenu du fichier de manière asynchrone. |
| 58 | fs.writeFileSync(filename, data[, options]) Version synchronisée de fs.writeFile. |
| 59 | fs.appendFile(filename, data[, options], callback) Ajouter le contenu du fichier de manière asynchrone. |
| 60 | fs.appendFileSync(filename, data[, options]) La version de synchronisation de fs.appendFile. |
| 61 | fs.watchFile(filename[, options], écouteur) Afficher les modifications du fichier. |
| 62 | fs.unwatchFile(filename[, listening]) Arrêtez d'afficher les modifications du nom de fichier. |
| 63 | fs.watch(filename[, options][, listener]) Afficher la modification du nom de fichier, le nom de fichier peut être un fichier ou un répertoire. Renvoie un objet fs.FSWatcher. |
| 64 | fs.exists(path, callback) Détecte si le chemin donné existe. |
| 65 | fs.existsSync(path) Version synchronisée de fs.exists. |
| 66 | fs.access(path[, mode], callback) Testez les autorisations utilisateur sur le chemin spécifié. |
| 67 | fs.accessSync(path[, mode]) Version synchrone de fs.access. |
| 68 | fs.createReadStream(path[, options]) Renvoie l'objet ReadStream. |
| 69 | fs.createWriteStream(path[, options]) Renvoie un objet WriteStream. |
| 70 | fs.symlink(srcpath, dstpath[, type], callback) Lien symbolique asynchrone(). paramètres de la fonction de rappel, mais peut lever une exception. |
Pour plus d'informations, veuillez consulter la description du module de fichiers du site officiel : Système de fichiers.
