การแนะนำ
หากคุณเคยได้ยินโหนดหรืออ่านบทความบางอย่างที่อ้างว่าโหนดนั้นยอดเยี่ยมแค่ไหนคุณอาจกำลังคิดว่า“ โหนดคืออะไร” แม้ว่าจะไม่ใช่สำหรับทุกคนโหนดอาจเป็นตัวเลือกที่เหมาะสมสำหรับบางคน
เพื่อพยายามอธิบายว่า Node.js คืออะไรบทความนี้สำรวจปัญหาที่สามารถแก้ปัญหาได้วิธีการทำงานวิธีการเรียกใช้แอปพลิเคชันง่าย ๆ และในที่สุดเมื่อโหนดเป็นและเมื่อใดที่ไม่ใช่ทางออกที่ดี บทความนี้ไม่ครอบคลุมวิธีการเขียนแอปพลิเคชันโหนดที่ซับซ้อนและไม่ได้เป็นบทช่วยสอนโหนดที่ครอบคลุม การอ่านบทความนี้ควรช่วยคุณตัดสินใจว่าคุณควรเรียนรู้โหนดเพื่อใช้สำหรับธุรกิจของคุณหรือไม่
โหนดออกแบบมาเพื่อแก้ปัญหาอะไร?
เป้าหมายที่อ้างสิทธิ์ในที่สาธารณะของ Node คือ "ให้วิธีง่ายๆในการสร้างโปรแกรมเครือข่ายที่ปรับขนาดได้" มีปัญหาอะไรกับโปรแกรมเซิร์ฟเวอร์ปัจจุบัน? มาทำปัญหาคณิตศาสตร์กันเถอะ ในภาษาเช่น Java ™และ PHP การเชื่อมต่อแต่ละครั้งจะสร้างเธรดใหม่ซึ่งอาจต้องใช้หน่วยความจำสหาย 2 MB ต่อเธรดใหม่ ในระบบที่มี RAM 8 GB จำนวนสูงสุดทางทฤษฎีของการเชื่อมต่อพร้อมกันคือผู้ใช้ 4,000 คน เมื่อฐานลูกค้าของคุณเติบโตขึ้นคุณต้องการให้เว็บแอปพลิเคชันของคุณรองรับผู้ใช้มากขึ้นดังนั้นคุณต้องเพิ่มเซิร์ฟเวอร์เพิ่มเติม แน่นอนว่าสิ่งนี้จะเพิ่มต้นทุนทางธุรกิจโดยเฉพาะค่าใช้จ่ายเซิร์ฟเวอร์ค่าขนส่งและต้นทุนแรงงาน นอกเหนือจากการเพิ่มขึ้นของค่าใช้จ่ายเหล่านี้มีปัญหาทางเทคนิค: ผู้ใช้อาจใช้เซิร์ฟเวอร์ที่แตกต่างกันสำหรับแต่ละคำขอดังนั้นทรัพยากรที่ใช้ร่วมกันใด ๆ จะต้องแชร์ระหว่างเซิร์ฟเวอร์ทั้งหมด ตัวอย่างเช่นใน Java ตัวแปรคงที่และแคชจะต้องแชร์ระหว่าง JVMs ในแต่ละเซิร์ฟเวอร์ นี่คือคอขวดในสถาปัตยกรรมเว็บแอปพลิเคชันทั้งหมด: จำนวนสูงสุดของการเชื่อมต่อพร้อมกันที่เซิร์ฟเวอร์สามารถจัดการได้
โซลูชันของ Node สำหรับปัญหานี้คือการเปลี่ยนวิธีการเชื่อมต่อการเชื่อมต่อกับเซิร์ฟเวอร์ การเชื่อมต่อแต่ละครั้งจะสร้างกระบวนการที่ไม่จำเป็นต้องใช้บล็อกหน่วยความจำร่วมแทนที่จะสร้างเธรด OS ใหม่สำหรับการเชื่อมต่อแต่ละครั้ง (และจัดสรรหน่วยความจำสหายบางอย่างให้กับมัน) โหนดอ้างว่ามันจะไม่หยุดชะงักเพราะไม่อนุญาตให้ล็อคเลยและจะไม่บล็อกการโทร I/O โดยตรง โหนดยังอ้างว่าเซิร์ฟเวอร์ที่ทำงานสามารถรองรับการเชื่อมต่อพร้อมกันหลายหมื่นครั้ง ในความเป็นจริงโหนดจะเปลี่ยนหน้าเซิร์ฟเวอร์โดยการเปลี่ยนคอขวดตลอดทั้งระบบจากจำนวนการเชื่อมต่อสูงสุดเป็นการรับส่งข้อมูลสำหรับระบบเดียว
ตอนนี้คุณมีโปรแกรมที่สามารถจัดการการเชื่อมต่อที่เกิดขึ้นพร้อมกันนับหมื่นคุณสามารถสร้างด้วยโหนดได้อย่างไร หากคุณมีเว็บแอปพลิเคชันที่ต้องจัดการการเชื่อมต่อมากมายมันจะเป็นสิ่งที่ "น่ากลัว"! นั่นคือ "ถ้าคุณมีปัญหานี้มันไม่ใช่ปัญหาเลย" ก่อนที่จะตอบคำถามข้างต้นลองมาดูกันว่าโหนดทำงานอย่างไรและออกแบบมาเพื่อทำงานอย่างไร
โหนดไม่แน่นอน
ใช่โหนดเป็นโปรแกรมเซิร์ฟเวอร์ อย่างไรก็ตามมันไม่ได้ดูเหมือน Apache หรือ Tomcat เซิร์ฟเวอร์เหล่านั้นเป็นผลิตภัณฑ์เซิร์ฟเวอร์แบบสแตนด์อโลนที่อนุญาตให้ติดตั้งและติดตั้งแอปพลิเคชันทันที ด้วยผลิตภัณฑ์เหล่านี้คุณสามารถรับเซิร์ฟเวอร์และทำงานได้ในหนึ่งนาที โหนดไม่ใช่ผลิตภัณฑ์ประเภทนี้อย่างแน่นอน Apache สามารถเพิ่มโมดูล PHP เพื่อให้นักพัฒนาสามารถสร้างหน้าเว็บแบบไดนามิกและโปรแกรมเมอร์ที่ใช้ Tomcat สามารถปรับใช้ JSP เพื่อสร้างหน้าเว็บแบบไดนามิก โหนดไม่ใช่ประเภทนี้อย่างแน่นอน
ในระยะแรกของโหนด (ปัจจุบันเวอร์ชัน 0.4.6) ไม่ใช่โปรแกรมเซิร์ฟเวอร์ "Run-ready" และคุณไม่สามารถติดตั้งได้วางไฟล์ลงในนั้นและมีเว็บเซิร์ฟเวอร์ที่ใช้งานได้อย่างสมบูรณ์ แม้ว่าคุณต้องการใช้ฟังก์ชั่นพื้นฐานของเว็บเซิร์ฟเวอร์และทำงานหลังจากการติดตั้งเสร็จสมบูรณ์ แต่ก็ยังต้องใช้งานได้มาก
โหนดทำงานอย่างไร
โหนดตัวเองเรียกใช้ V8 JavaScript เดี๋ยวก่อน JavaScript บนเซิร์ฟเวอร์? ถูกต้องคุณอ่านถูกต้อง JavaScript ฝั่งเซิร์ฟเวอร์เป็นแนวคิดที่ค่อนข้างใหม่ที่กล่าวถึงเมื่อสองปีก่อนเมื่อพูดถึงผลิตภัณฑ์ Aptana Jaxer ใน DeveloperWorks (ดูทรัพยากร) แม้ว่า Jaxer ไม่เคยได้รับความนิยมอย่างแท้จริง แต่แนวคิดของตัวเองยังไม่สามารถเข้าถึงได้ - ทำไมเราไม่สามารถใช้ภาษาการเขียนโปรแกรมที่ใช้กับไคลเอนต์บนเซิร์ฟเวอร์ได้?
อะไรทำให้ v8? เอ็นจิ้น V8 JavaScript เป็นเครื่องยนต์ JavaScript พื้นฐานที่ Google ใช้สำหรับเบราว์เซอร์ Chrome มีเพียงไม่กี่คนที่คิดว่า JavaScript ทำอะไรกับลูกค้าจริง ๆ ? ในความเป็นจริงเอ็นจิ้น JavaScript มีหน้าที่ในการตีความและดำเนินการรหัส ด้วยการใช้ V8 Google สร้างล่ามที่เร็วที่สุดที่เขียนใน C ++ ซึ่งมีคุณสมบัติที่ไม่ซ้ำกันอื่น คุณสามารถดาวน์โหลดเครื่องยนต์และฝังลงในแอปพลิเคชันใด ๆ ไม่ จำกัด เพียงแค่ทำงานในเบราว์เซอร์เดียว ดังนั้น Node ใช้เอ็นจิน V8 JavaScript ที่เขียนโดย Google และสร้างใหม่เพื่อใช้บนเซิร์ฟเวอร์ สมบูรณ์แบบเกินไป! ตอนนี้มีวิธีแก้ปัญหาที่ดีทำไมต้องสร้างภาษาใหม่?
การเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์
โปรแกรมเมอร์หลายคนให้การศึกษาแก่พวกเขาให้เชื่อว่าการเขียนโปรแกรมเชิงวัตถุเป็นการออกแบบการเขียนโปรแกรมที่สมบูรณ์แบบและไม่สนใจวิธีการเขียนโปรแกรมอื่น ๆ โหนดใช้รูปแบบการเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์
รายการ 1. การเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์โดยใช้ jQuery บนไคลเอนต์
การคัดลอกรหัสมีดังนี้:
// รหัส jQuery ในฝั่งไคลเอ็นต์แสดงให้เห็นว่าการเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์ทำงานอย่างไร
// เมื่อกดปุ่มเหตุการณ์จะเกิดขึ้น - จัดการกับมัน
// ตรงนี้โดยตรงในฟังก์ชันที่ไม่ระบุชื่อซึ่งทั้งหมด
// ตัวแปรที่จำเป็นมีอยู่และสามารถอ้างอิงได้โดยตรง
$ ("#myButton") คลิก (ฟังก์ชัน () {
if ($ ("#mytextfield"). val ()! = $ (นี่) .val ())
การแจ้งเตือน ("ฟิลด์ต้องจับคู่ข้อความปุ่ม");
-
ในความเป็นจริงไม่มีความแตกต่างระหว่างเซิร์ฟเวอร์และไคลเอนต์ ใช่ไม่มีการดำเนินการคลิกปุ่มและไม่มีการดำเนินการที่จะพิมพ์ลงในฟิลด์ข้อความ แต่ในระดับที่สูงขึ้นเหตุการณ์จะเกิดขึ้น การเชื่อมต่อถูกจัดตั้งขึ้น - เหตุการณ์! ข้อมูลได้รับผ่านการเชื่อมต่อ - เหตุการณ์! ข้อมูลหยุดผ่านการเชื่อมต่อ - เหตุการณ์!
เหตุใดประเภทการตั้งค่านี้จึงเหมาะสำหรับโหนด? JavaScript เป็นภาษาการเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์ที่ยอดเยี่ยมเพราะมันอนุญาตให้มีฟังก์ชั่นและการปิดที่ไม่ระบุชื่อและที่สำคัญกว่านั้นใครก็ตามที่เขียนโค้ดจะคุ้นเคยกับไวยากรณ์ ฟังก์ชั่นการโทรกลับที่เรียกว่าเมื่อเหตุการณ์เกิดขึ้นสามารถเขียนได้ที่เหตุการณ์การจับภาพ ด้วยวิธีนี้รหัสนั้นง่ายต่อการเขียนและบำรุงรักษาโดยไม่มีกรอบการทำงานเชิงวัตถุที่ซับซ้อนโดยไม่มีอินเทอร์เฟซและไม่มีศักยภาพในการจัดโครงสร้างอะไรก็ตาม เพียงแค่ฟังเหตุการณ์เขียนฟังก์ชั่นการโทรกลับและจากนั้นการเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์จะดูแลทุกอย่าง!
แอปพลิเคชันโหนดตัวอย่าง
สุดท้ายมาดูรหัสกันเถอะ! มารวมทุกสิ่งที่เราได้พูดคุยและสร้างแอปพลิเคชันโหนดแรกของเรา เนื่องจากเรารู้อยู่แล้วว่าโหนดเหมาะสำหรับการจัดการแอปพลิเคชันการจราจรสูงเราจะสร้างเว็บแอปพลิเคชันที่ง่ายมากซึ่งเป็นแอปพลิเคชันที่สร้างขึ้นเพื่อความเร็วสูงสุด นี่คือข้อกำหนดเฉพาะสำหรับแอปพลิเคชันตัวอย่างของเราที่อธิบายโดย "บอส": สร้าง API ตัวสร้างตัวเลขสุ่ม แอปพลิเคชันนี้ควรยอมรับอินพุต: พารามิเตอร์ชื่อ "หมายเลข" แอปพลิเคชันจะส่งคืนหมายเลขสุ่มระหว่าง 0 และพารามิเตอร์และส่งคืนหมายเลขที่สร้างไปยังผู้โทร เนื่องจาก "บอส" ต้องการให้เป็นแอปพลิเคชั่นที่ได้รับความนิยมอย่างกว้างขวางจึงควรจัดการผู้ใช้ที่เกิดขึ้นพร้อมกัน 50,000 คน ลองดูที่รหัส:
รายการ 2. ตัวสร้างหมายเลขสุ่มโหนด
การคัดลอกรหัสมีดังนี้:
// โมดูลเหล่านี้จำเป็นต้องนำเข้าเพื่อใช้งาน
// โหนดมีหลายโมดูล พวกเขาเป็นเหมือน #include ใด ๆ
// หรือคำสั่งนำเข้าในภาษาอื่น ๆ
var http = ต้องการ ("http");
var url = ต้องการ ("url");
// บรรทัดที่สำคัญที่สุดในไฟล์โหนดใด ๆ ฟังก์ชั่นนี้
// กระบวนการจริงในการสร้างเซิร์ฟเวอร์ ในทางเทคนิค
// โหนดบอกระบบปฏิบัติการพื้นฐานว่าเมื่อใดก็ตาม
// ทำการเชื่อมต่อฟังก์ชั่นการโทรกลับโดยเฉพาะนี้ควรเป็น
// ดำเนินการ เนื่องจากเรากำลังสร้างบริการเว็บกับ REST API
// เราต้องการเซิร์ฟเวอร์ HTTP ซึ่งต้องการตัวแปร HTTP
// เราสร้างในบรรทัดด้านบน
// ในที่สุดคุณจะเห็นว่าวิธีการโทรกลับได้รับ 'คำขอ'
วัตถุ // และ 'การตอบสนอง' โดยอัตโนมัติ สิ่งนี้ควรคุ้นเคย
// ไปยังโปรแกรมเมอร์ PHP หรือ Java ใด ๆ
http.createserver (ฟังก์ชั่น (คำขอ, การตอบกลับ) {
// การตอบกลับจำเป็นต้องจัดการส่วนหัวทั้งหมดและรหัสส่งคืน
// สิ่งเหล่านี้ได้รับการจัดการโดยอัตโนมัติในโปรแกรมเซิร์ฟเวอร์
// เช่น Apache และ Tomcat แต่โหนดต้องการทุกอย่างที่ต้องทำด้วยตัวเอง
Response.writehead (200, {"เนื้อหาประเภท": "ข้อความ/ธรรมดา"});
// นี่คือรหัสที่ดูไม่ซ้ำกัน นี่คือวิธีที่โหนดการฝึกอบรม
// พารามิเตอร์ส่งผ่านจากคำขอของลูกค้า โมดูล URL
// จัดการฟังก์ชั่นเหล่านี้ทั้งหมด ฟังก์ชั่นการแยกวิเคราะห์
// deconstructs url และวางค่าคีย์แบบสอบถามในไฟล์
// วัตถุแบบสอบถาม เราสามารถค้นหาค่าสำหรับปุ่ม "หมายเลข"
// โดยการอ้างอิงโดยตรง - ความงามของ JavaScript
var params = url.parse (request.url, true) .query;
var input = params.number;
// นี่คือวิธี JavaScript ทั่วไปที่จะสร้าง
// หมายเลขสุ่มของเราที่ส่งกลับไปยังผู้โทร
var numInput = หมายเลขใหม่ (อินพุต);
var numoutput = หมายเลขใหม่ (math.random () * numinput) .tofixed (0);
// เขียนหมายเลขสุ่มเพื่อตอบสนอง
Response.write (numoutput);
// โหนดต้องการให้เราสิ้นสุดการเชื่อมต่อนี้อย่างชัดเจน นี่เป็นเพราะ
// โหนดช่วยให้คุณสามารถเปิดการเชื่อมต่อและส่งผ่านข้อมูลไปมา
// แม้ว่าหัวข้อขั้นสูงจะไม่ได้กล่าวถึงในบทความนี้
Response.end ();
// เมื่อเราสร้างเซิร์ฟเวอร์เราต้องเชื่อมต่อเซิร์ฟเวอร์ HTTP อย่างชัดเจนกับ
// พอร์ต พอร์ต HTTP มาตรฐานคือ 80 ดังนั้นเราจะเชื่อมต่อกับอันนั้น
}). ฟัง (80);
// เอาต์พุตสตริงไปยังคอนโซลเมื่อเซิร์ฟเวอร์เริ่มขึ้นแจ้งให้เราทราบทุกอย่าง
// เริ่มต้นอย่างถูกต้อง
console.log ("ตัวสร้างตัวเลขสุ่มกำลังทำงาน ... ");
ใส่รหัสด้านบนลงในไฟล์ที่เรียกว่า "random.js" ตอนนี้เพื่อเริ่มแอปพลิเคชันและเรียกใช้ (จากนั้นสร้างเซิร์ฟเวอร์ HTTP และฟังการเชื่อมต่อบนพอร์ต 80) เพียงป้อนคำสั่งต่อไปนี้ในพรอมต์คำสั่งของคุณ: % node random.js นี่คือสิ่งที่ดูเหมือนเมื่อเซิร์ฟเวอร์กำลังทำงานอยู่แล้ว:
การคัดลอกรหัสมีดังนี้:
root@ubuntu:/home/moila/ws/mike# node random.js
เครื่องกำเนิดหมายเลขสุ่มกำลังทำงาน ...
เข้าถึงแอปพลิเคชัน
แอปพลิเคชันกำลังเปิดใช้งาน โหนดกำลังฟังการเชื่อมต่อใด ๆ ลองทดสอบกันเถอะ เนื่องจากเราสร้าง API ที่เรียบง่ายอย่างง่ายเราจึงสามารถใช้เว็บเบราว์เซอร์ของเราเพื่อเข้าถึงแอปพลิเคชันนี้ พิมพ์ที่อยู่ต่อไปนี้ (ตรวจสอบให้แน่ใจว่าคุณทำตามขั้นตอนข้างต้นเสร็จแล้ว): http: // localhost/? number = 27
หน้าต่างเบราว์เซอร์ของคุณจะเปลี่ยนเป็นหมายเลขสุ่มระหว่าง 0 ถึง 27 คลิกปุ่มโหลดซ้ำบนเบราว์เซอร์ของคุณและคุณจะได้รับหมายเลขสุ่มอื่น นี่คือแอพโหนดแรกของคุณ!
โหนดอะไรดีสำหรับ?
จนถึงตอนนี้คุณควรจะตอบคำถาม "โหนดคืออะไร" แต่คุณอาจไม่ชัดเจนเมื่อคุณควรใช้มัน นี่เป็นคำถามสำคัญที่จะถามเพราะโหนดดีสำหรับบางสิ่ง แต่ในทางกลับกันโหนดอาจไม่ใช่ทางออกที่ดีสำหรับผู้อื่นในขณะนี้ คุณต้องระมัดระวังในการตัดสินใจว่าจะใช้โหนดเมื่อใช้ในสถานการณ์ที่ไม่ถูกต้องอาจส่งผลให้ล็อตที่เข้ารหัสซ้ำซ้อน
มันดีสำหรับอะไร?
อย่างที่คุณเคยเห็นมาก่อนโหนดเหมาะสำหรับสถานการณ์ที่คุณคาดว่าจะมีทราฟฟิกสูงและข้อกำหนดด้านเซิร์ฟเวอร์และข้อกำหนดด้านการประมวลผลไม่จำเป็นต้องมีขนาดใหญ่ก่อนที่จะตอบสนองต่อลูกค้า ตัวอย่างทั่วไปของประสิทธิภาพที่โดดเด่นของโหนด ได้แก่ :
1. Restful API
บริการบนเว็บที่ให้ API RESTFUL ได้รับพารามิเตอร์หลายตัวแยกวิเคราะห์รวมการตอบสนองและส่งคืนการตอบกลับ (โดยปกติจะน้อยกว่าข้อความ) ให้กับผู้ใช้ นี่เป็นสถานการณ์ที่เหมาะสำหรับโหนดเนื่องจากคุณสามารถสร้างมันเพื่อจัดการการเชื่อมต่อนับหมื่น ยังไม่จำเป็นต้องใช้ตรรกะจำนวนมาก มันแค่ค้นหาค่าบางส่วนจากฐานข้อมูลและรวมการตอบสนอง เนื่องจากการตอบสนองเป็นข้อความจำนวนเล็กน้อยและข้อความจำนวนเล็กน้อยในคำขอขาเข้าการรับส่งข้อมูลไม่สูงและเครื่องสามารถจัดการกับความต้องการ API ของ บริษัท ที่คึกคักที่สุด
2. คิว twitter
ลองนึกภาพ บริษัท อย่าง Twitter ซึ่งจะต้องได้รับทวีตและเขียนลงในฐานข้อมูล ในความเป็นจริงมีทวีตเกือบหลายพันครั้งต่อวินาทีและเป็นไปไม่ได้ที่ฐานข้อมูลจะประมวลผลจำนวนการเขียนที่จำเป็นในช่วงเวลาสูงสุดในเวลาที่เหมาะสม โหนดได้กลายเป็นส่วนสำคัญของการแก้ปัญหานี้ อย่างที่คุณเห็นโหนดสามารถจัดการทวีตขาเข้าหลายหมื่น มันเขียนได้อย่างรวดเร็วและง่ายดายไปยังกลไกคิวหน่วยความจำ (เช่น Memcached) ซึ่งกระบวนการแยกต่างหากอื่นสามารถเขียนลงในฐานข้อมูลได้ บทบาทของโหนดที่นี่คือการรวบรวมทวีตอย่างรวดเร็วและส่งข้อมูลนี้ไปยังกระบวนการอื่นที่รับผิดชอบในการเขียน ลองนึกภาพการออกแบบอื่น - เซิร์ฟเวอร์ PHP ปกติพยายามที่จะจัดการกับการเขียนลงในฐานข้อมูลเอง - แต่ละทวีตจะทำให้เกิดความล่าช้าสั้น ๆ เมื่อเขียนลงในฐานข้อมูลเนื่องจากการโทรฐานข้อมูลปิดกั้นช่อง เนื่องจากความล่าช้าของฐานข้อมูลเครื่องที่ออกแบบมาเช่นนี้อาจจัดการทวีตขาเข้าได้ 2,000 ครั้งต่อวินาที ทวีต 1 ล้านต่อวินาทีต้องใช้ 500 เซิร์ฟเวอร์ แต่โหนดจัดการการเชื่อมต่อทุกครั้งโดยไม่ปิดกั้นช่องจึงจับทวีตให้ได้มากที่สุด เครื่องโหนดที่สามารถจัดการ 50,000 ทวีตต้องใช้เซิร์ฟเวอร์เพียง 20 เซิร์ฟเวอร์
3. เซิร์ฟเวอร์ไฟล์รูปภาพ
บริษัท ที่มีเว็บไซต์กระจายขนาดใหญ่เช่น Facebook หรือ Flickr อาจตัดสินใจใช้เครื่องทั้งหมดสำหรับรูปภาพบริการเท่านั้น โหนดจะเป็นทางออกที่ดีสำหรับปัญหานี้เนื่องจาก บริษัท สามารถใช้เพื่อเขียนไฟล์รีทรีฟเวอร์ง่าย ๆ แล้วประมวลผลการเชื่อมต่อนับหมื่น โหนดจะค้นหาไฟล์ภาพส่งคืนไฟล์หรือข้อผิดพลาด 404 แล้วไม่ทำอะไรเลย การตั้งค่านี้จะอนุญาตให้เว็บไซต์กระจายดังกล่าวลดจำนวนเซิร์ฟเวอร์ที่พวกเขาต้องการในการให้บริการไฟล์คงที่เช่นรูปภาพ, .js และ. css
มันไม่ดีสำหรับอะไร?
แน่นอนในบางกรณีโหนดไม่เหมาะ นี่คือพื้นที่ที่โหนดไม่ดีที่:
1. หน้าสร้างแบบไดนามิก
ปัจจุบันโหนดไม่ได้ให้วิธีการเริ่มต้นเพื่อสร้างหน้าแบบไดนามิก ตัวอย่างเช่นเมื่อใช้เทคโนโลยี JavaServer Pages (JSP) คุณสามารถสร้างหน้า index.jsp ที่มีลูปในตัวอย่างโค้ด JSP ดังกล่าว โหนดไม่รองรับหน้าแบบไดนามิกที่ขับเคลื่อนด้วย HTML ในทำนองเดียวกันโหนดไม่เหมาะกับเว็บเซิร์ฟเวอร์เช่น Apache และ Tomcat ดังนั้นหากคุณต้องการจัดหาโซลูชันฝั่งเซิร์ฟเวอร์ในโหนดคุณต้องเขียนโซลูชันทั้งหมดด้วยตัวเอง โปรแกรมเมอร์ PHP ไม่ต้องการเขียนตัวแปลง PHP สำหรับ Apache ทุกครั้งที่พวกเขาปรับใช้เว็บแอปพลิเคชันและจนถึงตอนนี้นี่คือสิ่งที่โหนดขอให้คุณทำ
2. แอปพลิเคชันหนักฐานข้อมูลเชิงสัมพันธ์
จุดประสงค์ของโหนดนั้นรวดเร็วอะซิงโครนัสและไม่ปิดกั้น ฐานข้อมูลไม่จำเป็นต้องแบ่งปันเป้าหมายเหล่านี้ พวกเขาเป็นแบบซิงโครนัสและการบล็อกเนื่องจากการโทรไปยังฐานข้อมูลระหว่างการอ่านและเขียนจะบล็อกช่องจนกว่าผลลัพธ์จะถูกสร้างขึ้น ดังนั้นเว็บแอปพลิเคชันที่ต้องการการโทรฐานข้อมูลจำนวนมากการอ่านจำนวนมากการเขียนจำนวนมากต่อคำขอไม่เหมาะสมมากสำหรับโหนดเนื่องจากฐานข้อมูลเชิงสัมพันธ์สามารถชดเชยข้อดีของโหนดได้ (ฐานข้อมูล NOSQL ใหม่เหมาะสำหรับโหนด แต่นั่นเป็นอีกหัวข้อหนึ่งโดยสิ้นเชิง)
บทสรุป
คำถามคือ "node.js คืออะไร" ควรได้รับคำตอบ หลังจากอ่านบทความนี้คุณควรจะสามารถตอบคำถามนี้ได้ในประโยคที่ชัดเจนและรัดกุม ถ้าเป็นเช่นนั้นคุณมาถึงระดับแนวหน้าของผู้เขียนโค้ดและโปรแกรมเมอร์จำนวนมาก ฉันได้พูดคุยเกี่ยวกับโหนดกับหลาย ๆ คน แต่พวกเขาสับสนเกี่ยวกับโหนดที่แน่นอน เป็นที่เข้าใจกันว่าพวกเขามีความคิดของ Apache - เซิร์ฟเวอร์เป็นแอปพลิเคชันที่ใส่ไฟล์ HTML ลงในนั้นและทุกอย่างจะทำงานได้อย่างถูกต้อง และโหนดเป็นแรงผลักดันที่มีวัตถุประสงค์ เป็นโปรแกรมซอฟต์แวร์ที่ใช้ JavaScript เพื่อให้โปรแกรมเมอร์สามารถสร้างเว็บเซิร์ฟเวอร์ที่รวดเร็วและปรับขนาดได้อย่างรวดเร็ว Apache พร้อมใช้งานในขณะที่ Node กำลังเข้ารหัสพร้อมใช้งาน
โหนดบรรลุเป้าหมายในการจัดหาเซิร์ฟเวอร์ที่ปรับขนาดได้สูง แทนที่จะจัดสรรโมเดล "หนึ่งเธรดต่อการเชื่อมต่อ" จะใช้โมเดล "หนึ่งกระบวนการต่อการเชื่อมต่อ" เพื่อสร้างเฉพาะหน่วยความจำที่จำเป็นสำหรับการเชื่อมต่อแต่ละครั้ง มันใช้เอ็นจิ้น JavaScript ที่รวดเร็วมากจาก Google: Engine V8 มันใช้การออกแบบที่ขับเคลื่อนด้วยเหตุการณ์เพื่อให้รหัสน้อยที่สุดและอ่านง่าย ปัจจัยทั้งหมดเหล่านี้นำไปสู่เป้าหมายในอุดมคติของโหนด - ง่ายกว่าที่จะเขียนโซลูชันที่ปรับขนาดได้สูง
สำคัญพอ ๆ กับการทำความเข้าใจว่าโหนดคืออะไรทำความเข้าใจกับสิ่งที่ไม่ใช่ Node ไม่ได้แทนที่ Apache ซึ่งออกแบบมาเพื่อให้เว็บแอปพลิเคชัน PHP ปรับขนาดได้มากขึ้น นี่เป็นกรณีที่แน่นอน ในระยะแรกของโหนดนี้ไม่น่าเป็นไปได้ที่โปรแกรมเมอร์จำนวนมากจะใช้มัน แต่ในสถานการณ์ที่ใช้งานได้มันทำงานได้ดีมาก
ฉันควรคาดหวังอะไรจากโหนดในอนาคต? นี่อาจเป็นคำถามที่สำคัญที่สุดที่บทความนี้เกิดขึ้น ตอนนี้คุณรู้แล้วว่ามันทำอะไรอยู่ตอนนี้คุณควรสงสัยว่ามันจะทำอะไรต่อไป ในปีหน้าฉันหวังว่าจะได้รับการรวมเข้าด้วยกันกับห้องสมุดสนับสนุนบุคคลที่สามที่มีอยู่ดีขึ้น โปรแกรมเมอร์ของบุคคลที่สามหลายคนได้พัฒนาปลั๊กอินสำหรับโหนดรวมถึงการเพิ่มการสนับสนุนไฟล์เซิร์ฟเวอร์และการสนับสนุน MySQL หวังว่าโหนดจะเริ่มรวมเข้ากับฟังก์ชั่นหลัก ในที่สุดฉันก็ต้องการให้โหนดสนับสนุนโมดูลหน้าแบบไดนามิกบางชนิดเพื่อให้คุณสามารถทำสิ่งที่คุณทำใน PHP และ JSP (อาจเป็น NSP หน้าเซิร์ฟเวอร์โหนด) ในไฟล์ HTML ในที่สุดหวังว่าวันหนึ่งเซิร์ฟเวอร์โหนด "การปรับใช้พร้อม" จะปรากฏขึ้นซึ่งสามารถดาวน์โหลดและติดตั้งได้เพียงใส่ไฟล์ HTML ของคุณไว้ในนั้นเช่นเดียวกับการใช้ Apache หรือ Tomcat โหนดยังอยู่ในระยะเริ่มต้น แต่ก็กำลังพัฒนาอย่างรวดเร็วและอาจจะอยู่ในวิสัยทัศน์ของคุณในไม่ช้า