Los 5 principales errores que los desarrolladores de nodos cometen

Node es una plataforma fantástica para escribir backends. Excepto cuando no haces las cosas bien.


Dependiendo de qué lado de la cerca te encuentres, Node es lo mejor o lo peor que le puede pasar al mundo del desarrollo web. Pero a pesar de las opiniones, no se discute la popularidad de Node. Se disparó en popularidad mucho más rápido de lo que nadie esperaba, incluso su creador (lo dijo de una manera pesimista) entrevista)!

Al momento de escribir, es la plataforma predeterminada para iniciar nuevas aplicaciones, que admito es a menudo el resultado de la mentalidad de rebaño, pero el efecto neto es que hay más trabajos, más dinero y proyectos más emocionantes en Node que en otros lenguajes de secuencias de comandos tradicionales..

Desafortunadamente, se ha llegado a un punto en que cuando alguien me pide que les recomiende una pila inicial para desarrollo web o nuevos productos de inicio, Node es mi recomendación número 1 a pesar de que estoy bien versado en PHP y Laravel.

Si se me permite continuar un poco la diatriba (¿qué lo haré desde que escribo?), Los que odian a Node tienen un punto cuando dicen que su web stack favorito puede hacer las cosas tan bien como Node, pero lo contrario también es cierto. Y luego hay cosas de programación y eventos asíncronos, que se integraron en Node desde el día 1, y otros ecosistemas ahora están tratando desesperadamente de copiar.

Hoy tenemos opciones asíncronas en PHP y Python, pero desafortunadamente, el núcleo de las bibliotecas populares existentes son puramente sincrónicas, por lo que es casi como si estuvieras luchando contra el sistema. Pero de todos modos, suficiente despotricar por un día. ��

Entonces, si usted es un desarrollador de Nodo (principiante o familiar), es probable que esté cometiendo uno de estos grandes errores que afectan negativamente a su aplicación. Puede deberse a que no está familiarizado con una forma particular de hacer las cosas mejor en Node, o tal vez son simplemente hábitos que ha llevado de algún otro ecosistema.

No respetar el bucle de eventos.

Cuando una persona migra a Node, es en parte porque ha escuchado historias de cómo LinkedIn escala usando Node, o ha visto puntos de referencia que muestran a Node ejecutando círculos alrededor de PHP, Ruby, etc. cuando se trata de atender solicitudes por segundo o manejar conexiones de toma abierta.

Entonces construyen su aplicación, esperando los mismos tiempos explosivos de respuesta con los que soñaron, excepto que no ocurre nada parecido..

Una de las principales razones para esto es no entender el bucle de eventos correctamente. Considere el siguiente código que obtiene un conjunto de libros de la base de datos y luego los ordena por el número total de páginas:

db.Library.get (libraryId, function (err, library) {
let books = library.books;
books.sort (función (a, b) {
volver a.páginas < b.páginas? -1: 1
});
});

Estoy de acuerdo en que este código no hace nada con la matriz de libros ordenados, pero ese no es el punto aquí. El punto es que un código de aspecto tan inocente es suficiente para hacer estallar el ciclo de eventos tan pronto como comience a tratar con un número no trivial de libros.

La razón es que el bucle de eventos está destinado a realizar E / S sin bloqueo. Un buen ejemplo es el de un empacador de pizzas en una pizzería: la persona se especializa en cortar la pizza, plegar las cubiertas en cajas de entrega, colocar la pizza, pegar las etiquetas correctas y empujarla hacia el repartidor..

Increíble, ¿verdad? Al igual que Node!

Fuente: stackoverflow.com

Pero considere lo que sucederá si esta persona también necesita mezclar, preparar y empacar los condimentos. Dependiendo de lo complejo que sea el proceso, la tasa de empaque de la pizza se reducirá a un tercio, o incluso se detendrá por completo.

Esto es lo que queremos decir con tareas que están “bloqueando”: siempre que Node simplemente tenga que pasar información, es muy rápida e idealmente la mejor opción, pero tan pronto como necesita hacer algunos cálculos extensos, se detiene y todo más tiene que esperar. Esto sucede porque el bucle de eventos es de un solo subproceso (más detalles aquí.)

Por lo tanto, no realice cálculos dentro del ciclo de eventos, no importa cuán importantes sean. Quiero decir, agregar números y tomar promedios está bien, pero grandes conjuntos de datos harán que su aplicación Node rastree.

Esperando que el código asincrónico coopere

Considere este ejemplo de nodo muy simple que lee datos de un archivo y lo muestra:

const fs = require (‘fs’);

dejar contenido = fs.readFile (‘secret.txt’, (err, data) => {
devolver datos;
});

console.log (‘El contenido del archivo es:’);
console.log (contenido);

La exposición a lenguajes clásicos (como PHP, Python, Perl, Ruby, C ++, etc.) hará que aplique el sentido común de que después de que se ejecute este código, el contenido variable tendrá el contenido del archivo. Pero esto es lo que sucede cuando realmente ejecutas el código:

Nos indefinimos (). Esto se debe a que, si bien es posible que te importe profundamente Node, su naturaleza asincrónica no se preocupa por ti (¡es una broma! Por favor, no envíes comentarios de odio aquí). Nuestro trabajo es comprender su naturaleza asincrónica y trabajar con ella. readFile () es una función asincrónica, lo que significa que tan pronto como se llama, el bucle de evento Node pasa el trabajo al componente del sistema de archivos y continúa.

Vuelve a la función más tarde cuando el archivo se ha leído, pero para ese momento el contenido se trata como una variable no inicializada y, por lo tanto, contiene indefinido. La forma correcta es procesar los datos del archivo dentro de la función de devolución de llamada, pero no puedo entrar en más detalles ya que esto no es un Tutorial de nodos. ��

Devolución de llamada que llama la devolución de llamada que llama la devolución de llamada que llama . . .

JavaScript está más cerca de la programación funcional que cualquier otro lenguaje convencional más antiguo (de hecho, dicho y hecho, es mi favorito cuando se trata de diseño orientado a objetos y capacidades funcionales: lo pongo por encima de Python, PHP, Perl, Java y incluso Ruby cuando se trata de escribir código “agradable”).

Es decir, las funciones obtienen más derechos ciudadanos que en otros idiomas. Combine esto con el hecho de que el código asincrónico funciona al proporcionarle una función de devolución de llamada, y terminamos con una receta para el desastre conocida como Callback Hell.

Aquí hay un ejemplo de código Electron que encontré en Quora. Que crees que hace?

opciones var;

require (‘electron’). app.once (
‘Listo’,

función () {

opciones = {
marco: falso,
altura: 768,
ancho: 1024,
x: 0,
y: 0
};

options.BrowserWindow = require (‘electron’). BrowserWindow;
options.browserWindow = nuevas opciones.BrowserWindow (opciones);
options.browserWindow.loadURL (‘http://electron.atom.io’);
options.browserWindow.webContents.once (
‘did-stop-loading’,

función () {
options.browserWindow.capturePage (
opciones,

función (datos) {
require (‘fs’). writeFileSync (
‘/tmp/screenCapture.testExampleJs.browser..png’,
data.toPng ()
);

proceso.exit (0);
}
);
}
);
}
);

Si tienes dificultades, únete al club!

Las funciones dentro de las funciones dentro de las funciones son difíciles de leer y muy difíciles de razonar, por eso se le ha llamado “infierno de devolución de llamada” (¡supongo que el infierno es un lugar confuso para salir!). Si bien esto funciona técnicamente, está haciendo que su código esté preparado para el futuro de cualquier intento de comprensión y mantenimiento.

Hay muchas formas de evitar el infierno de devolución de llamada, incluidas Promesas y Extensiones Reactivas.

No usa todos los núcleos de CPU

Los procesadores modernos tienen varios núcleos: 2, 4, 8, 16, 32. . . el número sigue subiendo.

Pero esto no es lo que el creador de Node tenía en mente cuando lanzó Node. Como resultado, Node es de un solo subproceso, lo que significa que se ejecuta dentro de un solo subproceso (o proceso, si desea llamarlo así, aunque no son lo mismo), utilizando solo un núcleo de CPU.

Eso significa que si aprendió Node de tutoriales y amigos y fragmentos de código que flotan, y tiene su aplicación implementada en un servidor de 8 núcleos, está desperdiciando 7/8 de la potencia de procesamiento disponible!

No hace falta decir que es un desperdicio masivo. Si sigue este camino, terminará pagando por ocho servidores cuando solo necesite uno. Es decir, gastar $ 16,000 por mes cuando $ 2,000 lo harán (la pérdida de dinero siempre duele, ¿verdad?). Todo esto, cuando la solución es bastante simple: usar el racimo módulo.

No puedo entrar en todos los detalles aquí, pero es una técnica simple de detectar cuántos núcleos tiene la máquina actual y luego lanzar tantas instancias de Nodo. Cuando se detectan errores, la instancia se reinicia. Así de sencillo es implementarlo (tutorial aquí):

var cluster = require (‘cluster’);

if (cluster.isMaster) {
var numWorkers = require (‘os’). cpus (). length;

console.log (‘Configuración del clúster maestro’ + numWorkers + ‘trabajadores …’);

para (var i = 0; i < numWorkers; i ++) {
cluster.fork ();
}

cluster.on (‘en línea’, función (trabajador) {
console.log (‘Trabajador’ + trabajador.proceso.pid + ‘está en línea’);
});

cluster.on (‘salida’, función (trabajador, código, señal) {
console.log (‘Trabajador’ + trabajador.proceso.pid + ‘murió con código:’ + código + ‘, y señal:’ + señal);
console.log (‘Iniciar un nuevo trabajador’);
cluster.fork ();
});
} más {
aplicación var = require (‘express’) ();
app.all (‘/ *’, function (req, res) {res.send (‘process’ + process.pid + ‘dice hola!’). end ();})

var server = app.listen (8000, function () {
console.log (‘Process’ + process.pid + ‘está escuchando todas las solicitudes entrantes’);
});
}

Como puede ver, cluster.fork () hace la magia, y el resto es simplemente escuchar un par de eventos de clúster esenciales y hacer la limpieza necesaria..

No usa TypeScript

Bien, no es un error como tal, y muchas aplicaciones de Nodo han sido y están siendo escritas sin TypeScript.

Dicho esto, TypeScript ofrece las garantías y la tranquilidad que Node siempre necesitó, y en mi opinión, es un error si está desarrollando para Node en 2019 y no está usando TypeScript (especialmente cuando la A (Angular) en la pila MEAN se movió a TypeScript hace mucho tiempo).

La transición es suave, y TypeScript es casi exactamente como el JavaScript que conoce, con la seguridad de los tipos, ES6 y algunas otras comprobaciones:

// /lib/controllers/crmController.ts
importar * como mangosta de ‘mangosta’;
importar {ContactSchema} desde ‘../models/crmModel’;
importar {Solicitud, Respuesta} desde ‘express’;

const Contact = mongoose.model (‘Contacto’, ContactSchema);
clase de exportación ContactController {

public addNewContact (req: Request, res: Response) {
let newContact = nuevo contacto (req.body);

newContact.save ((err, contact) => {
si (err) {
res.send (err);
}
res.json (contacto);
});
}

Recomiendo comprobar esto agradable y amigable Tutorial de TypeScript.

Conclusión

El nodo es impresionante, pero no está exento de problemas (¿muchos?). Dicho esto, esto se aplica a todas las tecnologías existentes, nuevas y antiguas, y haremos mejor para entender Node y trabajar con él..

Espero que estos cinco consejos eviten que te dejes atrapar por el pozo de alquitrán de errores perennes y problemas de rendimiento. Si me perdí algo interesante, avíseme y estaré más que feliz (de hecho, ¡agradecido!) De incluirlos en el artículo. ��

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map