Топ 5 Създават разработчици на грешки на възли

Node е фантастична платформа за писане на бекъни. С изключение на случаите, когато не правите нещата.


В зависимост от това на коя страна на оградата се намирате, Node е или най-доброто, или най-лошото нещо, което се случва в света на уеб разработките. Но мненията, няма спор за популярността на Node. Той се появи по популярност по-бързо, отколкото някой очакваше, дори и неговият създател (той каза това иначе песимистично интервю)!

Що се отнася до писането, това е платформата по подразбиране за стартиране на нови приложения, която, признавам, често е резултат от менталния стад, но нетният ефект е, че в Node има повече работни места, повече пари и по-вълнуващи проекти, отколкото в други традиционни езици на скриптове.

За съжаление стигна дотам, че когато някой ме помоли да им препоръча начален стек за уеб разработка или нови стартиращи продукти, Node е моята препоръка №1, въпреки че съм добре запознат с PHP и Laravel.

Ако може да ми бъде позволено да продължа безкрайно малко (което ще бъда, тъй като аз съм този, който пиша?), Хейтърите на Node имат смисъл, когато казват, че любимият им уеб стек може да прави нещата точно както и Node, но обратното също е вярно. И тогава има програми за асинхронизиране на програми и събития, които бяха изпечени в Node от първия ден, а други екосистеми сега отчаяно се опитват да копират.

Днес имаме опции за асинхронизация в PHP и Python, но за съжаление ядрото на съществуващите популярни библиотеки е чисто синхронно, така че е почти като да се борите срещу системата. Но така или иначе, достатъчно рейтинг за един ден. ��

Така че, ако сте разработчик на Node (начинаещ или познат), най-вероятно правите една от тези големи грешки, които се отразяват негативно на приложението ви. Възможно е, защото не сте запознати с конкретен начин да подобрите нещата в Node, или просто това са навици, които сте пренесли от някаква друга екосистема.

Без да се спазва примката на събитието

Когато човек мигрира към Node, това е отчасти защото е чувал истории за това как LinkedIn мащабира с помощта на Node, или е виждал показатели, които показват Node да върти кръгове около PHP, Ruby и т.н., когато става въпрос за обслужване на заявки в секунда или обработка отворете гнездовите връзки.

Така те изграждат своето приложение, очаквайки същите експлозивни времена за реакция, за които са мечтали – с изключение на това, че нищо близо до него не се случва.

Една от основните причини за това е неразбирането правилно на кръга на събитията. Помислете следния код, който получава набор от книги от базата данни и след това ги сортира по общия брой страници:

db.Library.get (libraryId, функция (грешка, библиотека) {
нека книги = library.books;
books.sort (функция (a, b) {
върнете a.pages < б.страници? -1: 1
});
});

Съгласен съм, че този код не прави нищо с масива от сортирани книги, но това не е тук. Въпросът е, че такъв невинно изглеждащ код е достатъчен, за да взривите цикъла на събитията, веднага щом започнете да се занимавате с нетривиален брой книги.

Причината е, че цикълът на събитията е предназначен да изпълнява не блокиращ I / O. Добър пример е този на опаковчик за пица при пица на ставата – човекът е специализиран в рязането на пицата, сгъването на корици в кутии за доставка, поставянето на пицата, поставянето на правилните етикети и бутането й на водещия.

Невероятно, нали? Точно като Node!

Източник: stackoverflow.com

Но помислете какво ще се случи, ако този човек също трябва да смеси, приготви и пакетира подправките. В зависимост от това колко сложен е процесът, скоростта на опаковане на пица ще бъде намалена до една трета или може би дори ще стигне до пълна спирка.

Това имаме предвид под „блокиращи” задачи – стига Node просто да предава информация наоколо, това е много бърз и в идеалния случай най-добрият вариант, но щом трябва да направи обширни изчисления, той спира и всичко друго трябва да чака. Това се случва, защото цикълът на събитията е еднопоточен (повече подробности тук.)

Така че, не правете изчисления в кръга на събитията, независимо колко важни са те. Искам да кажа, че добавянето на числа и вземането на средни стойности е добре, но големи масиви от данни ще накарат приложението ви Node да обходи.

Надявам се, че асинхронният код ще съдейства

Помислете за този много прост пример на Node, който чете данни от файл и го показва:

const fs = изисквам (‘fs’);

нека съдържание = fs.readFile (‘secret.txt’, (грешка, данни) => {
данни за връщане;
});

console.log (‘Съдържанието на файла е:’);
console.log (съдържание);

Експозицията на класически езици (като PHP, Python, Perl, Ruby, C ++ и т.н.) ще накарате да приложите здравия разум, че след като този код се изпълни, съдържанието на променливата ще съдържа съдържанието на файла. Но ето какво се случва, когато действително изпълните кода:

Получаваме неопределени (). Това е така, защото макар че може да ви е грижа дълбоко за Node, неговата асинхронна природа не се интересува от вас (означава, че е шега! Моля, не спамете коментари от омраза тук ��). Нашата работа е да разберем нейната асинхронна природа и да работим с нея. readFile () е асинхронна функция, което означава, че веднага след като се извика, цикълът на събитието Node предава работата на компонента на файловата система и продължава.

Той се връща към функцията по-късно, когато файлът е прочетен, но по това време съдържанието се третира като неинициализирана променлива и по този начин съдържа неопределена. Правилният начин е да обработвате файловите данни във функцията за обратно извикване, но не мога да вляза в повече подробности, тъй като това не е Урок за възел. ��

Обратна връзка, която призовава обратната връзка, която се обажда обратно . . .

JavaScript е по-близо до функционалното програмиране, отколкото всеки друг по-стар, основен език (всъщност, всичко казано и направено, това е любимото ми, когато става дума за обектно-ориентиран дизайн и функционални възможности – поставям го над Python, PHP, Perl, Java и дори Ruby, когато става дума за писане на “приятен” код).

Тоест, функциите получават повече права на гражданите, отколкото на другите езици. Съчетайте това с факта, че асинхронен код работи, като ви предоставя функция за обратно извикване, и ние завършваме с рецепта за бедствие, известна като Callback Hell.

Ето някои примерни електронни кодове, които попаднах на Quora. Какво мислите, че прави?

var опции;

изискват ( “електрон”). app.once (
‘готов’,

функция () {

options = {
рамка: невярно,
височина: 768,
ширина: 1024,
x: 0,
у: 0
};

options.BrowserWindow = изискват (‘електрон’).
options.browserWindow = нови опции.BrowserWindow (опции);
options.browserWindow.loadURL ( “http://electron.atom.io ‘);
options.browserWindow.webContents.once (
“Направих гише натоварване”,

функция () {
options.browserWindow.capturePage (
настроики,

функция (данни) {
изискват ( “FS”). writeFileSync (
“/Tmp/screenCapture.testExampleJs.browser..png”,
data.toPng ()
);

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

Ако ви е трудно, присъединете се към клуба!

Функциите във функциите вътре във функциите са трудни за четене и е много трудно да се разсъждават, поради което това е наречено като „ад на обратно повикване“ (предполагам, че Адът е объркващо място за излизане от него!). Докато това технически работи, вие правите кода си в бъдеще доказан от всякакви опити за разбиране и поддръжка.

Има много начини да избегнете ада на обратно повикване, включително обещания и Реактивни разширения.

Не се използват всички ядра на процесора

Съвременните процесори имат няколко ядра – 2, 4, 8, 16, 32. , , броят продължава да се качва.

Но това не е това, което създателят на Node е имал предвид, когато пусна Node. В резултат на това Node е с една нишка, което означава, че работи вътре в една нишка (или процес, ако искате да го наречете така, въпреки че не са еднакви), използвайки само едно ядро ​​на процесора.

Това означава, че ако сте научили Node от уроци и приятели и кодови фрагменти, плаващи наоколо, и приложението ви да бъде разгърнато на 8-ядрен сървър, вие губите 7/8 от наличната обработваща мощност!

Излишно е да казвам, че това е огромна загуба Ако следвате този път, ще получите плащане за осем сървъра, когато имате нужда само от един. Тоест, харчете 16 000 долара на месец, когато 2 000 долара ще направят (загубата на пари винаги боли, нали?). Всичко това, когато решението е доста просто: използване на струпване модул.

Не мога да вляза във всички подробности тук, но това е проста техника за откриване колко ядра има текущата машина и след това стартиране на толкова много екземпляри на Node. Когато бъдат открити грешки, екземплярът се рестартира. Ето колко е проста за изпълнение (урок тук):

var cluster = изисквам (‘клъстер’);

ако (cluster.isMaster) {
var numWorkers = изискват (‘os’). cpus (). дължина;

console.log (‘Настройка на главния клъстер’ + numWorkers + ‘работнички …’);

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

cluster.on (‘онлайн’, функция (работник) {
console.log (“Работник” + работник.процес.pid + “е онлайн”);
});

cluster.on (‘изход’, функция (работник, код, сигнал) {
console.log (‘Работник’ + работник.процес.pid + ‘умря с код:’ + код + ‘, и сигнал:’ + сигнал);
console.log („Стартиране на нов работник“);
cluster.fork ();
});
} else {
var app = изисквам (‘express’) ();
app.all (‘/ *’, функция (req, res) {res.send (‘процес’ + process.pid + ‘казва здравей!’). end ();})

var server = app.listen (8000, функция () {
console.log (‘Process’ + process.pid + ‘слуша всички входящи заявки’);
});
}

Както можете да видите, cluster.fork () прави магията, а останалото е просто да слушате няколко съществени събития в клъстера и да правите необходимото почистване.

Не се използва TypeScript

Добре, не е грешка, като такава и много приложения за Node са били и се пишат без TypeScript.

Това каза, TypeScript предлага гаранциите и спокойствието, от които Node винаги е бил нужен, и в моите очи е грешка, ако разработвате за Node през 2019 г. и не използвате TypeScript (особено когато A (Angular) в стека MEAN се премести към TypeScript отдавна).

Преходът е нежен и TypeScript е почти точно като JavaScript, който познавате, със сигурността на типовете, ES6 и няколко други проверки, хвърлени в:

// /lib/controllers/crmController.ts
импортиране * като мангуста от „мангуста“;
import {ContactSchema} от ‘../models/crmModel’;
import {Заявка, отговор} от ‘express’;

const Contact = mongoose.model (‘Контакт’, ContactSchema);
експортен клас ContactController {

обществен addNewContact (req: заявка, res: отговор) {
нека newContact = нов контакт (req.body);

newContact.save ((грешка, контакт) => {
ако (ERR) {
res.send (ERR);
}
res.json (контакт);
});
}

Препоръчвам ви да проверите това хубаво и приятелско Урок за TypeScript.

заключение

Възелът е впечатляващ, но не е без своите (много?) Проблеми. Това каза, това се отнася за всички технологии навън, нови и стари, и ще е по-добре да разберем Node и да работим с него.

Надявам се, че тези пет съвета ще ви попречат да се всмуквате в катранната яма на многогодишни бъгове и проблеми с производителността. Ако пропуснах нещо интересно, моля, уведомете ме и ще бъда повече от щастлив (всъщност благодарен!), За да ги включа в статията. ��

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