Обработка на събития в Node.js

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

Това в Node.js е това, което се нарича излъчватели на събития, което дава възможност на разработчиците да абонират събития, където той абонира функция обратно повикване който ще бъде извикан всеки път, когато се случи събитие в излъчвателя на събития. Можем дори да създадем наши собствени излъчватели на събития благодарение на псевдокласа EventEmitter.

За да влезем обаче с излъчвателите на събития, първо трябва да сме наясно с някои понятия, като например някои модели на тези функции, типовете събития и дори слушателите.

ИзискванияЗа да изпълним упражненията, предложени в този урок, трябва да имаме функционална инсталация на Node.js в нашата система можем да разгледаме този урок, преди да продължим да се задълбочаваме в него. Също така е важно да имате достъп до богат текстов редактор, за да кодирате примерите, можем да използваме всичко, с което се чувстваме комфортно, но за неговата лекота на употреба препоръчваме Възвишен текст o NotePad ++, който също има плъгини за синтаксиса JavaScript Y HTML.

Шаблон за обратни обаждания

Асинхронното програмиране не използва връщането на стойности във функциите, за да обозначи, че тази функция току -що е приключила, но извиква известния обратен извикване след приключване на операцията, за да може нашата програма да продължи, където JavaScript Стигам до този тип програмиране, нека видим пример в Не давай който чете файл и зарежда съдържанието му в паметта:

 var fs = require ('fs'); fs.readFile ('file.txt', function (err, fileContent) {if (err) {throw err;} console.log ('Съдържание на файла:', fileContent.toString ());});

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

Шаблон за излъчвател на събитие

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

Излъчвателят на събития не е нищо повече от обект, който, както показва името му, излъчва събитие, където a слушател това е част от кода, който се свързва с този излъчвател и слуша определени типове събития, като например:

 var req = http.request (опции, функция (отговор) {response.on ("данни", функция (данни) {console.log ("Някои данни за отговор", данни);}); response.on ("край" , function () {console.log ("завършен отговор");});}); req.end ();

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

Видове събития

Според предишния пример можем да видим, че излъчваните събития винаги имат тип, който е представен от низ, в този случай "данни"Y"край”, Които ще бъдат произволни низове, определени от издателя на събитието.

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

 var em = new (require ('events'). EventEmitter) (); em.emit ('събитие1'); em.emit ('error', new Error ('Моята грешка'));

Ако го пуснем през конзолата, можем да видим как Не давай ни казва, че не обработваме грешката, като по този начин генерираме неуловимо изключение:

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

Използване на API за излъчване на събития

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

.addListener - .onТози метод ни позволява да добавим слушател към тип събитие.
.единадесетС този метод можем да обвържем слушателя с тип събитие, като се има предвид, че то ще бъде извикано поне веднъж.
.removeEventListenerТози метод ще ни позволи да премахнем слушател от всяко дадено събитие.
.removeAllEventListenersИ накрая, този метод ни помага да премахнем всички слушатели за даден тип събитие.
След като вече видяхме каква е функцията на всеки от тях, нека видим как ги използваме в нашите програми.

Използване на .addListener () или .on () при обратни извиквания

Като посочите тип събитие и функция обратно повикване, можем да запишем действието, което да предприемем, когато настъпи конкретно събитие. Например, ако искаме да бъдем информирани, че част от данните са налични и излъчват събитие от тип данни, можем да направим следното:

 функция receiveData (данни) {console.log ("Данните са получени:% j", данни); } readFlow.addListener ("данни", receiveData);

Можем да използваме и метода .На () което е само пряк път, нека видим еквивалента на предишния код:

 функция receiveData (данни) {console.log ("Данните са получени:% j", данни); } readFlow.on ("данни", receiveData);

Можем дори да добавим няколко слушатели за нашите събития, за да слушат един и същ тип събитие на един и същ предавател, например:

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

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

• Не улавянето на изключения е нездравословно поведение за нашия код, така че ако някой от тези слушатели хвърли грешка и не бъде уловен, възможно е някои слушатели да не бъдат извикани, където можем да илюстрираме това в следния пример:

Когато в този пример вторият слушател няма да бъде извикан, тъй като първият издава грешка.

Използване на .removeListener ()

Ако по всяко време вече не искаме да бъдем информирани за промени в конкретно събитие или обект, можем да спрем да го записваме, като посочим типа на събитието и функцията за обратно извикване, както следва:

Използване на .once ()

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

Използване на .removeAllListeners ()

Накрая можем да премахнем всички слушатели за определен тип събитие от излъчвател на събития, както следва:

 issueer.removeAllListeners (тип);

Създаване на излъчвател на събития

Излъчвателят на събития ни предоставя общ начин за създаване на интерфейси, тъй като ние сме обвързващи събития вместо функции, което прави нашата програма по -гъвкава, дори ако искаме да използваме модела на Node.js В цялото ни приложение можем да създаваме псевдоклас и да наследяваме от EventEmitter както следва:

 util = require ('util'); var EventEmitter = require ('events'). EventEmitter; var MyClass = function () {} util.inherits (MyClass, EventEmitter);

По този начин методите на EventEmitter Те ще бъдат достъпни за нашия екземпляр и можем да ги използваме без проблеми и по този начин Моят клас може да излъчва събития:

 MyClass.prototype.someMethod = function () {this.emit ("персонализирано събитие", "аргумент 1", "аргумент 2"); };

Тук кога някакъв метод се извиква в случая на Моят клас, примерът излъчва събитие, наречено персонализирано събитие, където от своя страна излъчва две различни данни, аргумент 1 и аргумент 2, които ще бъдат изпратени на слушателите на събитията. Накрая в случаите на Моят клас от страна на клиента можете да слушате персонализирано събитие както следва:

 var MyClass = нов MyClass (); MyClass.on ('персонализирано събитие', функция (str1, str2) {console.log ('Прослушано персонализирано събитие с аргументи str1% s и str2% s!', Str1, str2);});

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