1. Análisis de apertura
El módulo del sistema de archivos es un conjunto simple empaquetado de métodos de operación de E/S de archivo POSIX estándar. El módulo se puede obtener llamando a requerir ("fs"). Todos los métodos en el módulo del sistema de archivos están disponibles en versiones asincrónicas y sincrónicas.
(1) El método asincrónico en el módulo del sistema de archivos requiere una función de devolución de llamada completa como el último parámetro formal entrante.
(2) La composición de la función de devolución de llamada está determinada por el método asincrónico llamado. En general, el primer parámetro formal de la función de devolución de llamada es el mensaje de error devuelto.
(3) Si la operación asincrónica se ejecuta correctamente y devuelve, el parámetro formal de error es nulo o indefinido. Si está utilizando la versión sincrónica del método de operación, una vez que ocurra un error, se devolverá un error en la forma habitual de lanzar un error.
(4) Puede usar las declaraciones de prueba y atrapar para interceptar errores y hacer que el programa continúe.
Primero veamos un ejemplo simple, lea el archivo ("bb.txt"):
(1) Cree el archivo "bb.txt", como sigue ("¡Hola a todos, soy nobita! (*^__^*) jeje ...").
(2), lea la operación del archivo de la siguiente manera:
La copia del código es la siguiente:
var fs = require ("fs");
fs.ReadFile ("bb.txt", "utf8", function (error, data) {
if (error) tirar error;
console.log (datos);
});
Resultados de ejecución:
Lo que debe tener en cuenta aquí es: debe establecer la codificación al leer archivos, de lo contrario, el formulario predeterminado aparecerá en "Buffer".
Mirando el efecto de ejecución que no está establecido, la diferencia sigue siendo muy obvia. como sigue:
Otra operación de escritura, como sigue:
La copia del código es la siguiente:
var fs = require ("fs");
var txt = "¡Todos deberían aprender NodeJs!" ;
// escribir en el archivo
fs.WriteFile ("bb.txt", txt, function (err) {
if (err) tirar err;
console.log ("Archivo guardado!"); // El archivo se guarda
});
Resultados de ejecución:
Aquí hay algunos ejemplos comunes:
La copia del código es la siguiente:
// eliminar el archivo
fs.unlink ('bb.txt', function () {
console.log ('éxito');
});
// modificar el nombre del archivo
fs.Rename ('bb.txt', 'bigbear.txt', function (err) {
console.log ('renombrar el éxito');
});
// Verifique el estado del archivo
fs.stat ('bb.txt', function (err, stat) {
console.log (stat);
});
// determinar si el archivo existe
fs.exists ('bb.txt', function (exists) {
console.log (existe);
});
2. La conexión entre FS y Stream
"Stream" tiene características asíncronas. ¿Puedo dividir un archivo o una pieza de contenido en "trozos" desconocidos y leerlo, y cada vez que se lee un "trozo", lo generamos? Hasta que el archivo esté terminado. Esto es como "codificación de transferencia: fragmentada" compatible con "http1.1". ("Fragmento" puede existir en cualquier forma, NodeJs existe en forma de "búfer" de forma predeterminada, lo cual es más eficiente). "Stream" en NodeJs tiene una súper característica en los sistemas UNIX, que es ("tubería" ------ tubelina).
¿Todavía recuerdas el primer programa NodeJS "¡Hola, Big Bear!"? Hacemos algunas modificaciones basadas en el applet, como sigue:
(1), cree "bb.html"
La copia del código es la siguiente:
<html>
<Evista>
<style type = "text/css">
div {
margen-top: 50px;
Ancho: 100%;
margen: 0px;
Altura: 120px;
Línea de altura: 120px;
Color: #ffff;
tamaño de fuente: 22px;
Antecedentes:#FF9900;
Text-Align: Center;
}
</style>
</ablo>
<Body>
<Div> ¡Hola, Big Bear! </div>
</body>
</html>
(2), modifique el programa anterior de la siguiente manera:
La copia del código es la siguiente:
var http = require ('http');
var fs = require ("fs");
var server = http.createServer (function (req, res) {
fs.ReadFile ("bb.html", "utf-8", function (err, data) {
if (err) {
res.writehead (500, {'context-type': 'text/sencillo'});
res.end ('Especifique el archivo que no existe! ¡O error del servidor!');
}
demás{
res.writehead (200, {'context-type': 'text/html'});
res.write (datos);
res.end ();
}
})
});
servidor.listen (8888);
console.log ("servidor HTTP que se ejecuta en el puerto 8888 ...");
Los siguientes son los resultados de ejecución:
Ahora tenemos que pensar en ello, si no estamos enviando un archivo de texto simple sino un archivo de HyperMedia, como el archivo de video Full HD de la conferencia IO de Google 2014. Formato MP4. La longitud es de más de 2 horas 1080p.
Alrededor de 4 GB. La forma en que se sabe que "ReadFile" funciona es leer archivos en la memoria. Entonces un archivo tan grande obviamente no se puede hacer. Entonces, ¿qué debo hacer? Después de eso, debe usar la transmisión para hacerlo. Entonces eso es todo.
El código es el siguiente:
La copia del código es la siguiente:
fs.CreateReadStream (__ dirname + '/vedio.mp4').pipe(res);
Para resumir:
Estos códigos pueden implementar las funciones requeridas, pero el servicio debe almacenar en caché los datos completos de la memoria antes de enviar los datos del archivo, si el archivo "bb.html" es muy
Si es grande y tiene una gran concurrencia, se desperdiciará mucha memoria. Debido a que el usuario debe esperar hasta que todo el archivo esté en caché a la memoria para aceptar los datos del archivo, esto lleva a
La experiencia del usuario es bastante mala. Afortunadamente, ambos parámetros "(REQ, RES)" son transmisión, por lo que podemos usar fs.CreateReadStream () en lugar de "fs.ReadFile ()".
Tres, ejemplos
Ven a subir un archivo:
(1) Crear "server.js"
La copia del código es la siguiente:
var http = require ('http');
var url = require ('url');
Function Start (Route, Handler) {
function OnRequest (solicitud, respuesta) {
var rathName = url.Parse (request.url) .pathname;
// Ruta a la lógica comercial correspondiente
ruta (ruta, nombre, controlador, respuesta, solicitud);
}
http.createServer (OnRequest) .listen (3000);
console.log ('el servidor está comenzando');
}
exports.start = inicio;
(2) Crear "ruta.js"
La copia del código es la siguiente:
ruta de funciones (rationName, manejador, respuesta, solicitud) {
console.log ('a punto de enrutar una solicitud para' + rathName);
if (typeOf Handler [PathName] === 'function') {
Handler de retorno [PathName] (respuesta, solicitud);
} demás {
console.log ('No se encontró controlador de solicitud para' + rathName);
Response.Writehead (404, {'Content-type': 'text/html'});
respuesta.write ('404 no encontrado!');
respuesta.end ();
}
}
exports.route = ruta;
(3) Crear "requesthandler.js"
La copia del código es la siguiente:
var QueryString = require ('QueryString'),
fs = requerir ('fs'),
formidable = require ('formidable');
Function Start (respuesta, solicitud) {
console.log ('módulo de inicio');
var cuerpo = '<html>'+
'<head>'+
'<meta http-equiv = "content-type"'+
'content = "text /html; charset = utf-8" />'+
'</head>'+
'<body>'+
'<Form Action = "/upload" enctype = "multipart/form-data" método = "post">'+
'<input type = "file" name = "upload" múltiple = "múltiple">'+
'<input type = "enviar" valor = "enviar texto" />'+
'</form>'+
'</body>'+
'</html>';
Response.Writehead (200, {'Content-type': 'Text/html'});
respuesta.write (cuerpo);
respuesta.end ();
}
Function upload (respuesta, solicitud) {
console.log ('módulo de carga');
var Form = new Formidable.InComingForm ();
Form.Parse (solicitud, función (error, campos, archivos) {
fs.Renamesync (files.upload.path, '/tmp/test.png');
Response.Writehead (200, {'Content-type': 'Text/html'});
Response.write ('You /' ha enviado: <Br /> ');
Response.Write ('<img src = " /show" />');
respuesta.end ();
});
}
FUNCIÓN SHOW (respuesta, solicitud) {
console.log ('show módulo');
fs.ReadFile ('/tmp/test.png', 'binary', function (error, archivo) {
if (error) {
Response.Writehead (200, {'Content-type': 'Text/html'});
respuesta.write (error);
respuesta.end ();
} demás {
Response.Writehead (200, {'Content-type': 'Image/png'});
Response.write (archivo, 'binario');
respuesta.end ();
}
});
}
exports.start = inicio;
exports.upload = cargar;
exports.show = show;
(4) Crear "index.js"
La copia del código es la siguiente:
var ser servidor = request ('./ servidor');
var enrutador = require ('./ Router');
var requestHandler = require ('./ requestHandler');
var formidable = request ('formidable'); // requiere algoritmo de búsqueda de ruta? ?
Var Handler = {};
Handler ['/'] = requestHandler.Start;
Handler ['/Start'] = requestHandler.Start;
Handler ['/upload'] = requestHandler.upload;
Handler ['/show'] = requestHandler.show;
servidor.start (router.route, manejador);
Cuatro, resumamos
(1) Comprenda la "conexión entre FS y Stream".
(2) Competente en el uso de API relacionadas con "FS".
(3) Preste atención a los detalles, tales como: Los detalles de procesamiento entre el método de sincronización API de operación de archivo y el método asincrónico.
(4), y finalmente enfatice: Comprenda el método de organización del código en ejemplos de carga de archivos, refactor constantemente y resume constantemente.