5 principals errors que fan els desenvolupadors de nodes

Node és una plataforma fantàstica per escriure backends. Excepte quan no es posin les coses bé.


Depenent de quin costat de la tanca us trobeu a estar, Node és el millor o el pitjor que passa pel món del desenvolupament web. No obstant això, no hi ha opinions sobre la popularitat de Node. Va guanyar popularitat de manera més ràpida del que ningú esperava, fins i tot el seu creador (ho va dir d’una manera pessimista entrevista)!

Quant a escriure, és la plataforma predeterminada per iniciar aplicacions noves, que admeto sovint és el resultat de la mentalitat del ramat, però l’efecte net és que hi ha més llocs de treball, més diners i projectes més emocionants al node que en altres llenguatges tradicionals d’escriptura..

Malauradament, ha arribat a un punt que quan algú em demana que els recomani una pila inicial per al desenvolupament web o els nous productes d’inici, Node és la meva recomanació # 1, tot i que estic ben versat en PHP i Laravel.

Si se’m permetria continuar una mica el rastre (que seré ja que sóc el que escric?), Els nodes haters tenen un punt en dir que la seva pila web preferida pot fer les coses tan bé com ho fa Node, però el contrari també és cert. I, a continuació, hi ha coses de programació i esdeveniments asínc, que es van formar al node des del primer dia i altres ecosistemes estan intentant desesperadament copiar.

Avui tenim opcions asíncques a PHP i Python, però, malauradament, el nucli de les biblioteques populars existents són purament sincrònics, de manera que gairebé com que lluiteu contra el sistema. Però de totes maneres, prou rescabalament per un dia. ��

Així, si sou un desenvolupador de nodes (principiant o familiar), és probable que cometeu un d’aquests grans errors que afecten negativament la vostra aplicació. Pot ser perquè no coneixeu una forma determinada de fer les coses millor a Node, o potser simplement són els hàbits que heu tret d’un altre ecosistema.

No respectar el bucle d’esdeveniments

Quan una persona migra a Node, és en part perquè han escoltat històries de com escalen LinkedIn amb Node, o bé han vist punts de referència que mostren cercles amb Node corrent al voltant de PHP, Ruby, etc. quan es tracta de sol·licitar o gestionar sol·licituds per segon. connexions de soca oberta.

Així que construeixen la seva aplicació, esperant els mateixos temps de resposta explosius que somien, tret que no passi res proper.

Una de les principals raons per a això és no entendre correctament el bucle d’esdeveniments. Penseu en el codi següent que rep un conjunt de llibres de la base de dades i després els ordena pel nombre total de pàgines:

db.Library.get (libraryId, function (err, biblioteca) {
let books = library.books;
books.sort (funció (a, b) {
retorna a.pages < b.pàgines? -1: 1
});
});

Estic d’acord que aquest codi no fa res amb la matriu de llibres ordenats, però no és el punt aquí. La qüestió és que un codi tan aspecte innocent és suficient per fer volar el llaç d’esdeveniment tan bon punt comenceu a tractar un nombre no trivial de llibres.

El motiu és que el bucle d’esdeveniments està dissenyat per realitzar I / O no bloquejants. Un bon exemple és el d’un envasador de pizza en una junta de pizza: la persona s’especialitza en tallar la pizza, plegar les fundes a les caixes d’entrega, posar la pizza, enganxar les etiquetes adequades i posar-la cap a l’entrega..

Sorprenent, no? Igual que Node!

Font: stackoverflow.com

Però considereu què passarà si aquesta persona també necessita barrejar, preparar i empaquetar els condiments. Segons la complexitat del procés, la taxa d’embalatge de pizza es reduirà fins a un terç o, fins i tot, s’aturarà completament.

Això és el que entenem per tasques que es “bloquegen”, sempre que Node simplement hagi de passar informació al voltant, és molt ràpida i idealment la millor opció, però tan aviat com ha de fer uns càlculs extensos, s’atura i tot. més s’ha d’esperar. Això passa perquè el bucle d’esdeveniments és d’un filet (més detalls) aquí.)

Per tant, no feu càlculs dins del bucle d’esdeveniments, no importa la importància que siguin. Vull dir, afegir números i prendre mitjanes no està bé, però els grans conjunts de dades faran que la vostra aplicació de node s’arrossegui.

Amb l’esperança que el codi async cooperarà

Penseu en aquest exemple de node molt senzill que llegeix dades d’un fitxer i les mostra:

const fs = requereixen (‘fs’);

let contents = fs.readFile (‘secret.txt’, (err, dades) => {
devolució de dades;
});

console.log (“El contingut del fitxer és:”);
console.log (contingut);

L’exposició a llenguatges clàssics (com PHP, Python, Perl, Ruby, C ++, etc.) us haurà d’aplicar el sentit comú que després que s’execute aquest codi, els continguts variables tindran el contingut del fitxer. Però aquí teniu el que passa quan realment executeu el codi:

Ens quedem indefinits (). Això és perquè si us pot interessar profundament per Node, la seva naturalesa asíncica no li importa (és una broma! Per tant, no espanteu els comentaris d’odi per correu brossa aquí ��). La nostra feina és comprendre la seva naturalesa asínica i treballar-hi. readFile () és una funció asíncrona, cosa que significa que tan aviat com es diu, el bucle d’esdeveniment del node passa el treball al component del sistema de fitxers i continua.

Torna a la funció més tard quan s’ha llegit el fitxer, però per aquest moment el contingut és tractat com una variable no inicialitzada i, per tant, no definit. La manera correcta és processar les dades del fitxer dins de la funció de devolució, però no puc aprofundir en més detalls, ja que no és una Tutorial de nodes. ��

Callback que truca a la devolució que truca a la devolució que truca . . .

JavaScript s’aproxima a la programació funcional que qualsevol altre llenguatge principal i antic (de fet, tot dit i fet, és el meu preferit quan es tracta de disseny orientat a objectes i capacitats funcionals; el situo per sobre de Python, PHP, Perl, Java i fins i tot Ruby a l’hora d’escriure codi “agradable”).

És a dir, les funcions obtenen més drets ciutadans que no pas en altres idiomes. Combina-ho amb el fet que el codi asíncron funciona proporcionant-te una funció de devolució, i acabem amb una recepta de desastre coneguda com Callback Hell.

Aquí teniu un exemple de codi d’electrons que he trobat a Quora. Què creus que fa?

opcions var;

require (“electró”). app.once (
‘llest’,

function () {

options = {
marc: fals,
alçada: 768,
amplada: 1024,
x: 0,
i: 0
};

options.BrowserWindow = requereix (“electró”).
options.browserWindow = new options.BrowserWindow (opcions);
options.browserWindow.loadURL (“http://electron.atom.io”);
options.browserWindow.webContents.once (
“va deixar de carregar”,

function () {
options.browserWindow.capturePage (
opcions,

function (data) {
require (“fs”). writeFileSync (
‘/tmp/screenCapture.testExampleJs.browser..png’,
data.toPng ()
);

process.exit (0);
}
);
}
);
}
);

Si us costa molt, uniu-vos al club!

Les funcions dins de les funcions dins de les funcions són difícils de llegir i són difícils de raonar, i és per això que s’anomena “infern de devolució” (suposo que Infern és un lloc confús per sortir-ne!). Si bé funciona tècnicament, esteu fent que el vostre codi sigui a prova futura de qualsevol intent de comprensió i manteniment.

Hi ha moltes maneres d’evitar l’infern de trucada, incloses Promeses i Extensions reactives.

No utilitzeu tots els nuclis de CPU

Els processadors moderns tenen diversos nuclis: 2, 4, 8, 16, 32. . . el nombre continua pujant.

Però això no és el que tenia en compte el creador del node quan va llançar Node. Com a resultat, el node és de fil únic, cosa que significa que funciona dins d’un mateix fil (o procés, si voleu anomenar-ho, tot i que no són el mateix), utilitzant només un nucli de CPU.

Això vol dir que si heu après Node de tutorials i amics i fragments de codi que floten i que la vostra aplicació es desplega en un servidor de 8 nuclis, perdreu el 7/8 del poder de processament disponible.!

No cal dir que són un malbaratament massiu. Si seguiu aquest camí, acabareu pagant per vuit servidors quan només en necessiteu un. És a dir, invertiu 16.000 dòlars al mes quan faran 2.000 dòlars (la pèrdua de diners sempre fa mal, oi?). Tot això, quan la solució és bastant simple: fer servir la funció cúmul mòdul.

No puc entrar a tots els detalls aquí, però és una tècnica senzilla de detectar quants nuclis té la màquina actual i, després, llançar moltes instàncies de node. Quan es detecten errors, es reinicia la instància. Aquí teniu la sencililitat de posar en pràctica (tutorial) aquí):

var cluster = requerir (‘cluster’);

if (cluster.isMaster) {
var numWorkers = requerir (‘os’). longitud cpus ().

console.log (“Configuració del clúster mestre” + numWorkers + “treballadors …”);

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

cluster.on (‘en línia’, funció (treballador) {
console.log (“Worker” + working.process.pid + “està en línia”);
});

cluster.on (‘sortida’, funció (treballador, codi, senyal) {
console.log (“Worker” + traballador.process.pid + “ha mort amb el codi: ‘+ codi +’ i el senyal: ‘+ senyal);
console.log (‘Iniciar un nou treballador’);
cluster.fork ();
});
} més {
var app = require (‘express’) ();
app.all (‘/ *’, function (req, res) {res.send (‘process’ + process.pid + ‘saluda!’). end ();})

var server = app.listen (8000, function () {
console.log (“Process” + process.pid + “escolta totes les sol·licituds entrants”);
});
}

Com podeu veure, cluster.fork () fa la màgia, i la resta és simplement escoltar un parell d’esdeveniments clústers imprescindibles i fer la neteja necessària.

No utilitzeu TypeScript

D’acord, no és cap error, com a tal, i s’han escrit i s’escriuen moltes aplicacions de nodes sense TypeScript.

Dit això, TypeScript ofereix les garanties i la tranquil·litat que Node sempre necessitava, i als meus ulls, és un error si esteu desenvolupant per a Node el 2019 i no utilitzeu TypeScript (sobretot quan la A (Angular) de la pila MEAN es va moure). a TypeScript fa molt temps).

La transició és suau i TypeScript és gairebé exactament com el JavaScript que coneixeu, amb la garantia de tipus ES6 i algunes altres comprovacions:

// /lib/controllers/crmController.ts
importar * com a mongoose de “mongoose”;
importar {ContactSchema} de “../models/crmModel”;
importa {Sol·licitud, resposta} de “express”;

const Contact = mongoose.model (‘Contacte’, ContactSchema);
export class ContactController {

public addNewContact (sol·licitud: sol·licitud, res: resposta) {
let newContact = new Contact (req.body);

newContact.save ((err, contacte) => {
if (err) {
res.send (err);
}
res.json (contacte);
});
}

Us recomano que comproveu aquest tracte amable i amable Tutorial de TypeScript.

Conclusió

El node és impressionant, però no té els seus (molts?) Problemes. Dit això, això s’aplica a totes les tecnologies existents, noves i antigues, i farem millor comprendre Node i treballar amb ell.

Espero que aquests cinc consells impedeixin que us deixeu xuclar a la fossa de quitrà d’errors perennes i problemes de rendiment. Si he perdut alguna cosa interessant, si us plau, fes-ho saber i estaré més que feliç (de fet, agraït!) D’incloure-les a l’article. ��

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