ในโหนดวัตถุจำนวนมากปล่อยเหตุการณ์ ตัวอย่างเช่นเซิร์ฟเวอร์ TCP จะส่งเหตุการณ์ "เชื่อมต่อ" เมื่อใดก็ตามที่ไคลเอนต์ร้องขอการเชื่อมต่อและตัวอย่างเช่นเมื่อใดก็ตามที่อ่านข้อมูลทั้งหมดระบบไฟล์จะส่งเหตุการณ์ "ข้อมูล" วัตถุเหล่านี้เรียกว่าตัวปล่อยเหตุการณ์ในโหนด ตัวส่งสัญญาณเหตุการณ์อนุญาตให้โปรแกรมเมอร์สมัครรับเหตุการณ์ที่น่าสนใจและผูกฟังก์ชันการโทรกลับกับเหตุการณ์ที่เกี่ยวข้องเพื่อให้ฟังก์ชั่นการโทรกลับถูกเรียกเมื่อใดก็ตามที่ตัวส่งสัญญาณเหตุการณ์ปล่อยเหตุการณ์ โหมดการเผยแพร่/สมัครสมาชิกคล้ายกับโหมด GUI แบบดั้งเดิมเช่นโปรแกรมจะได้รับการแจ้งเตือนที่สอดคล้องกันเมื่อคลิกปุ่ม การใช้โมเดลนี้โปรแกรมเซิร์ฟเวอร์สามารถตอบสนองเมื่อมีบางเหตุการณ์เกิดขึ้นเช่นการเชื่อมต่อไคลเอนต์ข้อมูลที่มีอยู่ในซ็อกเก็ตหรือปิดไฟล์
คุณยังสามารถสร้างเครื่องส่งสัญญาณกิจกรรมของคุณเอง ในความเป็นจริงโหนดให้บริการพิเศษ Eventemitter Pseudo-class ที่สามารถใช้เป็นคลาสพื้นฐานเพื่อสร้างตัวส่งสัญญาณกิจกรรมของคุณเอง
เข้าใจโหมดการโทรกลับ
การเขียนโปรแกรมแบบอะซิงโครนัสไม่ได้ใช้ค่าการส่งคืนฟังก์ชั่นเพื่อระบุการสิ้นสุดของการเรียกใช้ฟังก์ชัน แต่ใช้รูปแบบการส่งผ่านที่ตามมา
"สไตล์การผ่านความต่อเนื่อง" (CPS: สไตล์การผ่านความต่อเนื่อง) เป็นรูปแบบการเขียนโปรแกรมและการควบคุมกระบวนการจะถูกส่งผ่านไปยังการดำเนินการครั้งต่อไปอย่างชัดเจน ...
ฟังก์ชั่นสไตล์ CPS จะยอมรับฟังก์ชั่นเป็นพารามิเตอร์พิเศษ ฟังก์ชั่นนี้ใช้เพื่อชี้ให้เห็นถึงกระบวนการควบคุมโปรแกรมต่อไปอย่างชัดเจน เมื่อฟังก์ชั่น CPS คำนวณ "ค่าส่งคืน" มันจะเรียกฟังก์ชันที่แสดงถึงกระบวนการต่อไปของโปรแกรมและใช้ "ค่าคืน" ของฟังก์ชัน CPS เป็นพารามิเตอร์
จาก Wikipedia - http://en.wikipedia.org/wiki/continuation-passing_style
ในรูปแบบการเขียนโปรแกรมนี้แต่ละฟังก์ชั่นจะเรียกฟังก์ชั่นการโทรกลับหลังจากดำเนินการเพื่อให้โปรแกรมสามารถทำงานต่อไปได้ คุณจะเข้าใจในภายหลังว่า JavaScript เหมาะมากสำหรับสไตล์การเขียนโปรแกรมนี้ นี่คือตัวอย่างของการโหลดไฟล์ลงในหน่วยความจำภายใต้โหนด:
การคัดลอกรหัสมีดังนี้:
var fs = ต้องการ ('fs');
fs.readfile ('/etc/passwd', ฟังก์ชั่น (err, fileContent) {
ถ้า (err) {
โยนเอ่อ;
-
console.log ('เนื้อหาไฟล์', fileContent.toString ());
-
ในตัวอย่างนี้คุณผ่านฟังก์ชันที่ไม่ระบุชื่อแบบอินไลน์เป็นพารามิเตอร์ที่สองของ fs.readfile ในความเป็นจริงนี่คือการใช้การเขียนโปรแกรม CPS เพราะคุณส่งผ่านกระบวนการที่ตามมาของการดำเนินการโปรแกรมไปยังฟังก์ชั่นการโทรกลับ
อย่างที่คุณเห็นพารามิเตอร์แรกของฟังก์ชั่นการเรียกกลับเป็นวัตถุข้อผิดพลาด หากเกิดข้อผิดพลาดในโปรแกรมพารามิเตอร์นี้จะเป็นอินสแตนซ์ของคลาสข้อผิดพลาด นี่เป็นรูปแบบทั่วไปสำหรับการเขียนโปรแกรม CPS ในโหนด
เข้าใจโหมดเครื่องส่งสัญญาณเหตุการณ์
ในโหมดการโทรกลับมาตรฐานฟังก์ชั่นจะถูกส่งผ่านเป็นพารามิเตอร์ไปยังฟังก์ชันที่จะดำเนินการ โหมดนี้ทำงานได้ดีมากในสถานการณ์ที่ลูกค้าจำเป็นต้องได้รับการแจ้งเตือนหลังจากฟังก์ชั่นเสร็จสิ้น อย่างไรก็ตามหากมีหลายเหตุการณ์เกิดขึ้นระหว่างการดำเนินการของฟังก์ชั่นหรือเหตุการณ์เกิดขึ้นหลายครั้งรูปแบบนี้ไม่เหมาะสม ตัวอย่างเช่นหากคุณต้องการได้รับการแจ้งเตือนทุกครั้งที่ซ็อกเก็ตได้รับข้อมูลที่มีอยู่คุณจะพบว่าโหมดการโทรกลับมาตรฐานไม่มีประโยชน์มากในสถานการณ์นี้ ในเวลานี้โหมดเครื่องส่งสัญญาณเหตุการณ์มีประโยชน์ คุณสามารถใช้ชุดอินเทอร์เฟซมาตรฐานเพื่อแยกตัวสร้างเหตุการณ์และฟังเหตุการณ์อย่างชัดเจน
เมื่อใช้โหมดตัวสร้างเหตุการณ์จะมีวัตถุสองวัตถุขึ้นไป - มีการส่งสัญญาณและผู้ฟังเหตุการณ์อย่างน้อยหนึ่งรายการ
ตัวส่งสัญญาณเหตุการณ์ตามชื่อแนะนำเป็นวัตถุที่สามารถสร้างเหตุการณ์ได้ ผู้ฟังเหตุการณ์คือรหัสที่ถูกผูกไว้กับตัวส่งสัญญาณเหตุการณ์เพื่อฟังเหตุการณ์เฉพาะประเภทเช่นตัวอย่างต่อไปนี้:
การคัดลอกรหัสมีดังนี้:
var req = http.request (ตัวเลือก, ฟังก์ชั่น (การตอบสนอง) {
Response.on ("data", function (data) {
console.log ("ข้อมูลบางอย่างจากการตอบสนอง", ข้อมูล);
-
Response.on ("end", function () {
console.log ("การตอบสนองสิ้นสุดลง");
-
-
req.end ();
รหัสนี้แสดงให้เห็นถึงสองขั้นตอนที่จำเป็นเมื่อสร้างคำขอ HTTP เพื่อเข้าถึงเซิร์ฟเวอร์ HTTP ระยะไกลโดยใช้ HTTP.Request API ของ Node (ดูบทต่อไป) บรรทัดแรกใช้ "สไตล์การผ่านความต่อเนื่อง" (CPS: สไตล์การผ่านความต่อเนื่อง) ผ่านฟังก์ชั่นอินไลน์ที่จะเรียกเมื่อ HTTP ตอบสนอง HTTP Request API ใช้ CPS ที่นี่เนื่องจากโปรแกรมจำเป็นต้องดำเนินการต่อไปเพื่อดำเนินการต่อไปหลังจากที่ฟังก์ชั่น http.request ดำเนินการ
เมื่อมีการดำเนินการ http.request ฟังก์ชั่นการโทรกลับที่ไม่ระบุชื่อจะถูกเรียกและวัตถุตอบกลับ HTTP จะถูกส่งผ่านเป็นพารามิเตอร์ วัตถุตอบสนอง HTTP นี้เป็นตัวส่งสัญญาณเหตุการณ์ ตามเอกสารของโหนดมันสามารถปล่อยเหตุการณ์มากมายรวมถึงข้อมูลและสิ้นสุด ฟังก์ชั่นการโทรกลับที่คุณลงทะเบียนจะถูกเรียกทุกครั้งที่มีเหตุการณ์เกิดขึ้น
เป็นบทเรียนให้ใช้โหมด CPS เมื่อคุณต้องการเรียกคืนสิทธิ์การดำเนินการหลังจากการดำเนินการที่ร้องขอเสร็จสิ้นและใช้โหมดตัวส่งสัญญาณเหตุการณ์เมื่อเหตุการณ์สามารถเกิดขึ้นได้หลายครั้ง
ทำความเข้าใจประเภทเหตุการณ์
เหตุการณ์ที่ส่งมีประเภทที่แสดงโดยสตริง ตัวอย่างก่อนหน้านี้มีสองประเภทเหตุการณ์: "ข้อมูล" และ "สิ้นสุด" ซึ่งเป็นสตริงใด ๆ ที่กำหนดโดยตัวส่งสัญญาณเหตุการณ์ อย่างไรก็ตามมันเป็นเรื่องปกติที่ประเภทเหตุการณ์มักจะประกอบด้วยคำพิมพ์เล็กที่ไม่มีอักขระที่ว่างเปล่า
คุณไม่สามารถใช้รหัสเพื่ออนุมานประเภทของเหตุการณ์ที่เครื่องส่งสัญญาณเหตุการณ์สามารถสร้างได้เนื่องจาก API ตัวส่งสัญญาณเหตุการณ์ไม่มีกลไกการวิปัสสนาดังนั้น API ที่คุณใช้ควรมีเอกสารเพื่อระบุว่าสามารถปล่อยเหตุการณ์เหล่านั้นได้
เมื่อเหตุการณ์เกิดขึ้นเครื่องส่งสัญญาณเหตุการณ์จะเรียกผู้ฟังที่เกี่ยวข้องกับเหตุการณ์และส่งผ่านข้อมูลที่เกี่ยวข้องไปยังผู้ฟังเป็นพารามิเตอร์ ในตัวอย่างก่อนหน้านี้ http.request ฟังก์ชั่นการเรียกกลับเหตุการณ์ "ข้อมูล" ยอมรับวัตถุข้อมูลเป็นพารามิเตอร์แรกและเดียวในขณะที่ "สิ้นสุด" ไม่ยอมรับข้อมูลใด ๆ พารามิเตอร์เหล่านี้เป็นส่วนหนึ่งของสัญญา API นั้นถูกกำหนดโดยผู้เขียน API ลายเซ็นพารามิเตอร์ของฟังก์ชั่นการโทรกลับเหล่านี้จะถูกอธิบายในเอกสาร API ของแต่ละตัวส่งสัญญาณ
แม้ว่าตัวส่งสัญญาณเหตุการณ์จะเป็นอินเทอร์เฟซที่ให้บริการทุกประเภทของเหตุการณ์ แต่เหตุการณ์ "ข้อผิดพลาด" คือการใช้งานพิเศษในโหนด ตัวส่งสัญญาณเหตุการณ์ส่วนใหญ่ในโหนดจะสร้างเหตุการณ์ "ข้อผิดพลาด" เมื่อเกิดข้อผิดพลาดในโปรแกรม หากโปรแกรมไม่ฟังเหตุการณ์ "ข้อผิดพลาด" ของตัวส่งสัญญาณเหตุการณ์ตัวส่งสัญญาณเหตุการณ์จะสังเกตเห็นและโยนข้อยกเว้นที่ไม่ถูกต้องเมื่อเกิดข้อผิดพลาด
คุณสามารถเรียกใช้รหัสต่อไปนี้ใน Node Perl เพื่อทดสอบเอฟเฟกต์ซึ่งจำลองตัวส่งสัญญาณเหตุการณ์ที่สามารถสร้างสองเหตุการณ์:
การคัดลอกรหัสมีดังนี้:
var em = new (ต้องการ ('เหตุการณ์'). eventemitter) ();
em.emit ('event1');
em.emit ('ข้อผิดพลาด', ข้อผิดพลาดใหม่ ('ความผิดพลาดของฉัน'));
คุณจะเห็นผลลัพธ์ต่อไปนี้:
การคัดลอกรหัสมีดังนี้:
var em = new (ต้องการ ('เหตุการณ์'). eventemitter) ();
ไม่ได้กำหนด
> em.emit ('event1');
เท็จ
> em.emit ('ข้อผิดพลาด', ข้อผิดพลาดใหม่ ('ความผิดพลาดของฉัน'));
ข้อผิดพลาด: ความผิดพลาดของฉัน
ที่ REPL: 1: 18
ที่ replserver.eval (repol.js: 80: 21)
ที่ Ropp.js: 190: 20
ที่ replserver.eval (repol.js: 87: 5)
ที่อินเตอร์เฟส <ไม่ระบุชื่อ> (repol.js: 182: 12)
ที่ Interface.emit (Events.js: 67: 17)
ที่ interface._online (readline.js: 162: 10)
ที่ interface._line (readline.js: 426: 8)
ที่ interface._ttywrite (readline.js: 603: 14)
ที่ ReadStream. <Nonymous> (readline.js: 82: 12)
-
ในบรรทัดที่ 2 ของรหัสเหตุการณ์ที่เรียกว่า "Event1" ถูกปล่อยออกมาโดยไม่มีผลกระทบใด ๆ แต่เมื่อมีการปล่อยเหตุการณ์ "ข้อผิดพลาด" ข้อผิดพลาดจะถูกส่งไปยังสแต็ก หากโปรแกรมไม่ทำงานในสภาพแวดล้อมบรรทัดคำสั่ง Perl โปรแกรมจะล่มเนื่องจากข้อยกเว้นที่ไม่ได้รับการยกเว้น
การใช้ API ตัวส่งสัญญาณเหตุการณ์
วัตถุใด ๆ ที่ใช้โหมดส่งสัญญาณเหตุการณ์ (เช่นซ็อกเก็ต TCP, คำขอ HTTP ฯลฯ ) ใช้ชุดวิธีการต่อไปนี้:
การคัดลอกรหัสมีดังนี้:
.AddListener และ .on - เพิ่มฟังเหตุการณ์สำหรับเหตุการณ์ประเภทที่ระบุ
.once - ผูกผู้ฟังเหตุการณ์ที่ดำเนินการเพียงครั้งเดียวสำหรับเหตุการณ์ประเภทที่ระบุ
.removeEventListener - ลบผู้ฟังที่ถูกผูกไว้กับเหตุการณ์ที่ระบุ
.removealleventListener - ลบผู้ฟังทั้งหมดที่ถูกผูกไว้กับเหตุการณ์ที่ระบุ
มาแนะนำรายละเอียดด้านล่าง
ฟังก์ชั่นการโทรกลับโดยใช้. addlistener () หรือ. on ()
โดยการระบุประเภทเหตุการณ์และฟังก์ชั่นการโทรกลับคุณสามารถลงทะเบียนการกระทำที่ดำเนินการเมื่อเหตุการณ์เกิดขึ้น ตัวอย่างเช่นหากมีบล็อกข้อมูลที่พร้อมใช้งานเมื่อไฟล์อ่านสตรีมข้อมูลมันจะปล่อยเหตุการณ์ "ข้อมูล" รหัสต่อไปนี้แสดงวิธีการผ่านฟังก์ชั่นการโทรกลับเพื่อให้โปรแกรมบอกคุณว่าเหตุการณ์ข้อมูลเกิดขึ้น
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่นที่ได้รับ (ข้อมูล) {
console.log ("รับข้อมูลจากสตรีมอ่านไฟล์: %j", ข้อมูล);
-
readstream.addlistener ("ข้อมูล", ได้รับ);
นอกจากนี้คุณยังสามารถใช้. on ซึ่งเป็นเพียงตัวย่อของ. addlistener รหัสต่อไปนี้เหมือนกับด้านบน:
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่นที่ได้รับ (ข้อมูล) {
console.log ("รับข้อมูลจากสตรีมอ่านไฟล์: %j", ข้อมูล);
-
readstream.on ("ข้อมูล", ได้รับ);
ในรหัสก่อนหน้านี้คุณสามารถใช้ฟังก์ชั่นชื่อที่กำหนดไว้ล่วงหน้าเป็นฟังก์ชั่นการโทรกลับและคุณยังสามารถใช้ฟังก์ชันที่ไม่ระบุชื่อแบบอินไลน์เพื่อลดความซับซ้อนของรหัส:
การคัดลอกรหัสมีดังนี้:
readStream.on ("ข้อมูล", ฟังก์ชัน (ข้อมูล) {
console.log ("รับข้อมูลจากสตรีมอ่านไฟล์: %j", ข้อมูล);
-
ดังที่ได้กล่าวไว้ก่อนหน้านี้จำนวนพารามิเตอร์และลายเซ็นที่ส่งผ่านไปยังฟังก์ชั่นการโทรกลับขึ้นอยู่กับวัตถุส่งสัญญาณเหตุการณ์เฉพาะและประเภทเหตุการณ์ พวกเขาไม่ได้มาตรฐาน เหตุการณ์ "ข้อมูล" อาจผ่านวัตถุบัฟเฟอร์ข้อมูลเหตุการณ์ "ข้อผิดพลาด" ผ่านวัตถุข้อผิดพลาดและเหตุการณ์ "สิ้นสุด" ของโฟลว์ข้อมูลไม่ผ่านข้อมูลใด ๆ ไปยังผู้ฟังเหตุการณ์
ผูกผู้ฟังเหตุการณ์หลายรายการ
โหมดตัวส่งสัญญาณเหตุการณ์อนุญาตให้ฟังเหตุการณ์หลายรายการฟังประเภทเหตุการณ์เดียวกันของเครื่องส่งสัญญาณเหตุการณ์เดียวกันเช่น:
การคัดลอกรหัสมีดังนี้:
ฉันมีข้อมูลบางอย่างที่นี่
ฉันมีข้อมูลบางอย่างที่นี่ด้วย
ตัวส่งสัญญาณเหตุการณ์รับผิดชอบในการเรียกใช้ผู้ฟังทั้งหมดที่ผูกพันกับประเภทเหตุการณ์ที่ระบุในลำดับที่ผู้ฟังลงทะเบียนนั่นคือ:
1. เมื่อมีเหตุการณ์เกิดขึ้นผู้ฟังเหตุการณ์อาจไม่ถูกเรียกทันทีและอาจมีผู้ฟังเหตุการณ์อื่น ๆ ที่เรียกก่อนหน้านี้
2. มันผิดปกติที่จะถูกโยนลงไปที่สแต็กซึ่งอาจเป็นเพราะข้อผิดพลาดในรหัส เมื่อมีการส่งเหตุการณ์หากผู้ฟังเหตุการณ์ส่งข้อยกเว้นเมื่อมีการเรียกผู้ฟังเหตุการณ์บางคนอาจไม่ถูกเรียก ในกรณีนี้เครื่องส่งสัญญาณเหตุการณ์จับข้อยกเว้นและอาจจัดการได้
ดูตัวอย่างต่อไปนี้:
การคัดลอกรหัสมีดังนี้:
readStream.on ("ข้อมูล", ฟังก์ชัน (ข้อมูล) {
โยนข้อผิดพลาดใหม่ ("มีบางอย่างผิดปกติเกิดขึ้น");
-
readStream.on ("ข้อมูล", ฟังก์ชัน (ข้อมูล) {
console.log ('ฉันมีข้อมูลบางอย่างที่นี่ด้วย');
-
เนื่องจากผู้ฟังคนแรกโยนข้อยกเว้นผู้ฟังคนที่สองจะไม่ถูกเรียก
ใช้. remoVelistener () เพื่อลบผู้ฟังเหตุการณ์ออกจากตัวส่งสัญญาณเหตุการณ์
หากคุณไม่สนใจเหตุการณ์ในวัตถุอีกต่อไปคุณสามารถยกเลิกผู้ฟังเหตุการณ์ที่ลงทะเบียนได้โดยระบุประเภทเหตุการณ์และฟังก์ชั่นการโทรกลับเช่นนี้:
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่นที่ได้รับ (ข้อมูล) {
console.log ("รับข้อมูลจากสตรีมอ่านไฟล์: %j", ข้อมูล);
-
readstream.on ("ข้อมูล", ได้รับ);
-
readstream.removelistener ("ข้อมูล", ได้รับ);
ในตัวอย่างนี้บรรทัดสุดท้ายจะลบผู้ฟังเหตุการณ์ที่อาจเรียกได้ตลอดเวลาในอนาคตจากวัตถุส่งสัญญาณเหตุการณ์
ในการลบผู้ฟังคุณต้องตั้งชื่อฟังก์ชันการโทรกลับเนื่องจากชื่อของฟังก์ชั่นการโทรกลับจำเป็นเมื่อเพิ่มและลบ
ใช้. once () เพื่อเปิดใช้งานฟังก์ชั่นการโทรกลับที่จะดำเนินการได้มากที่สุดครั้งเดียว
หากคุณต้องการฟังกิจกรรมที่ดำเนินการมากที่สุดครั้งเดียวหรือสนใจในครั้งแรกที่เกิดเหตุการณ์คุณสามารถใช้ฟังก์ชั่น. once ():
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่นที่ได้รับ (ข้อมูล) {
console.log ("รับข้อมูลจากสตรีมอ่านไฟล์: %j", ข้อมูล);
-
readstream.once ("ข้อมูล", ได้รับ);
ในรหัสข้างต้นฟังก์ชันที่ได้รับจะถูกเรียกเพียงครั้งเดียว หากวัตถุ ReadStream ปล่อยเหตุการณ์ข้อมูลฟังก์ชั่นการโทรกลับที่ได้รับจะและจะถูกทริกเกอร์เพียงครั้งเดียว
จริงๆแล้วมันเป็นเพียงวิธีที่สะดวกเพราะมันสามารถนำไปใช้ได้ง่ายมากเช่นนี้:
การคัดลอกรหัสมีดังนี้:
var eventemitter = ต้องการ ("เหตุการณ์"). Eventemitter;
Eventemitter.prototype.once = function (type, callback) {
var that = this;
this.on (พิมพ์ฟังก์ชันฟัง () {
นั่นคือ removelistener (ประเภท, ผู้ฟัง);
การโทรกลับ APPLY (นั่นคือข้อโต้แย้ง);
-
-
ในรหัสข้างต้นคุณกำหนดฟังก์ชัน Eventemitter.prototype.once ใหม่และกำหนดฟังก์ชั่นหนึ่งครั้งของแต่ละวัตถุที่สืบทอดมาจาก Eventemitter รหัสใช้วิธี. on () เมื่อได้รับเหตุการณ์ให้ใช้. RemoveEventListener () เพื่อยกเลิกการลงทะเบียนของฟังก์ชันการโทรกลับและเรียกใช้ฟังก์ชันการโทรกลับดั้งเดิม
หมายเหตุ: รหัสก่อนหน้านี้ใช้วิธีการใช้ฟังก์ชัน () ซึ่งยอมรับวัตถุและใช้เป็นตัวแปรที่มีอยู่นี้และอาร์เรย์ของพารามิเตอร์ ในตัวอย่างก่อนหน้านี้อาร์เรย์พารามิเตอร์ที่ไม่ได้แก้ไขจะถูกส่งผ่านไปยังฟังก์ชั่นการโทรกลับผ่านตัวส่งสัญญาณเหตุการณ์
ลบผู้ฟังเหตุการณ์ทั้งหมดออกจากตัวส่งสัญญาณเหตุการณ์ด้วย. removealllisteners ()
คุณสามารถลบผู้ฟังทั้งหมดที่ลงทะเบียนกับประเภทเหตุการณ์ที่ระบุจากตัวส่งสัญญาณเหตุการณ์ดังนี้:
การคัดลอกรหัสมีดังนี้:
emitter.removealllisteners (ประเภท);
ตัวอย่างเช่นคุณสามารถยกเลิกการฟังสัญญาณขัดจังหวะกระบวนการทั้งหมดเช่นนี้:
การคัดลอกรหัสมีดังนี้:
Process.removeAlLlisteners ("Sigterm");
หมายเหตุ: เป็นบทเรียนขอแนะนำให้คุณใช้ฟังก์ชั่นนี้เฉพาะเมื่อคุณรู้ว่าสิ่งที่ถูกลบ มิฉะนั้นคุณควรปล่อยให้ส่วนอื่น ๆ ของแอปพลิเคชันลบคอลเลกชันฟังเหตุการณ์หรือคุณสามารถปล่อยให้ส่วนเหล่านั้นของโปรแกรมรับผิดชอบในการลบผู้ฟังด้วยตนเอง แต่ไม่ว่าจะเป็นอย่างไรฟังก์ชั่นนี้ยังคงมีประโยชน์ในบางสถานการณ์ที่หายากเช่นเมื่อคุณกำลังเตรียมที่จะปิดเครื่องส่งสัญญาณเหตุการณ์หรือปิดกระบวนการทั้งหมดในลักษณะที่เป็นระเบียบ
สร้างเครื่องส่งสัญญาณเหตุการณ์
เครื่องส่งสัญญาณเหตุการณ์ทำให้อินเทอร์เฟซการเขียนโปรแกรมทั่วไปมากขึ้นในวิธีที่ยอดเยี่ยม ในโหมดการเขียนโปรแกรมทั่วไปและเข้าใจง่ายไคลเอนต์เรียกฟังก์ชั่นต่าง ๆ โดยตรงในขณะที่ในโหมดส่งสัญญาณเหตุการณ์ไคลเอนต์จะถูกผูกไว้กับเหตุการณ์ต่าง ๆ ซึ่งจะทำให้โปรแกรมของคุณมีความยืดหยุ่นมากขึ้น (หมายเหตุของนักแปล: ประโยคนี้ไม่มั่นใจมากนักโพสต์ข้อความต้นฉบับ: Event Emitter ให้วิธีที่ยอดเยี่ยมในการสร้างอินเทอร์เฟซการเขียนโปรแกรมทั่วไปมากขึ้นเมื่อคุณใช้รูปแบบความเข้าใจทั่วไปลูกค้าผูกกับเหตุการณ์แทนที่จะเรียกใช้ฟังก์ชั่นทำให้โปรแกรมของคุณมีความยืดหยุ่นมากขึ้น
นอกจากนี้ด้วยการใช้เครื่องส่งสัญญาณเหตุการณ์คุณยังสามารถรับคุณสมบัติมากมายเช่นการเชื่อมโยงผู้ฟังที่ไม่เกี่ยวข้องหลายรายการในเหตุการณ์เดียวกัน
สืบทอดมาจากเครื่องส่งสัญญาณเหตุการณ์โหนด
หากคุณสนใจในโหมด Event Event Event ของ Node และตั้งใจที่จะใช้ในแอปพลิเคชันของคุณเองคุณสามารถสร้างคลาสหลอกได้โดยการสืบทอด Eventemitter:
การคัดลอกรหัสมีดังนี้:
util = ต้องการ ('util');
var eventemitter = ต้องการ ('เหตุการณ์') Eventemitter;
// นี่คือตัวสร้างของ MyClass:
var myclass = function () {
-
util.inherits (myclass, eventemitter);
หมายเหตุ: util.inherits สร้างห่วงโซ่ต้นแบบของ MyClass เพื่อให้อินสแตนซ์ myclass ของคุณสามารถใช้วิธีต้นแบบของ Eventemitter
เปิดงานกิจกรรม
โดยการสืบทอดจาก Eventemitter, MyClass สามารถเปิดตัวกิจกรรมเช่นนี้:
การคัดลอกรหัสมีดังนี้:
myclass.prototype.someMethod = function () {
this.emit ("เหตุการณ์ที่กำหนดเอง", "อาร์กิวเมนต์ 1", "อาร์กิวเมนต์ 2");
-
ในรหัสข้างต้นเมื่อวิธีการ somemethond ถูกเรียกโดยอินสแตนซ์ myclass เหตุการณ์ที่เรียกว่า "event cuteom" จะถูกปล่อยออกมา เหตุการณ์นี้จะปล่อยสองสตริงเป็นข้อมูล: "อาร์กิวเมนต์ 1" และ "อาร์กิวเมนต์ 2" ซึ่งจะถูกส่งผ่านเป็นพารามิเตอร์ไปยังผู้ฟังเหตุการณ์
ไคลเอนต์ของอินสแตนซ์ MyClass สามารถฟังเหตุการณ์ "เหตุการณ์ที่กำหนดเอง" เช่นนี้:
การคัดลอกรหัสมีดังนี้:
var myinstance = new myclass ();
myinstance.on ('เหตุการณ์ที่กำหนดเอง', ฟังก์ชั่น (str1, str2) {
console.log ('มีเหตุการณ์ที่กำหนดเองด้วย str1 %s และ str2 %s!', str1, str2);
-
ตัวอย่างเช่นคุณสามารถสร้างคลาส ticker ที่ปล่อย "tick" กิจกรรมหนึ่งครั้งที่สอง:
การคัดลอกรหัสมีดังนี้:
var util = ต้องการ ('util')
Eventemitter = ต้องการ ('เหตุการณ์') Eventemitter;
var ticker = function () {
var self = this;
setInterval (function () {
self.emit ('เห็บ');
}, 1,000);
-
util.inherits (ticker, eventemitter);
ลูกค้าที่ใช้คลาสทิกเกอร์สามารถแสดงวิธีใช้คลาสทิกเกอร์และฟังกิจกรรม "ติ๊ก"
การคัดลอกรหัสมีดังนี้:
var ticker = ticker ใหม่ ();
ticker.on ("tick", function () {
console.log ("tick");
-
สรุป
โหมดตัวส่งสัญญาณเหตุการณ์เป็นรูปแบบการกลับเข้าใช้ใหม่ที่สามารถใช้ในการแยกวัตถุส่งสัญญาณเหตุการณ์จากชุดของรหัสสำหรับเหตุการณ์เฉพาะ
คุณสามารถใช้ event_emitter.on () เพื่อลงทะเบียนผู้ฟังสำหรับประเภทของเหตุการณ์เฉพาะและยกเลิกการลงทะเบียนด้วย event_emitter.removelistener ()
นอกจากนี้คุณยังสามารถสร้างตัวปล่อยกิจกรรมของคุณเองโดยสืบทอด Eventemitter และใช้ฟังก์ชั่น. emit ()