1. Tampón tampón
fondo
1. El navegador no necesita almacenar archivos de imagen y otros archivos multimedia, y JS almacena algunos tipos de datos básicos.
2. El servidor necesita almacenar archivos multimedia como imágenes/videos/audio, por lo que hay un búfer de búfer.
1. ¿Qué es el búfer?
Buffer es un objeto similar a una matriz, la diferencia es que Buffer se usa especialmente para almacenar datos binarios.
2. Características del búfer
1. Es un objeto [similar a una matriz] que se utiliza para almacenar datos (se almacenan datos binarios).
2. La eficiencia de Buffer es muy alta, y el almacenamiento y la lectura son muy rápidos.Opera directamente en la memoria de la computadora.
3. Una vez determinado el tamaño del Buffer, no se puede modificar.
4. El tamaño de la memoria ocupada por cada elemento es de 1 byte, y sus elementos son números de dos dígitos en hexadecimal. El rango de cada elemento es de 00 - ff 5. El
búfer es un módulo muy básico en Node, no es necesario descargarlo , Se puede utilizar directamente sin importar
3. Operación de búfer
3.1 Creación de búfer
// 创建一个指定size大小的Buffer
// 安全，里面全是0
var buf = Buffer.alloc(size);
//不安全，可能包含旧数据，需要重写所有数据
var buf = Buffer.allocUnsafe(size);
1. Método 1
let buf = new Buffer(10)
console.log(buf)
new Bufferforma de crear Bufferun objeto de instancia de , el rendimiento es particularmente pobre (debe abrir espacio en el montón y luego limpiar el espacio, establecerlo en cero)
2. Método 2
let buf2 = Buffer.alloc(10)
console.log(buf2)
Cree un objeto de instancia de Buffer, que tiene un rendimiento new Buffer()ligeramente mejor , y abra un espacio en el montón (nadie ha utilizado este espacio)
3. Método 3
let buf3 = Buffer.allocUnsafe(10)
console.log(buf3)
Cree un Bufferobjeto de instancia con el mejor rendimiento y abra espacio en el montón.
3.2 Obtener la longitud de Buffer
// 获取Buffer的长度
buf.length
3.3 Conversión de búfer
// 相当于Buffer.alloc(size);
var buf = Buffer.allocUnsafe(size);
buf.fill(0) //将可能出现的敏感数据用0全部填充
// 将一个字符串转换为Buffer
var buf = Buffer.from(str);
// 将一个Buffer转换为字符串
var str = buf.toString();
Aviso:
1. ¿Por qué el búfer de salida no es binario?
La salida es hexadecimal, pero ¿está almacenada en binario? Se convertirá automáticamente a hexadecimal cuando se emita.
2. ¿El búfer de salida no está vacío?
Abrir espacio en el montón puede dejar datos utilizados por otros, por lo queallocUnsafe
Dos, sistema de archivos fs
1. sistema de archivos fs en Node
Hay un sistema de archivos en Node. El llamado sistema de archivos es para agregar, eliminar, modificar y verificar archivos en la computadora.
En NodeJs, proporcionamos un módulo llamado módulo fs (sistema de archivos), que se usa especialmente para operar archivos.
El módulo fs es el módulo principal de Node. Al usarlo, se puede importar directamente sin descargarlo.
// 引入fs模块
var fs = require("fs");
La mayoría de los métodos en fs nos proporcionan dos versiones:
1. Método síncrono: el método synccon
método síncrono bloqueará la ejecución del programa.El
método síncrono devuelve el resultado a través del valor de retorno
2. Método asíncrono: el método syncsin
el método asíncrono no bloqueará la ejecución del programa.
El método asíncrono devuelve el resultado a través de la función de devolución de llamada.
Una característica de Nodejs es asincrónica y sin bloqueo, por lo que todo lo que aprende son métodos asincrónicos.
2. Escribir archivo fs
2.1 Redacción de expedientes ordinarios
1. Usar sincrónicamente
1. Use fs.openSync()para abrir el archivo (este método devolverá un descriptor de archivo como resultado y se pueden realizar varias operaciones en el archivo a través de este descriptor), los parámetros son:
1. path: ruta del archivo
2. flags: tipo de operación (w, r)
let fd = fs.openSync("./file/test1.txt", "w");
2. Use fs.writeSync()para escribir el archivo , los parámetros son:
1. fd: descriptor de archivo
2. string: el contenido que se escribirá
3. position: la posición inicial de escritura (opcional)
4. encoding: la codificación de escritura, el valor predeterminado es utf-8 (opcional)
fs.writeSync(fd, "测试文件的第一行文字");
3. Use fs.closeSync()para cerrar el archivo, los parámetros son:
fd: descriptor de archivo
fs.closeSync(fd);
2. Uso asíncrono
Al usar la API asíncrona, solo necesita agregar una función de devolución de llamada de forma síncrona. La función de devolución de llamada debe devolver el valor correspondiente a través de parámetros. Los parámetros generalmente incluyen:
1. err: Objeto de error, si no hay error, será nulo
2. fd: Descriptor de archivo
// 打开文件
fs.open("./file/test2.txt", "w", function (err, fd){
if(!err){
// 写入内容
fs.write(fd, "异步操作的第一行文字", function (err){
if(!err){
console.log("成功添加内容");
}
// 关闭文件
fs.close(fd, function (err){
console.log(err);
})
})
}
})
2.2 Escritura sencilla de archivos
El método simple de escritura de archivos es una operación asíncrona. De hecho, las siguientes son todas operaciones asíncronas.
1. Usar sincrónicamente
Se usa fs.writeFileSync()para escribir, los parámetros son:
1. path: ruta del archivo
2. data: el contenido a escribir
3. options: Opcional, puede realizar algunos ajustes para escribir
fs.writeFileSync("./file/test4.txt", "通过简单文件同步写入的内容");
2. Uso asíncrono
Úselo fs.writeFile()para escribir, el parámetro es una función de devolución de llamada más que la sincronización
fs.writeFile(file, data[, options], callback(err) => {
})
1. file: la ruta del archivo para escribir + nombre de archivo + sufijo
2. data: los datos a escribir
3. options: objeto de configuración (parámetro opcional)
1.encoding：设置文件的编码方式，默认值：utf8（万国码）
2.mode：设置文件的操作权限，默认值是：0o666 = 0o222 + 0o444
0o111：文件可被执行的权限，.exe .msc 几乎不用，linux有自己一套操作方法。
0o222：文件可被写入的权限
0o444：文件可别读取的权限
3.flag：打开文件要执行的操作，默认值是 'w'
a：追加
w：写入
4.callback：回调函数
err：错误对象
Ejemplo:
//引入内置的fs模块
let fs = require('fs')
fs.writeFile("./file/test3.txt", "通过简单文件异步写入的内容", function (err){
console.log(err);
if(!err){
console.log("写入成功");
}
})
Existe tal principio en Node: error primero. Así que con la devolución de llamada: err=>{}.
3. estado de la bandera
El estado de apertura del archivo es como se muestra en la siguiente figura
2.3 Escritura de transmisión
Los dos métodos de escritura anteriores no son adecuados para escribir archivos grandes, el rendimiento es bajo y es fácil causar un desbordamiento de la memoria, por lo que se recomienda utilizar el método de escritura de transmisión.
La escritura de archivos de transmisión se puede comparar con el uso de una tubería de agua para transportar agua desde el río hasta su hogar. Al escribir un archivo de transmisión, primero debe crear una corriente (tubería de agua) y luego verificar el estado de la corriente. se transfiere el archivo, debe cerrar la transmisión (tomar la tubería de agua abierta).
1. Úselo fs.createWriteStream()para crear un flujo de escritura (se construye la tubería de agua), los parámetros son:
1. path: ruta del archivo
2. options: parámetro de configuración, opcional
let ws = fs.createWriteStream("./file/test5.txt");
2. Use ws.write()para ingresar contenido en el archivo:
ws.write("第一次写入");
ws.write("第二次写入");
3. Use ws.close()/ws.end()para cerrar el flujo de escritura (el primero tendrá algunos errores en la versión inferior de Node, la tubería de agua ya no se usa, por lo que debe guardarse)
ws.close();
ws.end();
4. Use ws.once()para vincular un evento de una sola vez al objeto para monitorear si la secuencia grabable está cerrada o no (siempre que se use la secuencia, se debe monitorear el estado de la secuencia):
ws.once("open", function (){
console.log("可写流打开了~~");
})
ws.once("close", function (){
console.log("可写流关闭了~~");
})
3. Lectura de archivos
3.1 Lectura sencilla
Úselo fs.readFile()para leer, el parámetro es una función de devolución de llamada más que la sincronización
fs.readFile("./file/test1.txt", function (err, data){
if(!err){
console.log(data.toString());
}
})
Si se usan la lectura y la escritura al mismo tiempo, el efecto de copiar se puede lograr de la siguiente manera:
fs.readFile("./file/1.jpg", function (err, data){
if(!err){
console.log(data);
fs.writeFile("./file/1_copy.jpg", data, function (err){
if (!err){
console.log("写入成功~~~");
}
})
}
})
3.2 Lectura de transmisión
3.2.1 Lectura+escritura normal
Para leer los datos en el flujo legible, debe vincular un evento de datos al flujo legible. Después de vincular el evento, automáticamente comenzará a leer datos (los datos leídos están en los parámetros de la función de devolución de llamada)
// 创建一个可读流
let rs = fs.createReadStream("./file/test1.txt");
// 创建一个可写流
let ws = fs.createWriteStream("./file/test1_copy.txt");
// 监听是否开始关闭
rs.once("open", function (){
console.log("可读流打开了");
})
rs.once("close", function (){
console.log("可读流关闭了");
ws.end(); //读完了才关，否则读一条就关了
})
// 读取可读流的数据
rs.on("data", function (data){
console.log(data);
// 写入可写流中
ws.write(data);
})
3.2.2 Fácil lectura y escritura
No hay necesidad de vincular datael evento , solo use rs.pipe()el método de la secuencia de escritura para enviar directamente el contenido de la secuencia de lectura a la secuencia de escritura.
// 创建一个可写流
let rs = fs.createReadStream("./file/那些花儿.mp3");
// 创建一个可写流
let ws = fs.createWriteStream("./file/那些花儿_copy.mp3");
// 监听是否开始关闭
rs.once("open", function (){
console.log("可读流打开了");
})
rs.once("close", function (){
console.log("可读流关闭了");
})
rs.pipe(ws);
4. Otros métodos
1. fs.existsSync(path): Comprobar si existe un archivo
2. fs.stat(path,callback)/fs.statSync(path): Obtener el estado del archivo
3. fs.unlink(path,callback)/fs.unlinkSync(path): Eliminar el archivo
4. fs.readdir(path[,options],callback)/fs.readdirSync(path[,options]): Leer la estructura de directorios de un directorio
5. fs.truncate(path,len,callback) / fs.truncateSync(path,len): Truncar el archivo y modificarlo al tamaño especificado
6. fs.mkdir(path,[options],callback) / fs.mkdirSync(path,[options]): Crear un directorio
7 , fs.rmdir(path,callback) / fs.rmdirSync(path): eliminar un directorio
8, fs.rename(oldPath,newPath,callback) / fs.renameSync(oldPath,newPath): renombrar el archivo, y al mismo tiempo lograr el efecto de mover
9, fs.watchFire(filename[,options],listener): monitorear la modificación del archivo
3. módulo http
1. Crea el servidor web más básico
1. Importar módulo Http
const http=require('http')
2. Crear una instancia de servidor web
const server=http.createServer()
3. Vincule el evento de solicitud a la instancia del servidor y escuche la solicitud del cliente
//使用服务器实例的.on()方法，为服务器绑定一个request事件
server.on('request',(req,res)=>{
//只要有客户端来请求我们自己的服务器，就会触发request事件，从而调用这个事件处理函数
console.log('someone visit our web server.')
})
4. Inicie el servidor
//调用server.listen(端口号，cb回调）方法，即可启动web服务器
server.listen(80,()=>{
console.log('http server running at http://127.0.0.1')
})
2. objeto de solicitud de req
Siempre que el servidor reciba la solicitud del cliente, llamará a la función de procesamiento de eventos server.on（）vinculada al servidor. Si desea acceder a datos o atributos relacionados con el cliente en la función de procesamiento de eventos, puede utilizar los siguientes métodos:request
server.on('request',(req,res)=>{
//req是请求对象，它包含了与客户端相关的数据和属性，例如：
//req.url是客户端请求的url地址
//req.method 是客户端的method请求类型
const str='Your request url is ${req.url},and request method is ${req.method}'
console.log(str)
}）
3. objeto de respuesta res
server.on('request',(req,res)=>{
//res是响应对象，它包含了与服务器相关的数据和属性，例如：
//要发送到客户端的字符串
const str='Your request url is ${req.url},and request method is ${req.method}'
//res.end()方法的调用：
//向客户端发送指定内容，并结束这次请求的处理过程
res.end(str)
}）
4. Resuelva el problema de los caracteres chinos ilegibles
Al llamar res.end()al método para enviar contenido chino al cliente, habrá caracteres ilegibles. En este momento, debe configurar manualmente el formato de codificación del contenido.
server.on('request',(req,res)=>{
//发送的内容包含中文
conststr='您请求的url地址是${req.url},请求的method类型是${req.method}'
//为了防止中文显示乱码的问题，需要设置响应头
res.setHeader('Content-Type','text/html;charset=utf-8')
//把包含中文的内容，响应给客户端
res.end(str)
})
5. Responda a diferentes contenidos html según diferentes URL
server.on('request',function(req,res){
const url =req.url //1.获取请求的Url地址
let content ='<h1>404 Not found!</h1>'//2.设置默认的内容
if(url=='/'||url ==='/index.html'){
content='<h1>首页</h1>'//3.用户请求的是首页
}else if(url==='/about.html'){
content='<h1>关于页面</h1>'
}
//为了防止中文显示乱码的问题，需要设置响应头
res.setHeader('Content-Type','text/html;charset=utf-8')
//把包含中文的内容，响应给客户端
res.end(str)
})