Events บน Node.js

7 July 2021

Event คือสิ่งที่โปรแกรมใช้เพื่อติดต่อสื่อการกันในรูปแบบของการส่งและรับสัญญาณที่เรียกว่า Event แนวคิดนี้เหมือนกับการส่งสัญญาณวิทยุ ผู้ส่งส่งสัญญาณไปยังผู้รับอาจมีหนึ่งหรือหลายคน และเมื่อได้รับสัญญาณแล้วแต่ละคนสามารถตอบสนองต่อเหตุการณ์ที่เกิดขึ้นได้ในรูปแบบที่แตกต่างกัน แนวคิิดนี้ถูกนำมาใช้กับ Event ในการเขียนโปรแกรม

Node.js ทำงานภายใต้รากฐานของ Event สำหรับการทำงานหลักของระบบ และใช้ Evet ในโมดูลเป็นจำนวนมาก ดังนั้นมันจึงเป็นเรื่องพื้นฐานที่่คุณจำเป็นต้องทราบเมื่อเขียนโปรแกรมบน Node.js และนี่เป็นเนื้อหาที่เราจะพูดถึงในบทนี้

  • Events บน Node.js
  • การสร้างและใช้งาน Event
  • Event listeners
  • Event parameters
  • Event once listener
  • Unregister event listeners
  • Node.js internal events
  • เมธอดของคลาส EventEmitter

Events บน Node.js

Event บน Node.js ได้รับแรงบันดาลใจมาจากการทำงานของ Event บนเว็บเบราว์เซอร์ ซึ่งเป็นวิธีที่โปรแกรมที่ทำงานในรูปแบบ Asynchronous ใช้เพื่อติดต่อสื่อสารกัน ยกตัวอย่างเช่น เมื่อผู้ใช้งานคลิกเมาส์หรือมีปฏิสัมพันธ์บางอย่างกับหน้าเว็บเพจ เราสามารถรับฟัง Event และทำงานบางอย่างเพื่อตอบสนองต่อการกระทำเหล่านั้นได้ เป็นต้น

Node.js ถูกออกแบบมาให้ทำงานในรูปแบบ Asynchronous โดยปริยาย ดังนั้นเราสามารถใช้งาน Event เพื่อทำให้โปรแกรมสามารถติดต่อสื่อการกันได้โดยที่ไม่ต้องสนใจว่า Event จะเกิดขึ้นเมื่อไร แต่เมื่อมันเกิดขึ้นแล้วเราสามารถรับฟัง Event และรับมือกับมันโดยทำงานบางอย่างเพื่อสอบสนอง Event ที่เกิดขึ้นได้

Node.js มีคลาส EventEmitter ซึ่งเป็นคลาสหลักของระบบที่เราสามารถใช้สำหรับส่งและรับ Event เพื่อให้ส่วนของโปรแกรมาสามารถติดต่อสื่อสารกันได้ และมันเป็นคลาสพื้นฐานที่ใช้ในระบบ Event หลักของ Node.js เอง และในบทนี้เราจะเรียนรู้เกี่ยวกับการใช้งานคลาสนี้

การสร้างและใช้งาน Event

Node.js นั้นมีโมดูล events ที่ประกอบไปด้วยคลาส EventEmitter ที่ใช้สำหรับการสร้าง Event สำหรับติดต่อสื่อสารกันในโปรแกรม เรามาเริ่มต้นสร้างออบเจ็คของ Event เพื่อใช้สำหรับส่งและรับ Event บน Node.js นี่เป็นตัวอย่างแรกของเรา

simple_event.js
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

eventEmitter.on('start', () => {
    console.log('Handing start event');
});

eventEmitter.emit('start');

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

Handing start event

ในตัวอย่างนี้ เป็นโปรแกรมสำหรับส่งและรับ Event อย่างง่ายบน Node.js เราได้นำเข้าโมดูล events ที่ประกอบไปด้วยคลาส EventEmitter ที่สามารถนำมาสร้างออบเจ็คสำหรับส่งและรับ Event บน Node.js ได้

const eventEmitter = new EventEmitter();

ออบเจ็ค eventEmitter เป็นออบเจ็คของ Event ที่เราสามารถใช้สำหรับส่งและรับ Event ได้โดยการเรียกใช้เมธอดต่างๆ บนออบเจ็คเอง

eventEmitter.on('start', () => {
    console.log('Handing start event');
});

ในการที่จะทำให้โปรแกรมทราบได้เมื่อเกิด Event ขึ้น เราจะต้องลงทะเบียน Event ด้วยเมธอด on ก่อนโดยกำหนดพารามิเตอร์แรกเป็นชื่อของ Event ที่ต้องการรับฟัง และพารามิเตอร์ที่สองเป็นฟังก์ชัน Callback ที่จะทำงานเมื่อเกิด Event นี้ขึ้น

eventEmitter.emit('start');

ในการส่ง Event หรือทำให้มันเกิดขึ้น เราสามารถเรียกใช้เมธอด emit พร้อมกับระบุชื่อของ Event ที่ต้องการส่ง นี่จะทำให้ฟังก์ชันลงทะเบียนเพื่อรับนี้ Event ทำงานที่เรากำหนดไปก่อนหน้าด้วยเมธอด on ในตัวอย่างนี้เป็นการส่ง Event start

ในตัวอย่างก่อนหน้า เป็นการส่งและรับเพียงหนึ่ง Event เท่านั้น อย่างไรก็ตาม ในหนึ่ง Event ออบเจ็ค มันสามารถใช้เพื่อส่งและรับหลาย Event พร้อมกันได้ ในตัวอย่างนี้ เราจะทำงานกับสอง Event ในออบเจ็คเดียวกัน

send_multiple_events.js
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

eventEmitter.on('a', () => {
    console.log('a event happened');
});

eventEmitter.on('b', () => {
    console.log('b event happened');
});

eventEmitter.emit('b');
eventEmitter.emit('a');

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

b event happened
a event happened

ในตัวอย่างนี้ เราได้ลงทะเบียนฟังก์ชันสำหรับรับฟังสอง Event ที่จะเกิดขึ้น นั่นคือ a และ b จากนั้นเรียกใช้เมธอด emit เพื่อส่ง Event ทั้งสอง

eventEmitter.emit('b');
eventEmitter.emit('a');

เราได้ทำการส่ง Event b และตามด้วย a และอย่างที่เห็นชัดเจนกว่าฟังก์ชันที่กำหนดสำหรับ Event b จะทำงานก่อน a ซึ่งหมายความว่าฟังก์ชันจะทำงานตามลำดับของ Event ที่เกิดขึ้นเสมอ

สำหรับ Event ใดๆ นั้นสามารถเกิดขึ้นหลายครั้งได้ในขณะที่โปรแกรมทำงาน ยกตัวเช่น ในเว็บซื้อขาย ถ้าหากผู้เพิ่มสินค้าลงในตระกร้า เราสามารถส่ง Event สำหรับการกระทำดังกล่าวเพื่อให้ส่วนอื่นของโปรแกรมทำงานได้ ซึ่งการเพิ่มสินค้าลงในตระกร้าอาจเกิดขึ้นได้หลายครั้งนั่นเอง มาดูตัวอย่างที่สอดคล้องกับเหตุการณ์นี้

send_multiple_times.js
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

eventEmitter.on('addCart', () => {
    console.log('addCart event happened: ' + new Date().toUTCString());
});

eventEmitter.on('confirmOrder', () => {
    console.log('confirmOrder event happened');
});

eventEmitter.emit('addCart');
eventEmitter.emit('addCart');

setTimeout(() => {
    eventEmitter.emit('addCart');
}, 3000);

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

a event happened: Fri, 04 Jun 2021 18:46:07 GMT
a event happened: Fri, 04 Jun 2021 18:46:07 GMT
a event happened: Fri, 04 Jun 2021 18:46:10 GMT

ในตัวอย่างนี้ เราได้ลงทะเบ่ียนฟังก์ชันเพื่อรับฟังก์ชัน Event addCart และ confirmOrder เช่นเดิม และเราได้ส่ง Event addCart ถึงสามครั้ง

eventEmitter.emit('addCart');
eventEmitter.emit('addCart');

setTimeout(() => {
    eventEmitter.emit('addCart');  
}, 3000);

สองครั้งแรกเป็นการส่ง Event แบบปกติ ส่วนครั้งที่สามเป็นการส่งในฟังก์ชัน setTimeout หลังจากที่เวลาผ่านไป 3 วินาที จะเห็นว่าในการส่ง Event แต่ละครั้งจะทำให้ฟังก์ชันที่ลงทะเบียนสำหรับ Event ดังกล่าวทำงานใหม่เสมอ

ส่วนฟังก์ชันรับฟังก์ของ Event confirmOrder จะไม่ทำงาน เนื่องจากเราไม่ได้ส่ง Event นี้เลย ดังนั้นเป็นไปได้ที่จะมีการลงทะเบียนเพื่อรับฟัง Event แต่มันอาจไม่เกิดขึ้น ซึ่งนี่ก็เหมือนกับการที่ผู้ใช้งานอาจเพิ่มสินค้าไปยังตระกร้า แต่พวกเขาอาจไม่ได้ยืนยันคำสั่งซื้อ

Event listeners

Event สามารถลงทะเบียนหลายฟังก์ชัน Listener เพื่อรับฟังเมื่อเกิด Event ขึ้นได้ ซึ่งก็เหมือนกับวิทยุหลายเครื่องสามารถรับฟังสัญญาณวิทยุที่ถูกส่งออกไป ในตัวอย่างนี้ เป็นการกำหนดตัวรับฟัง Event หลายตัวที่จะถูกทำงานเมื่อเกิด Event ขึ้น

multiple_listeners.js
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

eventEmitter.on('hello', () => {
    console.log('Ethan received an event.');
});

eventEmitter.on('hello', () => {
    console.log('Chris received an event.');
});

eventEmitter.on('hello', () => {
    console.log('Mia received an event.');
});

eventEmitter.emit('hello');

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

Ethan received an event.
Chris received an event.
Mia received an event.

ในตัวอย่างนี้ มีการลงทะเบียนสามฟังก์ชันเพื่อรับฟัง Event hello และเมื่อ Event ถูกส่งออกไป แต่ละฟังก์ชันจะทำงานตามที่กำหนด ทุกฟังก์ชันไม่จำเป็นต้องทำงานเหมือนกัน มันขึ้นอยู่กับว่าแต่ละฟังก์ชันนั้นต้องการทำงานอะไรหรือตอบสนองอย่างไรเมื่อเกิด Event ขึ้น

eventEmitter.on('hello', () => {
    console.log('Ethan received an event.');
});

eventEmitter.on('hello', () => {
    console.log('Leon received an event.');
});

eventEmitter.on('hello', () => {
    console.log('Mia received an event.');
});

เมื่อเราลงทะเบียนเพื่อรับฟัง Event มากกว่าหนึ่งอัน ฟังก์ชันเหล่านี้จะถูกเรียกใช้งานอย่างเป็นลำดับ (Synchronous) ตามที่มันถูกลงทะเบียนเอาไว้ ดังนั้นจึงสามารถยืนยันได้ว่า Ethan จะได้รับ Event ก่อน Leon และ Mia เสมอ

Event parameters

ในการส่ง Event ด้วยเมธอด emit เราสามารถส่งค่าเข้าไปยังฟังก์ชัน Callback ที่รับฟัง Event ได้โดยระบุค่าที่ต้องการส่งตั้งแต่อาร์กิวเมนต์ที่สองเป็นต้นไป ในตัวอย่างนี้ เราพัฒนาระบบของ Event ที่รอรับฟังเมื่อมีการเข้าสู่ระบบเกิดขึ้นพร้อมกับส่งข้อมูลบางอย่างไปกับ Event

login_event.js
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

eventEmitter.on('login', (name) => {
    console.log('Handler A');
    console.log('User logged in: ' + name);
});

eventEmitter.on('login', (name) => {
    console.log('Handler B');
    console.log('Save login info to Database');
    console.log({
        name: name,
        time: new Date().toUTCString()
    });
});

eventEmitter.emit('login', 'Metin');

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

Handler A
User logged in: Metin
Handler B
Save login info to Database
{ name: 'Metin', time: 'Fri, 04 Jun 2021 18:58:04 GMT' }

ในตัวอย่างนี้ เราได้ลงทะเบียนสองฟังก์ชันสำหรับรับฟัง Event login ขึ้น ฟังก์ชันแรกให้แสดงข้อความแจ้งบอกว่ามีการเข้าสู่ระบบ ส่วนฟังก์ชันที่สองเป็นการจำลองการบันทึกข้อมูลการเข้าสู่ระบบลงในฐานข้อมูล

eventEmitter.emit('login', 'Metin');

และนี่เป็นการส่ง Event login พร้อมกับอาร์กิวเมนต์ที่เป็น String ซึ่งนี่จะถูกส่งผ่านเข้าไปยังพารามิเตอร์ name ของฟังก์ชัน Callback

นอกจากค่าของ Literal แล้ว คุณสามารถส่งออบเจ็คหรือข้อมูลประเภทใดๆ ในภาษา JavaScript ผ่านอาร์กิวเมนต์ของเมธอด emit ได้ ยกตัวอย่างเช่น

eventEmitter.on('login', (user) => {
    // do something
});

let user = { id: 1, name: 'Metin' };
eventEmitter.emit('login', user);

และนอกจากนี้ คุณยังสามารถส่งหลายพารามิเตอร์ไปยังฟังก์ชัน Callback ได้เช่นกัน ในรูปแบบต่อไปนี้

eventEmitter.on('myEvent', (param1, param2, ...)) => {
    // do something
});

eventEmitter.emit('myEvent', arg1, arg2, ...);

แต่สังเกตว่าค่าที่ส่งเข้าไปยังฟังก์ชันผ่านเมธอด emit จะเริ่มต้นจากอาร์กิวเมนต์ที่สองเสมอ และในตอนที่รับค่าในฟังก์ชัน Callback จะเริ่มจากพารามิเตอร์แรก

Event once listener

ในการกำหนดฟังก์ชันเพื่อรับฟังการเกิดขึ้นของ Event บน Node.js นั้น มันเป็นไปได้ที่เราจะกำหนดฟังก์ชันเพื่อให้ทำงานเพียงครั้งเดียวโดยการลงทะเบียนฟังก์ชันสำหรับ Event ด้วยเมธอด once นี่เป็นตัวอย่าง

click_event.js
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

eventEmitter.once('click', (id) => {
    console.log('First click happened on: ' + new Date().toUTCString());
    console.log('Click ID: ' + id);
});

eventEmitter.emit('click', 1);
eventEmitter.emit('click', 2);

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

First click happened on: Fri, 04 Jun 2021 19:36:23 GMT
Click ID: 1

ในตัวอย่างนี้ เราได้ใช้เมธอด once สำหรับลงทะเบียนเพื่อรับฟังการเกิดขึ้นของ Event click จากนั้นเราได้ทำการส่ง Event สองครั้งด้วยเมธอด emit จะเห็นว่ามีเพียงการส่ง Event ครั้งแรกเท่านั้นที่ส่งผลให้ฟังก์ชันทำงาน

นั่นหมายความว่าคุณสามารถใช้ฟังก์ชัน once ในกรณีที่ต้องการทำงานแค่เพียงครั้งแรกครั้งเดียวเท่านั้น และเกิดเฉยต่อ Event ที่ถูกส่งหลังจากนั้นทั้งหมด

นอกจากนี้ ยังมีอีกวิธีในการทำให้ Event ทำงานเพียงครั้งเดียวเหมือนกับการใช้เมธอด once โดยการยกเลิกการลงทะเบียนการรับฟังก์ชัน Event ด้วยเมธอด off นี่เป็นตัวอย่างการใช้งาน

remove_event.js
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

function handler() {
    console.log('Click event happened');
    eventEmitter.off('click', handler);
}

eventEmitter.on('click', handler);

eventEmitter.emit('click');
eventEmitter.emit('click');

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

Click event happened

ในตัวอย่างนี้ เป็นโปรแกรมที่มีการทำงานเหมือนกับในตัวอย่างก่อนหน้า นั่นคือให้ฟังก์ชัน Listener สำหรับ Event click ทำงานเพียงครั้งเดียว เราสามารถทำเช่นนี้ได้โดยการใช้เมธอด off เพื่อปิดการทำงานการรับฟัง Event เมื่อมันทำงานในครั้งแรกเสร็จสิ้น

function handler() {
    console.log('Click event happened');
    eventEmitter.off('click', handler);
}

แต่ในการยกเลิกการลงทะเบียนฟังก์ชัน Listener เราจำเป็นต้องประกาศฟังก์ชันให้มีชื่อด้วยเสมอ นี่จะใช้อ้างอิงโดยภาษา JavaScript ในตอนยกเลิกการลงการทะเบียน Event สำหรับฟังก์ชันดังกล่าว ดังนั้นเราประกาศฟังก์ชันที่มีชื่อว่า handler

eventEmitter.on('click', handler);

จากนั้นลงทะเบียนฟังก์ชันด้วยเมธอด on ด้วยชื่อของฟังก์ชันแทน และในตอนยกเลิกการลงทะเบียนด้วยเมธอด off เราใช้ชื่อของฟังก์ชันเดิม นี่จะทำให้ตัวจัดการ Event สามารถนำฟังก์ชันเดิมออกไปได้อย่างถูกต้อง

ดังนั้นในการยกเลิกลงทะเบียน Event จะต้องใช้ฟังก์ชันที่มีชื่อเท่านั้น ซึ่งไม่ใช่ฟังก์ชันแบบ Anonymous อย่างไรก็ตาม ในกรณีที่คุณต้องการให้ฟังก์ชัน Listener ทำงานเพียงครั้งเดียว เราแนะนำให้ใช้เมธอด once เนื่องจากมันถูกออกแบบมาสำหรับการทำงานในรูปแบบนี้

Unregister event listeners

อย่างไรก็ตาม เมธอด off ได้ถูกออกแบบมาเพื่อวัตถุประสงค์ที่แตกต่างกันออกไป และอย่างที่ได้บอกไปก่อนหน้า เราสามารถใช้มันเพื่อยกเลิกการลงทะเบียน Event ได้ และการได้เห็นตัวอย่างนี้จะช่วยให้คุณจินตนาการออกว่าเมื่อไรที่ึควรใช้มัน

นี่เป็นตัวอย่างโปรแกรมจำลองการตรวจสอบข้อผิดพลาดที่เกิดขึ้นในระบบ ซึ่งเมื่อมีข้อผิดพลาดเกิดขึ้น Event ของข้อผิดพลาดจะถูกส่ง และในการรับฟัง Event จะสนใจเพียงแค่ Event ที่เกิดขึ้นในเวลา 24 ชั่วโมงแรกเท่านั้น

remove_event_hadlers.js
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

let count = 0;
function errorHander() {
    console.log('Error happened ' + (++count));
}

eventEmitter.on('myError', errorHander);

setInterval(() => {
    console.log('Time: ' + new Date().toUTCString());
    eventEmitter.emit('myError');
}, 1000);

setTimeout(() => {
    eventEmitter.off('myError', errorHander);
}, 6000);

นึี่เป็นผลลัพธ์การทำงานของโปรแกรม

Time: Fri, 04 Jun 2021 20:18:32 GMT
Error happened 1
Time: Fri, 04 Jun 2021 20:18:33 GMT
Error happened 2
Time: Fri, 04 Jun 2021 20:18:34 GMT
Error happened 3
Time: Fri, 04 Jun 2021 20:18:35 GMT
Error happened 4
Time: Fri, 04 Jun 2021 20:18:36 GMT
Error happened 5
Time: Fri, 04 Jun 2021 20:18:37 GMT
Time: Fri, 04 Jun 2021 20:18:38 GMT
Time: Fri, 04 Jun 2021 20:18:39 GMT
Time: Fri, 04 Jun 2021 20:18:40 GMT
...

แทนที่จะใช้เวลา 24 ชั่วโมงเหมือนกับที่บอกไว้ เราได้ลดเวลาให้เหลือเพียง 5 วินาทีเพื่อความรวดเร็วในการเห็นผลการทำงานของโปรแกรม ในตัวอย่างนี้ เป็นการจำลองการทำงานของระบบที่จะส่ง Event เมื่อเกิดข้อผิดพลาดใดๆ ขึ้น

let count = 0;
function errorHander() {
    console.log('Error happened ' + (++count));
}

eventEmitter.on('myError', errorHander);

และเช่นเดิม เราลงทะเบียนฟังก์ชัน Listener เพื่อรับฟังก์ชัน Event เมื่อมันเกิดขึ้น โดยการลงทะเบียนฟังก์ชัน errorHander ด้วยเมธอด on และทุกครั้งที่ฟังก์ชันทำงาน เราจะนับการทำงานของมันด้วยตัวแปร count

setInterval(() => {
    console.log('Time: ' + new Date().toUTCString());
    eventEmitter.emit('myError');
}, 1000);

จากนั้นเป็นการจำลองเพื่อให้เกิดข้อผิดพลาดขึ้นในทุกๆ หนึ่งวินาทีโดยใช้ฟังกชัน setInterval หน่วงเวลาเพื่อส่ง Event และเราแสดงเวลาปัจจุบันในตอนที่เกิด Event ของข้อผิดพลาดขึ้นด้วย

setTimeout(() => {
    eventEmitter.off('myError', errorHander);
}, 6000);

หลังจากที่เวลาผ่านไป 6 วินาทีตามที่ได้กำหนดเป็นเวลาหน่วงของฟังก์ชัน setTimeout เรายกเลิกการลงทะเบ่ียนของฟังก์ชัน errorHander เพื่อไม่ให้ทำงานอีกต่อไปสำหรับ Event myError

และอย่างที่คุณเห็นในผลลัพธ์การทำงานของโปรแกรม ในฟังก์ชัน Callback ของฟังก์ชัน setInterval ยังคงทำงานต่อไป แต่ฟังก์ชัน errorHander ไม่ถูกเรียกใช้งานอีกต่อไปแล้วเนื่องจากมันถูกยกเลิกลงทะเบียนด้วยเมธอด off

และนี่เป็นวิธีหนึ่งในการประยุกต์ใช้งานเมธอด off เพื่อยกเลิกฟังก์ชัน Listener เพื่อไม่ให้ทำงาน จะเห็นว่าวัตถุประสงค์ของมันแตกต่างจากเมธอด once ซึ่งถูกออกแบบมาสำหรับการทำงานครั้งเดียว นั่นคือมันอาจจะทำงานหลายครั้งและก่อนที่จะถูกปิดการทำงานไป

Node.js internal events

ออบเจ็คส่วนมากบน Node.js ถูกออกแบบเพื่อให้ทำงานกับ Event โดยปริยาย คุณสามารถฟัง Event ที่ได้ออบเจ็ค process เพื่อตรวจสอบสถานะการทำงานของ Process ของโปรแกรม ยกตัวอย่างเช่น เราสามารถรับฟัง Event exit ที่จะเกิดขึ้นเมื่อ Process กำลังจะปิดตัวลงได้

process.on('exit', (code) => {
    console.log(`About to exit with code: ${code}`);
});
console.log('Hello MarcusCode');

หรือแม้แต่ในออบเจ็คที่ใช้สำหรับอ่านข้อมูลแบบ Stream นั้นก็ทำงานด้วย Event เช่นเดียวกัน นั่นจะทำให้เราสามารถรับฟังจาก Event สำหรับอ่านข้อมูลและทราบว่าเมื่อไหร่ที่การอ่านเสร็จสิ้น และดำเนินการกับข้อมูลเหล่านั้นต่อไป

const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
    console.log(`Received ${chunk.length} bytes of data.`);
});
readable.on('end', () => {
    console.log('There will be no more data.');
});

และก็นี่เป็นวิธีปกติที่ Event บน Node.js ทำงาน และถููกออกแบบให้มีการทำงานในรูปแบบของ Event จากโมดูลมาตรฐานส่วนใหญ่ของมัน

เมธอดของคลาส EventEmitter

นอกจากเมธอดพื้นฐานที่ได้เรียนรู้ไปแล้ว คลาส EventEmitter ยังมีเมธอดอื่นเพื่ออำนวยความสะดวกในการทำงานกับ Event นี่เป็นรายการของเมธอดอีกส่วนหนึ่งที่สามารถใช้จัดการ Event ได้บน Node.js

emitter.eventNames()

เป็นเมธอดที่ใช้เพื่อรับเอาชื่อของ Event ทั้งหมดที่ถูกลงทะเบียนเอาไว้ก่อนหน้า นี่จะส่งค่ากลับเป็นอาเรย์ของ String ของชื่อ Event ทั้งหมด

emitter.listenerCount(eventName)

เป็นเมธอดที่ใช้เพื่อนับจำนวนของฟังก์ชัน Listener ทั้งหมดที่ถูกลงทะเบ่ียนไว้ของสำหรับชื่ของ Event ที่ระบุ

emitter.prependListener(eventName, listener)

เป็นเมธอดที่ใช้เพื่อลงทะเบียน Event และใส่ฟังก์ชันไว้ที่หน้าคิวเพื่อให้ทำงานก่อนฟังก์ชันอื่นๆ

emitter.removeAllListeners([eventName])

เป็นเมธอดที่ใช้เพื่อยกเลิกฟังก์ชัน Listener ทั้งหมดที่ถูกลงทะเบียนสำหรับ Event หรือละเว้นชื่อของ Event เพื่อยกเลิกทั้งหมด

emitter.setMaxListeners(n)

เป็นเมธอดที่ใช้เพื่อกำหนดจำนวนสุงสุดของฟังก์ชัน Listener ที่สามารถลงทะเบียนได้สำหรับออบเจ็คของ Event

ในบทนี้ คุณได้เรียนรู้การใช้งาน Event บน Node.js เราได้พูดถึงการสร้างและใช้งาน Event จากคลาส EventEmitter แนะนำเมธอดต่างๆ สำหรับจัดการกับ Event ซึ่งนึี่เป็นวิธีที่มีประสิทธิภาพในการทำให้โปรแกรมสามารถติดต่อสื่อสารกันบน Node.js

กลุ่มหัดเขียนโปรแกรมภาษา Python

กลุ่มหัดเขียนโปรแกรมเบื้องต้น เข้าร่วมกลุ่มเพื่อสอบถามปัญหาเกี่ยวกับการเขียนโปรแกรมในภาษาต่างๆ

เข้าร่วมกลุ่ม
บทความนี้เป็นประโยชน์หรือไม่? Yes · No