Módulo de búfer
JS fue diseñado originalmente para navegadores, por lo que puede manejar bien las cadenas codificadas por Unicode, pero no puede manejar bien los datos binarios. Este es un problema con Node.js, porque Node.js está diseñado para enviar y recibir datos que a menudo se transmiten en formato binario en la red. Por ejemplo:
- Enviar y recibir datos a través de la conexión TCP;
- Lea datos binarios de imágenes o archivos comprimidos;
- leer y escribir datos del sistema de archivos;
- Procesar flujos de datos binarios desde la red
El módulo de búfer trae un método a Node.js para almacenar datos sin procesar, por lo que los datos binarios se pueden usar en el contexto de JS. Cada vez que los datos se mueven en las operaciones de E/S deben procesarse en Node.js, es posible usar el módulo de búfer.
Clase: búfer
La clase de búfer es un tipo de variable global utilizado para procesar directamente los datos binarios. Se puede construir de varias maneras.
Los datos sin procesar se guardan en una instancia de la clase de búfer. Una instancia de búfer es similar a una matriz de enteros
1. NUEVO búfer (tamaño): asigne un nuevo tamaño de búfer de 8 bits cuyo tamaño es el tamaño.
2. NUEVO búfer (matriz): asigne un nuevo búfer para usar una matriz de bytes de 8 bits.
3. Niew Buffer (STR, [Codificación]): Codificación de la cadena Tipo de cadena El método de codificación se utiliza, y los parámetros son opcionales.
4. Método de clase: buffer.isEncoding (codificación): return true Si la codificación de codificación dada es válida, de lo contrario, devuelve falso.
5. Método de clase: buffer.isbuffer (OBJ): prueba si este OBJ es un amortiguador. Devuelve booleano
6. Método de clase: buffer.concat (list, [totallength]): list {array} Tipo de matriz, matriz de búfer, solía estar conectado. Totallength {Número} Tamaño total Tamaño de todos los búferes de la matriz de búfer anterior.
Además de leer archivos para obtener instancias de búfer, también se puede construir directamente, por ejemplo:
La copia del código es la siguiente:
var bin = nuevo búfer ([0x48, 0x65, 0x6c, 0x6c, 0x6c]);
El búfer es similar a una cadena. Además de usar el atributo .length para obtener la longitud de los bytes, también puede usar el método [índice] para leer los bytes en la posición especificada, por ejemplo:
La copia del código es la siguiente:
bin [0]; // => 0x48;
El búfer y la cadena se pueden convertir entre sí, por ejemplo, los datos binarios se pueden convertir en cadenas utilizando una codificación especificada:
La copia del código es la siguiente:
var str = bin.ToString ('utf-8'); // => "Hola"
En lugar de devolver un nuevo búfer, el método .lice devuelve un puntero a una ubicación en el medio del búfer original, como se muestra a continuación.
La copia del código es la siguiente:
1. [0x48, 0x65, 0x6c, 0x6c, 0x6c]
2. ^ ^
3. | |
4. Bin bin.lice (2)
Escribe en el búfer
La copia del código es la siguiente:
var buffer = new Buffer (8); // Crear un búfer con 8 bytes de memoria asignados
console.log (buffer.write ('a', 'utf8')); // Salida 1
Esto escribirá el personaje "A" en el búfer, y el nodo devuelve el número de bytes escritos al búfer después de ser codificado. La codificación UTF-8 de la letra A aquí ocupa 1 byte.
Búfer de copia
Node.js proporciona un método para copiar todo el contenido del objeto de búfer en otro objeto de búfer. Solo podemos copiar entre los objetos de búfer existentes, por lo que tenemos que crearlos.
La copia del código es la siguiente:
buffer.copy (buffertoCopyto)
Entre ellos, BuffertoCopy es el objeto de tampón objetivo que se copiará. El siguiente ejemplo:
La copia del código es la siguiente:
var buffer1 = nuevo búfer (8);
buffer1.write ('Encantado de conocerte', 'utf8');
var buffer2 = nuevo búfer (8);
buffer1.copy (buffer2);
console.log (buffer2.toString ()); // es bueno conocerte
Módulo de transmisión
En los sistemas operativos de tipo UNIX, la transmisión es un concepto estándar. Hay tres transmisiones principales de la siguiente manera:
1. Entrada estándar
2. Salida estándar
3. Errores estándar
Transmisión legible
Si el búfer es la forma en que Node.js maneja los datos sin procesar, entonces la secuencia suele ser la forma en que Node.js mueve los datos. Las transmisiones en Node.js son legibles o escritos. Muchos módulos en Node.js usan transmisiones, incluidos HTTP y sistemas de archivos.
Supongamos que creamos un archivo de clase.txt y leemos la lista de nombres para que podamos usar estos datos. Dado que los datos son un flujo, esto significa que antes de completar la lectura de archivos, puede actuar sobre los datos de los primeros bytes recibidos. Este es un patrón común en Node.js:
La copia del código es la siguiente:
var fs = require ('fs');
var stream = fs.Readstream ('classmates.txt');
stream.setEncoding ('UTF8');
stream.on ('data', function (chunk) {
console.log ('leer algunos datos')
});
stream.on ('cerrar', function () {
console.log ('Todos los datos se leen')
});
En el ejemplo anterior, los datos del evento se activan cuando se reciben nuevos datos. El evento de cierre se activa cuando se completa el archivo que se lee.
Transmisión por escrito
Obviamente, también podemos crear un flujo de escritura para escribir datos. Esto significa que solo se puede usar un script simple para leer en el archivo y luego escribir a otro archivo:
La copia del código es la siguiente:
var fs = require ('fs');
var readAbreStream = fs.Readstream ('classmates.txt');
var writableStream = fs.WriteStream ('Names.txt');
readAblSteam.setEncoding ('UTF8');
readAblSteam.on ('Data', Function (Chunk) {
writableStream.write (fragmento);
});
readAblSteam.On ('Close', function () {
writableStream.end ();
});
Ahora, cuando se recibe un evento de datos, los datos se escriben en la secuencia de escritura.
leeable.setEncoding (codificación): retorno: esto
leeable.resume (): Igual que el anterior. Este método permite que la secuencia legible continúe activando el evento de datos.
leeable.Pause (): Igual que el anterior. Este método hace que una secuencia en el modo de flujo deje de activar el evento de datos, cambie al modo sin flujo y deje los datos disponibles posteriores en el búfer interno.
Clase: stream.writable
La interfaz de flujo de escritura es una abstracción de los datos que está escribiendo en un objetivo.
1.writable.write (fragmento, [codificación], [devolución de llamada]):
trozo {cadena | Buffer} datos a escribir
codificación {string} codificación, si el fragmento es una cadena
devolución de llamada {function} devolución de llamada después de la redacción del bloque de datos
Return: {boolean} Verdadero si los datos han sido procesados todos.
Este método escribe datos en el sistema subyacente y llama a la devolución de llamada dada después de que se procesan los datos.
2.Writable.cork (): obligado a atrapar todas las escrituras.
Los datos atascados se escribirán cuando se llame a la llamada .Unbork () o .end ().
3.Writable.end ([Chunk], [codificación], [devolución de llamada])
trozo {cadena | Buffer} opcional, datos a escribir
codificación {string} codificación, si el fragmento es una cadena
devolución de llamada {function} opcional, devolución de llamada después de que finaliza la transmisión
Llamar a escribir () después de llamar end () generará un error.
La copia del código es la siguiente:
// Escribe 'Hola', y luego termina con '¡Mundo!'
http.createServer (function (req, res) {
res.write ('hola',);
res.end ('¡Mundo!');
// ahora no se le permite continuar escribiendo
});