การจัดการเหตุการณ์และความไม่ตรงกันใน Node.js

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

 

เหตุการณ์และ callback s ใน Node.js

ใน Node.js เหตุการณ์และ callback s มีบทบาทสำคัญในการจัดการการทำงานแบบอะซิงโครนัส เหตุการณ์เป็นวิธีจัดการและตอบสนองต่อการกระทำหรือเหตุการณ์บางอย่างที่เกิดขึ้นภายในแอปพลิเคชัน Callback ในทางกลับกัน s เป็นฟังก์ชันที่ดำเนินการเมื่อเหตุการณ์หรือการดำเนินการเฉพาะเสร็จสิ้น

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

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

นี่คือตัวอย่างการใช้ a callback ใน Node.js:

// A function that takes a callback
function fetchData(callback) {  
  // Simulate fetching data from an asynchronous operation  
  setTimeout(() => {  
    const data = { name: 'John', age: 30 };  
    callback(null, data); // Pass the data to the callback  
  }, 2000); // Simulate a 2-second delay  
}  
  
// Call the fetchData function and provide a callback  
fetchData((error, data) => {  
  if(error) {  
    console.error('Error:', error);  
  } else {  
    console.log('Data:', data);  
  }  
});  

ในตัวอย่างนี้ เรามีฟังก์ชัน fetchData ที่เรียกว่าจำลองการดึงข้อมูลจากการดำเนินการแบบอะซิงโครนัส(เช่น การเรียกใช้ API หรือการสอบถามฐานข้อมูล) ใช้ callback ฟังก์ชันเป็นอาร์กิวเมนต์

ภายใน fetchData ฟังก์ชั่นเราใช้ setTimeout จำลองการทำงานแบบอะซิงโครนัส หลังจากการหน่วงเวลา 2 วินาที เราจะสร้างข้อมูลตัวอย่างบางส่วนและส่งต่อไปยัง callback ฟังก์ชันพร้อมกับข้อผิดพลาด(ซึ่ง null ในกรณีนี้)

นอก fetchData ฟังก์ชัน เราเรียกมันและจัดเตรียม callback ฟังก์ชัน ใน เรา callback จัดการกับข้อผิดพลาดที่อาจเกิดขึ้นและประมวลผลข้อมูลที่ได้รับ หากมีข้อผิดพลาด เราจะบันทึกไว้ในคอนโซล มิฉะนั้นเราจะบันทึกข้อมูล

นี่คือตัวอย่างพื้นฐานของการใช้ a callback ใน Node.js เพื่อจัดการการทำงานแบบอะซิงโครนัสและตรวจสอบให้แน่ใจว่าข้อมูลได้รับการประมวลผลเมื่อพร้อมใช้งาน ในสถานการณ์จริง callback s มักใช้ในการจัดการการสืบค้นฐานข้อมูล คำขอ API และงานแบบอะซิงโครนัสอื่นๆ

 

ใช้ Promise s และ เพื่อจัดการกับความไม่ตรงกัน async/await

"การใช้ Promise และ จัดการการทำงานแบบอะซิงโครนัส" เป็นวิธีการทั่วไปใน Node.js เพื่อจัดการกับงานแบบอะซิงโครนัสด้วยวิธีที่ง่ายและมีประสิทธิภาพ เป็น วัตถุที่ช่วยเราจัดการและจัดการกับการทำงานแบบอะซิงโครนัส ในขณะที่ เป็นไวยากรณ์ที่ช่วยให้เราสามารถเขียนโค้ดแบบอะซิงโครนัสในลักษณะที่คล้ายคลึงกับโค้ดแบบซิงโครนัส async/await Promise JavaScript async/await

ด้วยการใช้ Promise และ เราสามารถเขียนโค้ดแบบอะซิงโครนัสได้ง่ายขึ้นและเป็นธรรมชาติ เราไม่จำเป็นต้องใช้ ฟังก์ชันและจัดการกับ นรก( ฟังก์ชันที่ซ้อนกัน) อีกต่อไปเพื่อจัดการกับการทำงานแบบอะซิงโครนัส เราสามารถใช้คำหลัก wait เพื่อรอให้ a เสร็จสิ้นและส่งคืนผลลัพธ์แทน async/await callback callback callback Promise

นี่คือตัวอย่างของการใช้ Promise และ ใน Node.js เพื่อจัดการการทำงานแบบอะซิงโครนัส: async/await

// A mock function to fetch data from an API  
function fetchData() {  
  return new Promise((resolve, reject) => {  
    setTimeout(() => {  
      const data = { name: 'John', age: 30 };  
      resolve(data); // Return data within the Promise  
    }, 2000);  
  });  
}  
  
// Using async/await to handle asynchronous operations  
async function getData() {  
  try {  
    const data = await fetchData(); // Wait for the Promise to complete and return the data  
    console.log('Data:', data);  
  } catch(error) {  
    console.error('Error:', error);  
  }  
}  
  
// Call the getData function  
getData();  

ในตัวอย่างนี้ เราใช้ fetchData ฟังก์ชันเพื่อจำลองการดึงข้อมูลจาก API(หรือการทำงานแบบอะซิงโครนัสใดๆ) ฟังก์ชันนี้จะคืนค่า a Promise ที่เราเรียก resolve ฟังก์ชันส่งคืนข้อมูล

นอกฟังก์ชัน fetchData เราใช้ try/catch บล็อกเพื่อจัดการกับข้อผิดพลาด ใน getData ฟังก์ชัน เราใช้ await คีย์เวิร์ดเพื่อรอให้การกรอก Promise ข้อมูลเสร็จสิ้นและส่งคืน หากมีข้อผิดพลาดใน Promise จะเกิดข้อยกเว้นและเราจะจัดการใน catch บล็อก

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

การใช้ Promise และ ทำให้โค้ดของเราอ่านได้ง่ายขึ้นและเข้าใจได้ง่ายขึ้นเมื่อต้องรับมือกับการทำงานแบบอะซิงโครนัส มันช่วยให้เราหลีกเลี่ยง นรกและทำให้เราสามารถเขียนโค้ดในลักษณะที่ต่อเนื่องกัน คล้ายกับการเขียนโค้ดแบบซิงโครนัส async/await callback

 

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