En introduktion till händelsestyrd programmering i Node.js

Key Takeaways

Händelsestyrd programmering är en idealisk metod för att utveckla interaktiva applikationer, särskilt sådana med grafiska användargränssnitt (GUI), eftersom koden kan reagera på användarinteraktioner på ett oförutsägbart sätt. Denna flexibilitet tar hänsyn till de olika sätt som användarna kan interagera med appen och ger en responsiv upplevelse som uppfyller deras behov sömlöst.

Händelsestyrd programmering har blivit en vanlig metod i webbapplikationer, där händelselyssnare aktiveras när användaren interagerar med dokumentobjektmodellen (DOM).

Att integrera händelsebaserad programmering i Node.js kan göras smidigt genom att använda klassen EventEmitter, som gör det lättare att skapa skräddarsydda händelser och koppla till händelsehanterare för lämplig hantering av dem.

När man utvecklar en programvara är valet av lämplig programmeringsparadigm ett viktigt beslut som måste fattas. Paradigmet påverkar i slutändan kodens struktur och organisation, liksom dess effektivitet och underhållsmässighet. Det är därför viktigt att noga överväga vilket paradigm som bäst överensstämmer med de specifika kraven och målen för projektet innan man bestämmer sig för en viss metod.

Händelsestyrd programmering, som kännetecknas av att den reagerar på asynkrona händelser som inträffar i en oförutsägbar sekvens, är särskilt väl lämpad för applikationer som kräver interaktion med användare och som ofta finns i grafiska användargränssnitt snarare än kommandoradsprogram eller kodning av inbyggda system.

Vad är händelser?

En händelse kan beskrivas som antingen en exekvering som initieras av programmet eller en stimulus som framkallar en reaktion från programvaran, som sedan identifieras och hanteras av en utsedd funktionell komponent i koden. Vanligtvis kommer en användare eller systemet självt att initiera en händelse, vilket får koden att ange en specifik procedur för att bearbeta resultatet.

Inom datorprogrammering skulle en rudimentär händelse kunna exemplifieras med processen att trycka ned en tangent på ett tangentbord för att utföra en specifik uppgift. När denna operation äger rum utlöser den en händelse som kallas “event”, som därefter aktiverar en subrutin som kallas “listener” eller “handler”.

Vad är händelsestyrd programmering?

Händelsestyrd programmering kan beskrivas som en särskild metod för programvaruutveckling, där utvecklingen av en applikations funktioner är beroende av specifika händelser eller händelser, snarare än att följa en förutbestämd och linjär sekvens.

Denna typ av paradigm används ofta vid utveckling av användargränssnitt och realtidsapplikationer, där en användares handling initierar ett motsvarande svar från systemet.

I samband med utveckling av webbapplikationer har det blivit allt vanligare att använda event listeners, eftersom de triggas som svar på användarens interaktion med DOM (Document Object Model).

Ovanstående illustration visar den underliggande mekanismen för händelsestyrd programmering, där en händelse triggas av motsvarande händelsekanal för att överföra händelsen till den utsedda lyssnaren för behandling.

Händelsestyrd programmering i Node.js

Händelseslingan i JavaScript, som utgör en hörnsten i den asynkrona karaktären hos Node.js runtime, utnyttjar sin inneboende händelsestyrda arkitektur genom att utnyttja den inbyggda EventEmitter-modulen för att säkerställa en oavbruten och effektiv utveckling av verksamheten.

Med hjälp av en händelsestyrd metod möjliggör Node.js utveckling av serverbaserade applikationer som kan hantera användarinteraktivitet, input/output-operationer och databehandling i realtid, allt utan hindrande blockeringsmekanismer, vilket optimerar den övergripande effektiviteten och ger en sömlös användarupplevelse.

Att implementera händelsestyrd programmering i Node.js kan vara en enkel process när man har en omfattande förståelse för de grundläggande principerna för att definiera, aktivera och hantera händelser.

Klassen EventEmitter

Genom att använda klassen EventEmitter i Node.js kan man skapa egna händelser och koppla till eventlistare för att hantera dem. För att integrera klassen i min kod ska du importera den från eventmodulevia detta:

 // CommonJS
const { EventEmitter } = require("events")

// ES6
import { EventEmitter } from "events" 

När en instans av klassen EventEmitter har skapats blir den tillgänglig i din applikation för att utnyttjas. Detta gör det möjligt att initiera processer för sändning och hantering av händelser.

Till exempel:

 const FoodEvents = new EventEmitter()

användning av “on”-metoden, tillägg av en lyssnare via “addListener”-strategin och aktivering av “once”-metoden.

Användningen av on egenskapen utgör den grundläggande operationen för att införliva händelsehanterare, med addEventListener() metoden som presenterar en identisk kapacitet för att ta emot händelsemeddelanden. Båda mekanismerna kräver att den angivna händelsen specificeras tillsammans med en skräddarsydd funktion som fungerar som den reaktiva komponenten. Det är möjligt att använda dessa alternativ sömlöst.

Följ dessa steg för att använda “on”-metoden för att hantera en specifik händelse:

 FoodEvents.on("cookie_ready", (data) => {
    console.log("Cookie ready for packaging, data received: ", data);
})

Istället för att använda händelsen “on” i JavaScript kan man använda metoden “addListener” som ett direkt substitut.

 FoodEvents.addListener("cookie_ready", (data) => {
    console.log(
        "Cookie will now be packaged and sent out, data received: ",
        data
    );
})

Båda sätten att lägga till en callback-funktion i listan över event listeners för eventet “cookie\_ready” säkerställer att de exekveras sekventiellt när de utlöses. Anrop av endera resulterar i exekvering av dess respektive callback-funktion.

Implementeringen av denna funktion innebär att man registrerar en event-lyssnare som utlöses när den angivna händelsen inträffar för endast en instans. När funktionen har utförts tas lyssnaren bort från listan över aktiva lyssnare för den specifika händelsen.

För att underlätta en singulär händelse, använd Singleton-mönstret tillsammans med Unity-behållaren. Detta tillvägagångssätt säkerställer att endast en enda instans av den avsedda klassen skapas och underhålls under hela applikationens livstid, vilket effektivt hanterar omfattningen av händelsen i fråga.

 FoodEvents.once("cookie_sent", (data) => {
    console.log("Cookie is sent out, data received: ", data);
})

I det här scenariot kommer avsändaren att hantera händelsen cookie\_sent endast en gång och radera callback-funktionen efter att den har utförts.

De ovan nämnda teknikerna ger alla upphov till källans entitet, vilket möjliggör på varandra följande anrop av en enda metod bland dem.

Kom ihåg att för att någon ska kunna bearbeta en händelse, måste motsvarande applikation släppa den genom att sända händelsen vid något tillfälle. Följande exempel visar hur händelsen cookie\_ready sänds ut med hjälp av metoden emit:

 function bakeCookie() {
    console.log("Cookie is baking, almost ready...")

    setTimeout(() => {
        FoodEvents.emit("cookie_ready", { flavor: "vanilla cookie" })
    }, 3000)
}

bakeCookie() 

När man kör den angivna koden, som visar ett meddelande i konsolen om att kakan förbereds, pausar i tre sekunder och utlöser händelsen cookie\_ready, kan man förvänta sig en visuell representation som liknar den som visas i grafiken:

Ovanstående exempel tjänar till att illustrera den kronologiska utvecklingen av eventlyssnare, som följer den registreringssekvens i vilken de rekryterades.

Klassen EventEmitter innehåller fler metoder, bland annat:

Funktionen removeListener används för att eliminera en lyssnare från samlingen av händelsehanterare som är associerade med ett visst element eller objekt, medan den alternativa metoden off , ger liknande funktionalitet.

Metoden prependListener används för att registrera en lyssnare med en angiven händelsemitterare och placera den i början av listan över lyssnare för den aktuella händelsen. Till skillnad från metoden addListener som lägger till nya lyssnare i slutet av en befintlig lyssnarkö, säkerställer metoden prependListener att den nyligen tillagda lyssnaren körs före alla andra tidigare registrerade lyssnare.

Funktionen prependOnceListener fungerar på samma sätt som prependListener , med den viktiga skillnaden att den angivna lyssnaren körs endast en gång, analogt med beteendet som uppvisas av metoden once .

Funktionen removeAllListeners används för att eliminera alla prenumeranter som är kopplade till en viss angiven förekomst, eller varje lyssnare om inget argument anges.

Funktionen listeners returnerar en matris med alla lyssnare som är kopplade till en viss händelse, som skickas som ett argument till funktionen.

Det medföljande kodavsnittet möjliggör hämtning av en matris som innehåller alla händelsenamn för vilka en lyssnare tidigare har registrerats.

I Node.js är det vanligt att begränsa antalet lyssnare som kan registreras för en händelse för att undvika potentiella minnesläckor. Som standard kommer plattformen att utfärda en varning om fler än tio lyssnare läggs till i en händelse. Denna begränsning kan dock åsidosättas med hjälp av metoden setMaxListeners . Dessutom kan man använda funktionen getMaxListeners för att fastställa det aktuella maximala antalet lyssnare som tillåts för ett specifikt objekt.

Händelsepaketet erbjuder en robust uppsättning funktioner som är utformade för att underlätta händelsebaserad programmering i Node.js-miljön.

Vilka är de bästa metoderna för händelsestyrd programmering?

När man skapar programvarusystem som bygger på händelser är det viktigt att känna till de potentiella nackdelar som är förknippade med varje metod. Om du inte använder optimala tekniker kan det leda till negativa resultat för ditt program. Med detta i åtanke följer här några viktiga riktlinjer som man bör ha i åtanke när man utvecklar händelsebaserade applikationer:

Se till att namngivningen av händelser är både kortfattad och informativ, för att främja en välorganiserad och lättskött programmeringsmiljö.

Att implementera effektiva tekniker för felhantering och loggning är avgörande för att underlätta felsökning av problem som kan uppstå under applikationsutvecklingen.Genom att implementera dessa bästa metoder kan utvecklare effektivt identifiera och lösa eventuella problem som uppstår i deras kodbas och därigenom säkerställa en smidigare och mer tillförlitlig användarupplevelse.

Använd asynkrona programmeringskonstruktioner, som Promises och async/await, för att minska problemet med nästlade callbacks i händelsehanteringen. Detta tillvägagångssätt erbjuder en mer elegant lösning jämfört med att förlita sig på besvärliga nesting-tekniker.

Det är tillrådligt att undvika att skapa ett alltför stort antal lyssnare för en enskild händelse, eftersom detta kan leda till prestandaproblem. Överväg istället att dela upp händelserna och länka samman dem i sekvens för att säkerställa optimal effektivitet.

Bygg applikationer med rätt arkitektur

När man konstruerar programvara är det viktigt att göra välgrundade val av arkitektur och design för att undvika potentiella fallgropar längre fram. Om man inte följer en sund utvecklingsstrategi kan det leda till oönskade resultat för din applikation.

Händelsestyrd programmering är en designfilosofi som på ett avgörande sätt kan påverka en applikations struktur och effektivitet. Om ditt program eller någon komponent i det är beroende av händelser för att fungera, kan händelsestyrd programmering vara värt att överväga som en lämplig metod.