1. Öffnungsanalyse
Das Dateisystemmodul ist ein einfacher verpackter Satz von Standard -POSIX -Datei -E/A -Betriebsmethoden. Das Modul kann durch Aufrufen von Anforderungen erhalten werden ("fs"). Alle Methoden im Dateisystemmodul sind in asynchronen und synchronen Versionen verfügbar.
(1) Die asynchrone Methode im Dateisystemmodul erfordert eine ausgefüllte Rückruffunktion als den letzten eingehenden formalen Parameter.
(2) Die Zusammensetzung der Rückruffunktion wird durch die genannte asynchrone Methode bestimmt. Im Allgemeinen ist der erste formale Parameter der Rückruffunktion die zurückgegebene Fehlermeldung.
(3) Wenn die asynchrone Operation korrekt ausgeführt wird und zurückgibt, ist der formale formale Parameter null oder undefiniert. Wenn Sie die synchrone Version der Betriebsmethode verwenden, wird ein Fehler nach dem Auftreten eines Fehlers in der üblichen Form des Werfens eines Fehlers zurückgegeben.
(4) Sie können versuchen, Aussagen zu fangen, um Fehler abzufangen und das Programm fortzusetzen.
Schauen wir uns zunächst ein einfaches Beispiel an, lesen Sie die Datei ("BB.TXT"):
(1) Erstellen Sie die Datei "bb.txt" wie folgt ("Hallo allerseits, ich bin nobita! (*^__^*) hehe ...").
(2) Lesen Sie die Dateioperation wie folgt vor:
Die Codekopie lautet wie folgt:
var fs = require ("fs");
fs.ReadFile ("Bb.txt", "Utf8", Funktion (Fehler, Daten) {
Wenn (Fehler) Fehler werfen;
console.log (Daten);
});
Auslaufergebnisse:
Was Sie hier beachten müssen, ist: Sie müssen die Codierung beim Lesen von Dateien festlegen, andernfalls wird das Standardformular in "Puffer" angezeigt.
Wenn man den nicht festgelegten Laufeffekt betrachtet, ist der Unterschied immer noch sehr offensichtlich. wie folgt:
Eine weitere Schreiboperation wie folgt:
Die Codekopie lautet wie folgt:
var fs = require ("fs");
var txt = "Jeder sollte Nodejs lernen !!!" ;
// in Datei schreiben
fs.writeFile ("Bb.txt", txt, function (err) {
Wenn (err) erröste;
console.log ("Datei gespeichert!"); // Die Datei wird gespeichert
});
Auslaufergebnisse:
Hier sind einige häufige Beispiele:
Die Codekopie lautet wie folgt:
// die Datei löschen
fs.unlink ('bb.txt', function () {
console.log ('Erfolg');
});
// den Dateinamen ändern
fs.rename ('bb.txt', 'bigbear.txt', function (err) {
console.log ('Erfolg umbenennen');
});
// Dateistatus überprüfen
fs.Stat ('bb.txt', function (err, stat) {
console.log (STAT);
});
// Bestimmen Sie, ob die Datei existiert
fs. exists ('bb.txt', function (existiert) {{
console.log (existiert);
});
2. Die Verbindung zwischen FS und Stream
"Stream" hat asynchrone Funktionen. Kann ich eine Datei oder ein Inhalt in unbekannte "Stücke" teilen und sie lesen, und jedes Mal, wenn ein "Chunk" gelesen wird, geben wir sie aus. Bis die Datei fertig ist. Dies ist wie "Transfer-Coding: Chunked" unterstützt von "http1.1". ("Chunk" kann in jeder Form existieren. NodeJs existieren standardmäßig in Form von "Puffer", was effizienter ist). "Stream" in NodeJS hat eine Superfunktion auf UNIX-Systemen, nämlich ("Pipe" ------ Pipeline).
Erinnerst du dich noch an das erste NodeJS -Programm "Hallo, Big Bear!"? Wir stellen einige Änderungen an, die auf dem Applet basieren, wie folgt:
(1) erstellen "Bb.html"
Die Codekopie lautet wie folgt:
<html>
<kopf>
<style type = "text/css">
div {
Rand: 50px;
Breite: 100%;
Rand: 0px;
Höhe: 120px;
Zeilenhöhe: 120px;
Farbe: #ffff;
Schriftgröße: 22px;
Hintergrund:#ff9900;
Text-Align: Mitte;
}
</style>
</head>
<body>
<div> Hallo, Big Bear! </div>
</body>
</html>
(2) ändern Sie das vorherige Programm wie folgt:
Die Codekopie lautet wie folgt:
var http = required ('http');
var fs = require ("fs");
var server = http.createServer (Funktion (req, res) {
fs
if (err) {
res.writeHead (500, {'context-type': 'text/plain'});
res.end ('Datei nicht angeben! oder Serverfehler!');
}
anders{
res.writeHead (200, {'context-type': 'text/html'});
Res.Write (Daten);
res.end ();
}
})
});
Server.Listen (8888);
console.log ("HTTP -Server, der auf Port 8888 ausgeführt wird ...");
Das Folgende sind die laufenden Ergebnisse:
Jetzt müssen wir darüber nachdenken, wenn wir keine einfache Textdatei, sondern eine Hypermedia -Datei senden, z. B. die vollständige HD -Videodatei der Google 2014 IO -Konferenz. MP4 -Format. Die Länge beträgt über 2 Stunden 1080p.
Ca. 4 GB. Die Art und Weise, wie "ReadFile" funktioniert, besteht darin, Dateien in den Speicher zu lesen. Dann kann eine so große Datei offensichtlich nicht durchgeführt werden. Also, was soll ich tun? Danach müssen Sie Stream verwenden, um dies zu tun. Also das war's.
Der Code ist wie folgt:
Die Codekopie lautet wie folgt:
fs.createadstream (__ Dirname + '/vedio.mp4').pipe(res);
Zusammenfassen:
Diese Codes können die erforderlichen Funktionen implementieren, aber der Dienst muss die gesamten Dateidaten vor dem Senden der Dateidaten zwischenspeichern
Wenn es groß ist und eine große Parallelität aufweist, wird viel Gedächtnis verschwendet. Da der Benutzer warten muss, bis die gesamte Datei in den Speicher entfernt ist, um die Dateidaten zu akzeptieren, führt dies zu
Die Benutzererfahrung ist ziemlich schlecht. Glücklicherweise sind beide Parameter "(req, res)" Stream, sodass wir fs.createadstream () anstelle von "fs.ReadFile ()" verwenden können.
Drei Beispiele
Kommen Sie, um eine Datei hochzuladen:
(1) erstellen "server.js"
Die Codekopie lautet wie folgt:
var http = required ('http');
var url = erfordern ('url');
Funktionsstart (Route, Handler) {
Funktion OnRequest (Anfrage, Antwort) {
var pathname = url.parse (request.url) .PathName;
// Route zur entsprechenden Geschäftslogik
Route (Pathname, Handler, Antwort, Anfrage);
}
http.createServer (OnRequest) .Listen (3000);
console.log ('Server startet');
}
exports.Start = start;
(2) Erstellen "Route.js"
Die Codekopie lautet wie folgt:
Funktionsroute (Pathname, Handler, Antwort, Anfrage) {
console.log ('kurz vor der Route einer Anfrage nach' + pathname);
if (typeof Handler [Pathname] === 'Funktion') {
Return Handler [Pathname] (Antwort, Anfrage);
} anders {
console.log ('kein Anfrage -Handler für' + pathname);
response.writeHead (404, {'content-type': 'text/html'});
Antwort.Write ('404 nicht gefunden!');
Antwort.end ();
}
}
Exports.Route = Route;
(3) erstellen "RequestHandler.js"
Die Codekopie lautet wie folgt:
var queryString = Request ('queryString'),
fs = erfordern ('fs'),
faszinierbar = require ('fordiable');
Funktion start (Antwort, Anfrage) {
console.log ('startmodul');
var body = '<html>'+
'<kopf>'+
'<meta http-äquiv = "content-type"'+
'content = "text /html; charSet = utf-8" />'+
'</head>'+
'<body>'+
'<form action = "/upload" engType = "MultiPart/Form-Data" methode = "post">'+
'<Eingabe type = "Datei" name = "hochladen" multiple = "multiple">'+
'<input type = "value =" text " />'+ reichen
'</form>'+
'</body>'+
'</html>';
response.writeHead (200, {'content-type': 'text/html'});
Antwort.Write (Körper);
Antwort.end ();
}
Funktion hochladen (Antwort, Anfrage) {
console.log ('Upload -Modul');
var form = new formidable.incomingForm ();
Form.Parse (Anfrage, Funktion (Fehler, Felder, Dateien) {
fs.renamesync (Dateien.Upload.Path, '/tmp/test.png');
response.writeHead (200, {'content-type': 'text/html'});
response.write ('du /' ve gesendet: <br /> ');
Antwort.Write ('<img src = " /show" />');
Antwort.end ();
});
}
Funktionshow (Antwort, Anfrage) {
console.log ('show modul');
fs
if (Fehler) {
response.writeHead (200, {'content-type': 'text/html'});
Antwort.Write (Fehler);
Antwort.end ();
} anders {
response.writeHead (200, {'content-type': 'image/png'});
response.write (Datei, 'binär');
Antwort.end ();
}
});
}
exports.Start = start;
exports.Upload = Upload;
exports.show = show;
(4) erstellen "index.js"
Die Codekopie lautet wie folgt:
var server = required ('./ server');
var router = required ('./router');
var RequestHandler = Request ('./ RequestHandler');
var formidable = required ('foridable'); // Pfadsuchalgorithmus benötigen? ?
var Handler = {};
Handler ['/'] = RequestHandler.Start;
Handler ['/start'] = RequestHandler.Start;
Handler ['/Upload'] = RequestHandler.Upload;
Handler ['/show'] = RequestHandler.show;
server.start (Router.Route, Handler);
Vier, lasst uns zusammenfassen
(1) Verstehen Sie die "Verbindung zwischen FS und Stream".
(2) In der Verwendung von "fs" -Ante-APIs.
(3) Achten Sie auf die Details, wie z.
(4) und schließlich betonen: Verstehen Sie die Code -Organisationsmethode in Beispielen für Datei -Upload, ständig Refactor und fassen ständig zusammen.