node.js se basa en el motor v8 de Chrome para ejecutar código js , por lo que podemos deshacernos del entorno del navegador y ejecutar el código js directamente en la consola, como el siguiente hello world código hello world
console.log('hello world'); Puedes ejecutarlo directamente usando node en la consola.
El módulo http incorporado de node.js http capacidades básicas de servicio http createServer Según la especificación CommonJS , podemos usar require para importar el módulo http para su uso. módulo que nos permite crear un http El servidor recibe una función de devolución de llamada como parámetro. Esta función de devolución de llamada recibe dos parámetros: request y response .
request incluye toda la información solicitada por el cliente, como url , header de la solicitud, el método de la solicitud y. Cuerpo de solicitud.response se utiliza principalmente para devolver información al cliente. Encapsula algunas operaciones relacionadas con el cuerpo de la respuesta. Por ejemplo, el método response.writeHead nos permite personalizar la información del encabezado y el código de estado del cuerpo de devolución. el cuerpo de la respuesta, llamamos response.end() . Puede enviar el cuerpo de la respuesta al cliente. El uso de la función createServer solo crea un objeto Server para nosotros, pero no le permite escuchar. método listen del objeto server a escuchar. De hecho, podemos comenzar a ejecutar
listen como servidor. El primer parámetro es el número de puerto de escucha, el segundo parámetro es la ip del host vinculado y el tercer parámetro es una función de devolución de llamada. llamado de forma asincrónica por el módulo http . Cuando se encuentra un error, puede ser La excepción lanzada se obtiene del primer parámetro de la función de devolución de llamada. Podemos elegir manejar la excepción para hacer que nuestro servidor sea más robusto. usando el módulo http para crear un servidor simple.
const { createServer } = require('http');
const HOST = 'localhost';
PUERTO constante = '8080';
servidor constante = createServer((solicitud, resp) => {
// el primer parámetro es el código de estado que devuelve
// y el segundo parámetro es la información del encabezado de respuesta
resp.writeHead(200, { 'Tipo de contenido': 'texto/sin formato' });
console.log('el servidor está funcionando...');
// llama al método final para decirle al servidor que la solicitud se ha cumplido
resp.end('hola servidor http nodejs');
});
server.listen(PUERTO, HOST, (error) => {
si (error) {
console.log('Algo anda mal: ', error);
devolver;
}
console.log(`el servidor está escuchando en http://${HOST}:${PORT} ...`);
}); ¡Puedes intentar ejecutarlo directamente con node y crear tu propio servidor! Una vez que el servidor se está ejecutando, el navegador puede acceder al servidor accediendo a http://localhost:8080
También puede usar nodemon para ejecutarlo, de modo que cuando nuestro código cambie, no necesitemos finalizar manualmente el programa y volver a ejecutar
npm i -g nodemon.
Se recomienda instalarlo globalmente para que pueda usarlo directamente. sin usar npx nodemon También es muy simple, simplemente cambie el comando node al comando nodemon
nodemon http-server.js.
. Cuando usamos los objetos createServer y resp anteriormente, no pudimos ver ninguna indicación de sintaxis. Debemos seguir la documentación oficial node para verificarlo en cualquier momento. puedo usar .d.ts nos ayuda a proporcionar la función de solicitud de sintaxis. Tenga en cuenta que no estamos usando ts para el desarrollo, solo usamos su función de solicitud de sintaxis
npm init -y@types/node -- pnpm i @types/node -Djsconfig.json en el directorio del proyecto, excluya node_modules , no es necesario verificarlo{ "compilerOptions": {
"checkJs": verdadero
},
"excluir": ["node_modules", "**/node_modules/*"]
} Me pregunto si ha descubierto que en realidad hay un error en el código anterior. checkJs puede ayudarnos a verificar si hay errores de tipo. Puede elegir activarlo según sus necesidades. Después de activar la verificación, nos avisará inmediatamente si el tipo de parámetro no coincide.
En este momento, pase el mouse sobre el método listen y podrá ver la firma del método.
Como puede ver, el parámetro port original debe ser de tipo number , pero cuando lo definimos, era de tipo string , por lo que no coincidía. Simplemente cámbielo a 8080 de number y podrá ver directamente la documentación api relevante. sin abrir el node oficial. Me llevó mucho tiempo encontrar el documento y comprobarlo.
. Nuestro http server simple solo devolvió una oración, entonces, ¿es posible devolver varias oraciones? Esto requiere usar el método write del objeto resp . end solo puede devolver contenido una vez. En su lugar, podemos write contenido en el cuerpo de la respuesta varias veces. Al final, solo necesitamos llamar end una vez. pase cualquier parámetro. Solo permítale completar la función de enviar el cuerpo de respuesta
const { createServer } = require("http");
const HOST = "localhost";
PUERTO constante = 8080;
servidor constante = createServer((solicitud, resp) => {
resp.writeHead(200, { "Tipo de contenido": "texto/sin formato" });
console.log("el servidor está funcionando...");
// escribe algunas oraciones lorem
resp.write("Lorem ipsum dolor sit amet consectetur adipisicing elit.n");
resp.write("Omnis eligendi aperiam delectus?n");
resp.write("¡Aut, quam quo!n");
resp.end();
});
server.listen(PUERTO, HOST, (error) => {
si (error) {
console.log("Algo anda mal: ", error);
devolver;
}
console.log(`el servidor está escuchando en http://${HOST}:${PORT} ...`);
}); esta vez escribimos tres oraciones y el efecto ahora se vuelve así
no solo podemos devolver una cadena al navegador, sino que también podemos leer directamente el contenido del archivo html y, como resultado, devolverlo al navegador. Esto requiere el uso de otro módulo integrado Node.js fs , que El módulo proporciona la función de operación de archivos. Puede usar fs.readFile para leer archivos de forma asincrónica, pero no devolverá un objeto promise , por lo que debemos pasar una devolución de llamada para manejar la operación después de leer el archivo. también puede usar fs.readFileSync para bloquear la lectura de archivos sincrónicamente, aquí elegimos la lectura asincrónica
const { createServer } = require("http");
const fs = requerir("fs");
const HOST = "localhost";
PUERTO constante = 8080; servidor constante = crearServidor((solicitud, resp) => {
// cambiar el tipo MIME de texto/plain a texto/html
resp.writeHead(200, { "Tipo de contenido": "texto/html" });
// lee el contenido del archivo html
fs.readFile("index.html", (err, datos) => {
si (errar) {
consola.error(
"se produjo un error al leer el contenido del archivo html: ",
errar
); tirar errar;
}
console.log("¡operación exitosa!");
resp.write(datos);
resp.end();
});
});
server.listen(PUERTO, HOST, (error) => {
si (error) {
console.log("Algo anda mal: ", error);
devolver;
}
console.log(`el servidor está escuchando en http://${HOST}:${PORT} ...`);
}); el resultado actual es el siguiente:
Devolver html con éxito Nota: Aquí debe cambiar **Content-Type** del encabezado de respuesta a **text/html** para informar al navegador que estamos devolviendo el contenido del archivo **html** . Si todavía usa **text/plain** se devuelve texto/sin formato**, el navegador no analizará el contenido devuelto, incluso si se ajusta a la sintaxis **html** , no se analizará, como se muestra a continuación:
Cuando necesitamos escribir un servidor back-end que solo sea responsable de devolver datos de la interfaz, necesitamos devolver contenido en formato json . Creo que es inteligente y sabe cómo manejarlo:
MIME en application/jsonresp.write , se pasa la cadena json . Puede usar JSON.stringify para procesar el objeto y devolverconst { createServer } = require("http");
const HOST = "localhost";
PUERTO constante = 8080;
servidor constante = createServer((solicitud, resp) => {
// cambia el tipo MIME a aplicación/json
resp.writeHead(200, { "Tipo de contenido": "aplicación/json" });
// crea datos json usando un objeto
const jsonDataObj = {
código: 0,
mensaje: "éxito",
datos: {
nombre: "plastilina",
edad: 20,
pasatiempo: "codificar",
},
};
resp.write(JSON.stringify(jsonDataObj));
resp.end();
});
server.listen(PUERTO, HOST, (error) => {
si (error) {
console.log("Algo anda mal: ", error);
devolver;
}
console.log(`el servidor está escuchando en http://${HOST}:${PORT} ...`);
}); los resultados son los siguientes:
La idea de devolver archivos pdf es similar a la de devolver archivos html antes. Ambos son un proceso de configuración del tipo MIME del encabezado de respuesta, lectura del archivo y devolución del contenido del archivo. algo diferente. Nuestra idea es hacerlo mientras el servidor se está ejecutando. Para generar un archivo pdf y devolverlo, necesita cambiar MIME a application/pdf Para generar un archivo pdf , necesita usar una biblioteca: pdfkit
pnpm i pdfkit
Primero, escribimos una función para crear un archivo pdf , porque crear un archivo pdf también requiere realizar algunas operaciones de escritura, no estoy seguro de cuándo se completará, pero nuestra solicitud debe esperar hasta que se cree pdf antes de que podamos. obtenemos una respuesta, por lo que debemos hacerlo asincrónico y devolver una promise
/**
* @description Crear archivo pdf */const createPdf = () => {
devolver nueva Promesa((resolver, rechazar) => {
if (!fs.existsSync("ejemplo.pdf")) {
// crear un objeto PDFDocument
const doc = nuevo documento PDF();
// crea una secuencia de escritura canalizando el contenido del pdf.
doc.pipe(fs.createWriteStream("ejemplo.pdf"));
// agregar algunos contenidos al documento pdf
doc.fontSize(16).text("Hola PDF", 100, 100);
// completa la operación de generación del archivo PDF.
doc.end();
}
resolver("éxito");
});
}; La operación de canalización se utiliza aquí para transferir el contenido del objeto PDFDocument a la secuencia de escritura recién creada a través de la canalización. Cuando se completa la operación, notificamos al mundo exterior a través de resovle que se ha creado el archivo pdf y luego llamamos
a const. server en el código del servidor = createServer(async (req, resp) => {
// cambia el tipo MIME a aplicación/pdf
resp.writeHead(200, { "Tipo de contenido": "aplicación/pdf" });
// crear archivo pdf
espere crearPdf();
// leer el archivo pdf creado
fs.readFile("ejemplo.pdf", (err, datos) => {
si (errar) {
consola.error(
"se produjo un error al leer el contenido del archivo pdf: ",
errar
);
tirar errar;
}
console.log("¡operación exitosa!");
resp.end(datos);
});
});
server.listen(PUERTO, HOST, (error) => {
si (error) {
console.log("Algo anda mal: ", error);
devolver;
}
console.log(`el servidor está escuchando en http://${HOST}:${PORT} ...`);
}); ahora el navegador puede leer el archivo pdf creado.
sigue siendo la misma: lea un archivo de audio, luego envíelo al objeto resp a través de una canalización y devuélvalo
const { createServer } = require("http");
const {stat, createReadStream} = require("fs");
const HOST = "localhost";
PUERTO constante = 8080;
servidor constante = createServer((solicitud, resp) => {
// cambia el tipo MIME a audio/mpe
resp.writeHead(200, { "Tipo de contenido": "audio/mp3" });
const mp3FileName = "audio.mp3";
stat(mp3FileName, (err, estadísticas) => {
si (estadísticas.isFile()) {
const rs = createReadStream(mp3FileName);
// canaliza el flujo de lectura a resp
rs.pipe(resp);
} demás {
resp.end("el archivo mp3 no existe");
}
});
});
server.listen(PUERTO, HOST, (error) => {
si (error) {
console.log("Algo anda mal: ", error);
devolver;
}
console.log(`el servidor está escuchando en http://${HOST}:${PORT} ...`);
}); el efecto es el siguiente
Después de abrir, hay una interfaz para reproducir audio. Esta es la visualización de archivos de audio proporcionada por chrome . Cuando abre la consola, encontrará que se devuelven archivos de audio.
Nota: Después de pasar la secuencia del archivo de audio a **resp** a través de la tubería , no es necesario llamar **resp.end()** , porque esto cerrará toda la respuesta y hará que el archivo de audio se indisponible.
El procesamiento de archivos de video y archivos de audio es el mismo, excepto que MIME debe cambiarse a video/mp4 . Todo lo demás es igual
const { createServer } = require("http");
const {stat, createReadStream} = require("fs");
const HOST = "localhost";
PUERTO constante = 8080;
servidor constante = createServer((solicitud, resp) => {
// cambia el tipo MIME a audio/mpe
resp.writeHead(200, { "Tipo de contenido": "audio/mp4" });
const mp4FileName = "vídeo.mp4";
stat(mp4FileName, (err, estadísticas) => {
si (estadísticas.isFile()) {
const rs = createReadStream(mp4FileName);
// canaliza el flujo de lectura a resp
rs.pipe(resp);
} demás {
resp.end("el archivo mp4 no existe");
}
});
});
server.listen(PUERTO, HOST, (error) => {
si (error) {
console.log("Algo anda mal: ", error);
devolver;
}
console.log(`el servidor está escuchando en http://${HOST}:${PORT} ...`);
});
aprendimos:
Node para crear un servidor httpjshtmlJSONpdf .Aunque el contenido es simple, espero que puedas seguirlo y probarlo. No creas que es fácil simplemente mirarlo. No significa que lo sepas. Encontrarás tus propios problemas sólo después de implementarlo.