1. Analyse d'ouverture
Le module du système de fichiers est un simple ensemble emballé de méthodes d'opération d'E / S de fichiers POSIX standard. Le module peut être obtenu en appelant requis ("fs"). Toutes les méthodes du module du système de fichiers sont disponibles en versions asynchrones et synchrones.
(1) La méthode asynchrone du module du système de fichiers nécessite une fonction de rappel terminée comme le dernier paramètre formel entrant.
(2) La composition de la fonction de rappel est déterminée par la méthode asynchrone appelée. Généralement, le premier paramètre formel de la fonction de rappel est le message d'erreur renvoyé.
(3) Si l'opération asynchrone est exécutée correctement et revient, le paramètre formel d'erreur est nul ou non défini. Si vous utilisez la version synchrone de la méthode d'opération, une fois qu'une erreur se produit, une erreur sera renvoyée sous la forme habituelle de lancer une erreur.
(4) Vous pouvez utiliser des instructions d'essayer pour intercepter les erreurs et faire continuer le programme.
Regardons d'abord un exemple simple, lisons le fichier ("bb.txt"):
(1) Créez le fichier "bb.txt", comme suit ("Bonjour à tous, je suis NOBITA! (* ^ __ ^ *) hehe ...").
(2), lisez l'opération de fichier comme suit:
La copie de code est la suivante:
var fs = require ("fs");
fs.readfile ("bb.txt", "utf8", fonction (erreur, données) {
if (erreur) lancer une erreur;
console.log (données);
});
Résultats en cours:
Ce que vous devez noter ici est: vous devez définir le codage lors de la lecture des fichiers, sinon le formulaire par défaut apparaîtra dans "Buffer".
En regardant l'effet de course qui n'est pas défini, la différence est toujours très évidente. comme suit:
Une autre opération d'écriture, comme suit:
La copie de code est la suivante:
var fs = require ("fs");
var txt = "Tout le monde devrait apprendre Nodejs !!!" ;
// Écrivez dans le fichier
fs.writeFile ("bb.txt", txt, fonction (err) {
si (err) jetez ERR;
console.log ("Fichier enregistré!"); // Le fichier est enregistré
});
Résultats en cours:
Voici quelques exemples courants:
La copie de code est la suivante:
// Supprimer le fichier
fs.unlink ('bb.txt', fonction () {
console.log («succès»);
});
// modifie le nom du fichier
fs.rename ('bb.txt', 'bigbear.txt', fonction (err) {
Console.log («Renommer le succès»);
});
// Vérifiez l'état du fichier
fsat ('bb.txt', fonction (err, stat) {
console.log (stat);
});
// déterminer si le fichier existe
fs.exists ('bb.txt', fonction (existe) {
console.log (existe);
});
2. La connexion entre FS et Stream
"Stream" a des fonctionnalités asynchrones. Puis-je diviser un fichier ou un morceau de contenu en "morceaux" inconnus et le lire, et chaque fois qu'un "morceau" est lu, nous le sortons. Jusqu'à ce que le fichier soit terminé. C'est comme "Transfert-Encoding: Chunked" Soutenu par "HTTP1.1". ("Chunk" peut exister sous n'importe quelle forme, NodeJS existe sous la forme de "tampon" par défaut, ce qui est plus efficace). "Stream" dans NodeJS a une fonction Super sur les systèmes UNIX, qui est ("Pipe" ------ Pipeline).
Vous souvenez-vous encore du premier programme Nodejs "Bonjour, Big Bear!"? Nous apportons quelques modifications basées sur l'applet, comme suit:
(1), créez "bb.html"
La copie de code est la suivante:
<html>
<adal>
<style type = "text / css">
div {
marge: 50px;
Largeur: 100%;
marge: 0px;
hauteur: 120px;
hauteur de ligne: 120px;
Couleur: #ffff;
taille de police: 22px;
Contexte: # FF9900;
Texte-aligne: Centre;
}
</ style>
</ head>
<body>
<div> Bonjour, Big Bear! </div>
</docy>
</html>
(2), modifiez le programme précédent comme suit:
La copie de code est la suivante:
var http = require ('http');
var fs = require ("fs");
var server = http.createServer (fonction (req, res) {
fs.readfile ("bb.html", "utf-8", fonction (err, data) {
if (err) {
res.writehead (500, {'context-type': 'text / plain'});
res.end ('Spécifier le fichier n'existe pas! ou l'erreur de serveur!');
}
autre{
res.writehead (200, {'context-type': 'text / html'});
res.write (données);
res.end ();
}
})
});
server.Listen (8888);
console.log ("Http Server fonctionnant sur le port 8888 ...");
Voici les résultats en cours:
Maintenant, nous devons y penser, si nous envoyons non un fichier texte simple mais un fichier hypermédia, tel que le fichier vidéo HD complet de la conférence IO Google 2014. Format MP4. La longueur est supérieure à 2 heures 1080p.
Environ 4 Go. La façon dont "Readfile" est connu pour fonctionner est de lire les fichiers dans la mémoire. Alors un fichier aussi important ne peut évidemment pas être fait. Alors que dois-je faire? Après cela, vous devez utiliser Stream pour le faire. Alors c'est tout.
Le code est le suivant:
La copie de code est la suivante:
fs.createadStream (__ dirname + '/vedio.mp4' ).pipe(res);
Pour résumer:
Ces codes peuvent implémenter les fonctions requises, mais le service doit mettre en mémoire l'ensemble des données de fichier avant d'envoyer les données du fichier, si le fichier "bb.html" est très
S'il est grand et a une grande concurrence, beaucoup de mémoire sera gaspillée. Étant donné que l'utilisateur doit attendre que l'ensemble du fichier soit mis en cache en mémoire pour accepter les données du fichier, cela conduit à
L'expérience utilisateur est assez mauvaise. Heureusement, les deux paramètres "(req, res)" sont du flux, nous pouvons donc utiliser fs.creareAdStream () au lieu de "fs.readfile ()".
Trois, des exemples
Venez télécharger un fichier:
(1) Créer "Server.js"
La copie de code est la suivante:
var http = require ('http');
var url = require ('url');
Fonction Start (route, gestionnaire) {
fonction onRequest (demande, réponse) {
var pathname = url.parse (request.url) .pathname;
// Itinéraire vers la logique commerciale correspondante
Route (chemin d'accès, gestionnaire, réponse, demande);
}
http.createServer (onRequest) .Listen (3000);
console.log («Server est démarré»);
}
export.start = start;
(2) Créer "Route.js"
La copie de code est la suivante:
Route de fonction (cheminement, gestionnaire, réponse, demande) {
console.log ('sur le point d'acheter une demande pour' + pathname);
if (typeof handler [pathname] === 'fonction') {
return handler [pathname] (réponse, demande);
} autre {
Console.log ('Aucun gestionnaire de demande trouvé pour' + pathname);
Response.WriteHead (404, {'Content-Type': 'Text / Html'});
Response.Write ('404 introuvable!');
réponse.end ();
}
}
export.Route = Route;
(3) Créer "RequestHandler.js"
La copie de code est la suivante:
var queRyString = require ('QueryString'),
fs = require ('fs'),
formidable = requis ('formidable');
fonction start (réponse, demande) {
console.log («Module de démarrage»);
var body = '<html>' +
'<adhead>' +
'<méta http-equiv = "contenu-type"' +
'content = "text / html; charset = utf-8" />' +
'</ head>' +
'<body>' +
'<form action = "/ upload" encType = "multipart / form-data" méthode = "post">' +
'<input type = "file" name = "upload" multiple = "multiple">' +
'<input type = "soumi" value = "soumettre le texte" />' +
'</form>' +
'</body>' +
'</html>';
Response.WriteHead (200, {'Content-Type': 'Text / Html'});
Response.Write (corps);
réponse.end ();
}
Fonction Téléchargement (réponse, demande) {
console.log («module de téléchargement»);
var form = new formidable.incomingform ();
Form.Parse (demande, fonction (erreur, champs, fichiers) {
fs.renamesync (files.upload.path, '/tmp/test.png');
Response.WriteHead (200, {'Content-Type': 'Text / Html'});
réponse.write ('vous /' ve a envoyé: <br /> ');
réponse.write ('<img src = "/ show" />');
réponse.end ();
});
}
fonction show (réponse, demande) {
Console.log ('MODULE AFFICHER');
fs.readfile ('/tmp/test.png', 'binaire', fonction (erreur, fichier) {
if (error) {
Response.WriteHead (200, {'Content-Type': 'Text / Html'});
Response.Write (erreur);
réponse.end ();
} autre {
Response.WriteHead (200, {'Content-Type': 'Image / Png'});
réponse.write (fichier, «binaire»);
réponse.end ();
}
});
}
export.start = start;
exports.upload = upload;
export.show = show;
(4) Créer "index.js"
La copie de code est la suivante:
var server = require ('./ server');
var routeur = require ('./ routeur');
var requestHandler = require ('./ requestHandler');
var formidable = require ('formidable'); // nécessite un algorithme de recherche de chemin? ?
var handler = {};
handler ['/'] = requesthandler.start;
handler ['/ start'] = requesthandler.start;
handler ['/ upload'] = requestHandler.upload;
handler ['/ show'] = requestHandler.show;
server.start (router.route, gestionnaire);
Quatre, résumons
(1) Comprendre la "connexion entre FS et Stream".
(2) compétent dans l'utilisation des API liées à "FS".
(3) Faites attention aux détails, tels que: les détails de traitement entre la méthode de synchronisation de l'API de l'opération de fichier et la méthode asynchrone.
(4), et enfin souligner: comprendre la méthode de l'organisation du code dans des exemples de téléchargement de fichiers, constamment refactor et résumer constamment.