Top 5 foute Node ontwikkelaars maak

Node is ‘n fantastiese platform vir die skryf van backends. Behalwe as jy dinge nie reg kry nie.


Afhangend van watter kant van die heining jy is, is Node die beste óf die slegste ding wat met die Webontwikkelingswêreld moet gebeur. Desondanks is daar geen sprake van die gewildheid van Node nie. Dit het vinniger gewild geword as wat iemand verwag het, selfs die skepper daarvan (hy het dit in ‘n andersins pessimistiese weergawe gesê onderhoud)!

Vanaf skryf is dit die standaardplatform vir die aanvang van nuwe apps, wat ek erken dat dit die gevolg is van die kudde-mentaliteit, maar die netto effek is dat daar meer werk, meer geld en meer opwindende projekte in Node is as in ander tradisionele skriftaaltale..

Ongelukkig is dit ‘n punt dat iemand my vra om ‘n beginbasis vir webontwikkeling of nuwe opstartprodukte aan te beveel, Node my aanbeveling is, alhoewel ek goed vertroud is met PHP en Laravel..

As ek miskien toegelaat word om ‘n bietjie voort te gaan (wat ek sal wees, want ek is die een wat skryf?), Dan is daar ‘n punt van nodehaters wanneer hulle sê dat hul gunsteling webstapel dinge net so goed kan doen as wat Node doen, maar die omgekeerde is ook waar. En dan is daar dinge wat asynchroniseer word en programme wat vanaf dag 1 in Node gebak is, en ander ekosisteme probeer nou desperaat kopieer.

Ons het vandag async-opsies in PHP en Python, maar ongelukkig is die kern van bestaande, gewilde biblioteke suiwer sinchronies, so dit is amper asof u teen die stelsel veg. Maar in elk geval, genoeg rant vir ‘n dag. ��

Dus, as u ‘n Node-ontwikkelaar is (beginner of bekend), is dit waarskynlik dat u een van hierdie groot foute begaan wat u aansoek negatief beïnvloed. Dit kan wees omdat u nie vertroud is met ‘n spesifieke manier om dinge beter in Node te doen nie, of miskien is dit bloot gewoontes wat u oorgedra het uit ‘n ander ekosisteem.

Nie die gebeurtenislus te respekteer nie

As ‘n persoon na Node migreer, is dit deels omdat hulle verhale gehoor het van hoe LinkedIn-skale gebruik maak van Node, of dat hulle maatstawwe gesien het wat wys dat Node rondloop rondom PHP, Ruby, ens. oop sok verbindings.

Hulle bou dus hul app en verwag dieselfde eksplosiewe reaksietye waarop hulle gedroom het – behalwe dat niks daar naby gebeur nie.

Een van die belangrikste redes hiervoor is om nie die gebeurtenislus korrek te verstaan ​​nie. Oorweeg die volgende kode wat ‘n stel boeke uit die databasis haal en sorteer dit volgens die totale aantal bladsye:

db.Library.get (biblioteekId, funksie (fout, biblioteek) {
laat boeke = biblioteek.boeke;
books.sort (funksie (a, b) {
terug a.bladsye < b.bladsye? -1: 1
});
});

Ek stem saam dat hierdie kode niks met die reeks boeke bevat nie, maar dit is nie die punt hier nie. Die punt is dat so ‘n onskuldige kode voldoende is om die gebeurtenislus op te blaas sodra u met ‘n nie-triviale aantal boeke begin werk..

Die rede is dat die gebeurtenislus bedoel is om nie-blokkerende I / O uit te voer. ‘N Goeie voorbeeld is dié van ‘n pizzapakker by ‘n pizzasameling – die persoon spesialiseer in die sny van die pizza, die oortreksels in afleweringsbakke gevou word, die pizza ingesit word, die regte etikette aangeheg en na die afleweringspers gedruk word.

Verbasend, nie waar nie? Net soos Node!

Bron: stackoverflow.com

Maar oorweeg wat sal gebeur as hierdie persoon ook die geurmiddels moet meng, voorberei en verpak. Afhangend van hoe ingewikkeld die proses is, word die pakkiesnelheid tot ‘n derde verlaag, of selfs tot ‘n einde gebring.

Dit is wat ons bedoel met take wat “blokkeer” – solank Node bloot inligting moet deurgee, is dit baie vinnig en ideaal die beste opsie, maar sodra dit uitgebreide berekeninge moet doen, stop dit, en alles anders moet wag. Dit gebeur omdat die gebeurtenislus enkel-draad is (meer besonderhede hier.)

Moet dus nie berekeninge binne die gebeurtenislus doen nie, hoe belangrik dit ook al is. Ek bedoel, om getalle by te tel en gemiddeldes te neem is goed, maar groot datastelle sal jou Node-app laat kruip.

Hoop dat die asynkode-kode sal saamwerk

Beskou hierdie baie eenvoudige Node-voorbeeld wat data uit ‘n lêer lees en dit weergee:

const fs = vereis (‘fs’);

laat inhoud = fs.readFile (‘geheim.txt’, (fout, data) => {
terugstuur data;
});

console.log (‘Lêerinhoud is:’);
console.log (inhoud);

As u blootstel aan klassieke tale (soos PHP, Python, Perl, Ruby, C ++, ens.), Sal u die gesonde verstand toepas dat die inhoud van die lêer, nadat hierdie kode loop, die inhoud bevat. Maar dit is wat gebeur as u die kode uitvoer:

Ons word ongedefinieerd (). Dit is omdat jy baie omgee vir Node, maar die asynchroniese aard daarvan gee nie om vir jou nie (dit is bedoel om ‘n grap te wees! Moet asseblief nie haat kommentaar hier strooi nie ��). Ons taak is om die asynchroniese aard daarvan te verstaan ​​en daarmee saam te werk. readFile () is ‘n asynchroniese funksie, wat beteken dat sodra dit genoem word, die Node-gebeurtenislus die werk aan die lêerstelselkomponent deurgegee en verder gaan.

Dit sal later terugkeer na die funksie wanneer die lêer gelees is, maar teen daardie tyd word die inhoud soos ‘n oninitialiseerde veranderlike behandel en bevat dit dus ongedefinieerd. Die regte manier is om die lêergegewens binne die terugbelfunksie te verwerk, maar ek kan nie meer in besonderhede gaan nie, aangesien dit nie ‘n voorbeeld is nie Nodututorial. ��

Terugbel wat die terugbel noem wat die terugbel wat bel . . .

JavaScript is nader aan funksionele programmering as enige ander ouer, hoofstaal (eintlik sê alles en al, dit is my gunsteling as dit kom by objekgeoriënteerde ontwerp en funksionele vermoëns – ek plaas dit bo Python, PHP, Perl, Java en selfs Ruby as dit kom by die skryf van ‘aangename’ kode).

Dit wil sê, funksies kry meer burgerregte as in ander tale. Koppel dit met die feit dat asynchroniese kode werk deur u ‘n terugbelfunksie te gee, en ons eindig met ‘n resep vir rampe wat bekend staan ​​as Callback Hell.

Hier is ‘n voorbeeld van ‘n elektroniese kode waarmee ek op Quora afgekom het. Wat dink jy doen dit??

var opsies;

vereis ( ‘n elektron ‘). app.once (
‘Gereed’,

funksie () {

opsies = {
raam: vals,
hoogte: 768,
breedte: 1024,
x: 0,
y: 0
};

options.BrowserWindow = benodig (‘elektron’). BrowserWindow;
options.browserWindow = nuwe opsies.BrowserWindow (opsies);
options.browserWindow.loadURL ( ‘http://electron.atom.io’);
options.browserWindow.webContents.once (
“Het-stop-laai ‘,

funksie () {
options.browserWindow.capturePage (
opsies,

funksie (data) {
vereis ( ‘FS). writeFileSync (
‘/Tmp/screenCapture.testExampleJs.browser..png’,
data.toPng ()
);

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

As u sukkel, sluit by die klub aan!

Funksies binne funksies binne funksies is moeilik om te lees en baie moeilik om oor te redeneer, daarom word dit ” terugbel-hel ” genoem (ek veronderstel dat die hel ‘n verwarrende plek is om uit te kom!). Terwyl dit tegnies werk, maak u u kode toekomsbestand uit alle pogings tot begrip en onderhoud.

Daar is baie maniere om terugbel-hel te vermy, insluitend Beloftes en Reaktiewe uitbreidings.

Gebruik nie al die CPU-kerns nie

Moderne verwerkers het verskillende kerns – 2, 4, 8, 16, 32. . . die nommer klim steeds.

Maar dit is nie wat die Node-skepper in gedagte gehad het toe hy Node vrygestel het nie. As gevolg hiervan is Node enkel-draad, wat beteken dat dit in ‘n enkele draad loop (of ‘n proses, as u dit wil noem, hoewel dit nie dieselfde is nie), met slegs een CPU-kern.

Dit beteken dat as u Node geleer het van tutoriale en vriende en kodebniere wat rondloop en u app op ‘n 8-kernbediener ontplooi het, mors u 7/8 van die beskikbare verwerkingskrag!

Nodeloos om te sê, dit is ‘n massiewe vermorsing. As u hierdie pad volg, sal u uiteindelik vir agt bedieners betaal as u slegs een benodig. Dit wil sê, spandeer $ 16,000 per maand wanneer $ 2,000 dit sal doen (geldverlies is altyd seer, nie waar nie?). Dit alles, wanneer die oplossing redelik eenvoudig is: die gebruik van die cluster module.

Ek kan nie al die besonderhede hier bespreek nie, maar dit is ‘n eenvoudige tegniek om op te let hoeveel cores die huidige masjien het, en dan soveel Node-instansies te begin. As foute opgespoor word, word die instansie herbegin. Hier is hoe eenvoudig dit is om te implementeer (handleiding hier):

var cluster = benodig (‘cluster’);

if (cluster.isMaster) {
var numWorkers = benodig (‘os’). cpus (). lengte;

console.log (‘Meesterkluster instel’ + numWorkers + ‘werknemers …’);

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

cluster.on (‘aanlyn’, funksie (werker) {
console.log (‘Worker’ + worker.process.pid + ‘is aanlyn’);
});

cluster.on (‘exit’, funksie (werker, kode, sein) {
console.log (‘Worker’ + worker.process.pid + ‘is dood met kode:’ + code + ‘, en sein:’ + sein);
console.log (‘Begin ‘n nuwe werker’);
cluster.fork ();
});
} anders {
var app = demand (‘uitdruklik’) ();
app.all (‘/ *’, funksie (req, res) {res.send (‘proses’ + proses.pid + ‘sê hallo!’). end ();})

var server = app.listen (8000, funksie () {
console.log (‘Process’ + process.pid + ‘luister na alle inkomende versoeke’);
});
}

Soos u kan sien, doen cluster.fork () die towery, en die res luister eenvoudig na ‘n paar noodsaaklike groepgebeurtenisse en doen die nodige opruiming.

Gebruik nie TypeScript nie

Goed, dit is nie ‘n fout nie, en daar is en is baie van die nodetoepassings geskryf sonder TypeScript.

Dat gesê, TypeScript bied die waarborge en gemoedsrus wat Node altyd nodig gehad het, en in my oë is dit ‘n fout as u in 2019 ontwikkel vir Node en nie TypeScript gebruik nie (veral nie wanneer die A (Angular) in die MEAN-stapel geskuif het nie na TypeScript lank gelede).

Die oorgang is sag, en TypeScript is byna presies soos die JavaScript wat u ken, met die borg van soorte, ES6, en ‘n paar ander tjeks wat ingegooi word:

// /lib/controllers/crmController.ts
invoer * as mongose ​​vanaf ‘mongoose’;
voer {ContactSchema} in vanaf ‘../models/crmModel’;
invoer {Request, Response} van ‘express’;

const Contact = mongoose.model (‘Contact’, ContactSchema);
uitvoerklas kontakbeheerder {

openbare addNewContact (vraag: Versoek, res: Reaksie) {
laat newContact = new Contact (req.body);

newContact.save ((fout, kontak) => {
indien (dwaal) {
res.send (dwaal);
}
res.json (kontak);
});
}

Ek sal aanbeveel dat u dit aangenaam en vriendelik nagaan TypeScript-tutoriaal.

Afsluiting

Knooppunt is indrukwekkend, maar dit is nie sonder sy (baie?) Probleme nie. Dit gesê, dit geld vir alle tegnologieë daar buite, nuut en oud, en ons sal beter doen om Node te verstaan ​​en daarmee te werk.

Ek hoop dat hierdie vyf wenke sal verhoed dat u in die teerput van meerjarige goggas en prestasieprobleme ingesuig word. As ek iets interessants gemis het, laat weet my dan daarvan, en ek sal dit (in werklikheid baie dankbaar!) Ook in die artikel insluit. ��

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