Sådan bruger du hændelsessendere i Node.js

Hændelsesudsendere er objekter i NodeJS, der udløser hændelser ved at sende en besked for at signalere, at en handling har fundet sted.

Node.js giver et indbygget hændelsesmodul. Den indeholder en hændelsessenderklasse, der lader dig oprette og håndtere tilpassede hændelser via tilbagekaldsfunktioner.

Her lærer du, hvordan du udsender hændelser, lytter og håndterer hændelsesdata og håndterer hændelsesfejl i NodeJS.

Udsender begivenheder

Eventmodulet er en kernedel af Node.js server-side miljøet. Du behøver således ikke installere det, men før du bruger EventEmitter klasse, skal du importere fra begivenhedsmodulet og instansiere det.

Ligesom:

konst EventEmitter = kræve("begivenheder");
// Instantiatation af EventEmitter
konst minEmitter = ny EventEmitter();

Du kan udsende begivenheder ved hjælp af EventEmitter’s udsende metode. Det udsende metode tager en begivenhedsnavn og et vilkårligt antal argumenter som parametre.

Når du ringer til udsende metode, udsender den bestået begivenhedsnavn. Derefter kalder den synkront hver af begivenhedens lyttere i den rækkefølge, du registrerede dem, og videregiver de leverede argumenter til hver. Endelig vender den tilbage

rigtigt hvis arrangementet havde lyttere og falsk hvis den ikke havde nogen lyttere.

For eksempel:

myEmitter.emit("TestEvent", "foo", "bar", 1, 2);

I kodeblokken ovenfor bestod du TestEvent som Begivenhedsnavn, og "foo,” "bar,” 1, og 2 som argumenterne. Når kodeblokken ovenfor kører, vil den give besked til alle lyttere, der lytter efter TestEvent begivenhed. Det vil kalde disse lyttere med de givne argumenter.

Lytte til begivenheder

Du kan lytte efter udsendte begivenheder ved hjælp af EventEmitter’s på metode. Det på metode tager en Begivenhedsnavn og en tilbagekaldsfunktion som parametre. Når arrangementet med Begivenhedsnavn gik over i på metoden udsendes, påberåber den sin tilbagekaldsfunktion. Denne metode returnerer en reference til EventEmitter, så du kan sammenkæde flere opkald.

For eksempel:

// Første lytter
myEmitter.on("TestEvent", () => {
 console.log("TestEvent udsendt!!!");
}); // TestEvent udsendt!!!
// Anden lytter
myEmitter.on("TestEvent", (...args) => {
 args = args.join(", ");
konsol.log(`Begivenhed udsendt med følgende argumenter: ${args}`);
}); // Hændelse udsendt med følgende argumenter: foo, bar, 1, 2
myEmitter.emit("TestEvent", "foo", "bar", 1, 2);

I kodeblokken ovenfor, når TestEvent begivenheden udsender, vil lytterne til begivenheden aktivere deres tilbagekaldsfunktioner. Lytterne vil reagere i den rækkefølge, du registrerede dem, hvilket betyder, at den "første lytters" tilbagekald vil køre før den anden, og så videre.

Du kan ændre denne adfærd ved at bruge EventEmitter’s prependListener metode. Denne metode tager de samme parametre som på metode. Forskellen er, at denne metode reagerer på begivenheden først, uanset hvornår du registrerer den.

For eksempel:

myEmitter.on("TestEvent", () => {
 console.log("TestEvent udsendt!!!");
});
myEmitter.prependListener("TestEvent", () => {
 console.log("Udføres først")
})
// console.log (myEmitter.listeners("TestEvent"));
myEmitter.emit("TestEvent", "foo", "bar", 1, 2);

Når kodeblokken ovenfor udføres, logges "Executes first" først til konsollen, efterfulgt af "TestEvent Emitted!!!" uanset hvilken rækkefølge du registrerede dem i på grund af prependListener metode.

Hvis du registrerer flere lyttere med prependListener metode, vil de køre i rækkefølge fra den sidste til den første.

Bemærk arrangementet af senderen og lytterne. Lytterne kommer altid før udsenderen. Dette arrangement skyldes, at lytterne allerede skal lytte til begivenheden, før udsenderen udsender den.

For kontekst, overvej kodeblokken nedenfor:

myEmitter.emit("TestEvent", "foo", "bar", 1, 2);
myEmitter.on("TestEvent", () => {
 console.log("TestEvent udsendt!!!");
}); 

Hvis du kører kodeblokken ovenfor, sker der ikke noget, fordi på det tidspunkt, hvor udsenderen udsendte hændelsen, var der ingen lyttere, der lyttede efter hændelsen.

Lytter til begivenheder én gang

Afhængigt af dine krav skal du muligvis kun håndtere nogle hændelser én gang i din applikations livscyklus. Du kan opnå dette ved at bruge EventEmitter’s enkelt gang metode.

Denne metode tager de samme argumenter som på metode og fungerer på samme måde. Den eneste forskel er, at lytterne tilmeldte sig enkelt gang metode kun lytte til begivenheden én gang.

For eksempel:

minEmitter.once("SingleEvent", () => {
 console.log("Begivenhed håndteret én gang");
});
myEmitter.emit("SingleEvent"); // Begivenhed håndteret én gang
myEmitter.emit("SingleEvent"); // Ignoreret
myEmitter.emit("SingleEvent"); // Ignoreret

Kørsel af kodeblokken vil kun logge "Begivenhed håndteret én gang" til konsollen én gang, uanset hvor ofte senderen udsender hændelsen.

Lyttere registreret hos enkelt gang metode reagere på begivenheden i den rækkefølge, du registrerer dem. Du kan ændre denne adfærd ved at bruge prependOnceListener metode, som fungerer som prependListener. Den eneste forskel er, at lytterne tilmeldte sig enkelt gang metode kun lytte til begivenheden én gang.

Håndtering af fejl med hændelsessendere

Du skal passe på håndtere JavaScript-fejl korrekt og begivenhedslyttere er ingen undtagelse. Ubehandlede fejl fra dem vil få Node.js-processen til at afslutte, og din applikation går ned.

For at håndtere en fejlhændelse skal mindst én af begivenhedens lyttere have sin Begivenhedsnavn indstillet til fejl.

For eksempel:

myEmitter.on("fejl", (fejl) => {
konsol.fejl(`Fejl: ${error}`);
});

At lade en lytter håndtere en potentiel fejl, som i kodeblokken ovenfor, vil forhindre applikationen i at gå ned, når der opstår en fejl.

For eksempel:

myEmitter.emit("fejl", ny fejl("Dette er en fejl"));

Ved at køre kodeblokken ovenfor logges "Dette er en fejl" til konsollen, fordi en lytter håndterer fejlhændelser.

Håndtering af begivenhedslyttere

Det EventEmitter klasse har flere metoder, der giver dig mulighed for at manipulere og administrere begivenhedslyttere. Du kan hente en begivenheds lyttere, fjerne dem og indstille det maksimale antal lyttere til en begivenhed.

Her er en tabel med EventEmitter metoder, du kan manipulere begivenhedslyttere med:

Du kan kun kalde disse metoder på en EventEmitter eksempel.

For eksempel:

myEmitter.removeListener("TestEvent");

Kodeblokken ovenfor fjerner en enkelt lytter for TestEvent begivenhed.

Vigtigheden af ​​hændelsesudsendere

Node.js adopterer det begivenhedsdrevne programmeringsparadigme med dets understøttelse af begivenhedsudsendere og lyttere. Hændelsesdrevet programmering er en af ​​grundene til, at Node.js-programmer er hurtigere og mere ligetil end nogle alternativer. Du kan nemt synkronisere flere begivenheder, hvilket resulterer i forbedret effektivitet.