Node.js เป็นแบบอะซิงโครนัสและขับเคลื่อนเหตุการณ์ตามธรรมชาติและเหมาะสำหรับการจัดการงานที่เกี่ยวข้องกับ I/O หากคุณกำลังจัดการกับการดำเนินการที่เกี่ยวข้องกับ I/O ในแอปพลิเคชันของคุณคุณสามารถใช้ประโยชน์จากสตรีมใน Node.js ดังนั้นลองมาดูรายละเอียดสตรีมและเข้าใจว่าพวกเขาทำให้การดำเนินงานของ I/O ง่ายขึ้นอย่างไร
การไหลคืออะไร
สตรีมเป็นท่อ UNIX ที่ช่วยให้คุณสามารถอ่านข้อมูลจากแหล่งข้อมูลได้อย่างง่ายดายแล้วไหลไปยังปลายทางอื่น
พูดง่ายๆคือการสตรีมไม่ใช่สิ่งที่พิเศษ แต่เป็นเพียงเหตุการณ์ที่ใช้วิธีการบางอย่าง ตามวิธีการที่ใช้งานสตรีมสามารถกลายเป็นสตรีมที่อ่านได้ (อ่านได้) สตรีมที่เขียนได้ (เขียนได้) หรือสตรีมสองทิศทาง (เพล็กซ์, อ่านง่ายและเขียนได้)
สตรีมที่อ่านได้ช่วยให้คุณอ่านข้อมูลจากแหล่งข้อมูลในขณะที่สตรีมที่เขียนได้ช่วยให้คุณเขียนข้อมูลไปยังปลายทางของคุณได้
หากคุณใช้ node.js คุณมีแนวโน้มที่จะพบสตรีมมิ่ง
ตัวอย่างเช่นในเซิร์ฟเวอร์ Node.js HTTP คำขอเป็นสตรีมที่อ่านได้และการตอบสนองเป็นสตรีมที่เขียนได้
คุณอาจใช้โมดูล FS ซึ่งสามารถช่วยคุณจัดการสตรีมที่อ่านได้และเขียนได้
ตอนนี้ให้คุณเรียนรู้พื้นฐานและเข้าใจการไหลประเภทต่างๆ บทความนี้จะหารือเกี่ยวกับสตรีมที่อ่านได้และเขียนได้ ลำธารสองทิศทางอยู่นอกเหนือขอบเขตของบทความนี้และเราจะไม่พูดคุยกัน
สตรีมที่อ่านได้
เราสามารถใช้สตรีมที่อ่านได้เพื่ออ่านข้อมูลจากแหล่งข้อมูลซึ่งสามารถเป็นอะไรก็ได้เช่นไฟล์ในระบบบัฟเฟอร์ในหน่วยความจำหรือแม้แต่สตรีมอื่น ๆ เนื่องจากสตรีมเป็น Eventemitters พวกเขาจึงส่งข้อมูลพร้อมเหตุการณ์ต่าง ๆ เราจะใช้กิจกรรมเหล่านี้เพื่อทำให้การไหลทำงาน
อ่านข้อมูลจากสตรีม
วิธีที่ดีที่สุดในการอ่านข้อมูลจากสตรีมคือการฟังเหตุการณ์ข้อมูลและเพิ่มฟังก์ชั่นการโทรกลับ เมื่อข้อมูลไหลผ่านสตรีมที่อ่านได้จะส่งเหตุการณ์ข้อมูลและฟังก์ชั่นการโทรกลับจะถูกเรียกใช้ ดูตัวอย่างโค้ดต่อไปนี้:
var fs = ต้องการ ('fs'); var readableStream = fs.createReadStream ('file.txt'); var data = ''; var readableStream.on ('data', ฟังก์ชั่น (chunk) {data += chunk;}); readableStream.on ('ปลาย'Fs.CreateReadStream จะให้สตรีมที่อ่านได้
ในตอนแรกสตรีมนี้ไม่ได้ไหลแบบไดนามิก เมื่อคุณเพิ่มฟังเหตุการณ์ของข้อมูลและเพิ่มฟังก์ชั่นการโทรกลับมันจะไหล หลังจากนี้มันจะอ่านข้อมูลชิ้นเล็ก ๆ และส่งผ่านไปยังฟังก์ชั่นการโทรกลับของคุณ
ผู้ดำเนินการของสตรีมกำหนดความถี่ทริกเกอร์ของเหตุการณ์ข้อมูล ตัวอย่างเช่นคำขอ HTTP จะทริกเกอร์เหตุการณ์ข้อมูลเมื่ออ่านข้อมูลหลาย KBS เมื่อคุณอ่านข้อมูลจากไฟล์คุณอาจตัดสินใจที่จะเรียกเหตุการณ์ข้อมูลเมื่อบรรทัดเสร็จสิ้น
เมื่อไม่มีข้อมูลที่จะอ่าน (เมื่ออ่านในตอนท้ายของไฟล์) สตรีมจะส่งเหตุการณ์สิ้นสุด ในตัวอย่างด้านบนเราฟังเหตุการณ์นี้และพิมพ์ข้อมูลเมื่อเราอ่านไฟล์เสร็จ
มีอีกวิธีหนึ่งในการอ่านสตรีม คุณเพียงแค่ต้องโทรหาวิธีการอ่าน () ในอินสแตนซ์สตรีมก่อนที่จะอ่านไปยังจุดสิ้นสุดของไฟล์
var fs = ต้องการ ('fs'); var readableStream = fs.createReadStream ('file.txt'); var data = ''; var chunk; readableStream.on ('อ่านได้', ฟังก์ชั่น () {ในขณะที่ (chunk = readableStream.Read ())! = null) {data += chunk; console.log (ข้อมูล);});วิธีการอ่าน () อ่านข้อมูลจากบัฟเฟอร์ภายในและส่งคืนค่า null เมื่อไม่มีข้อมูลที่จะอ่าน
ดังนั้นในขณะที่ลูปเราตรวจสอบว่าอ่าน () ส่งคืนค่า null และเมื่อมันส่งคืนค่าโมฆะลูปจะถูกยกเลิก
ควรสังเกตว่าเมื่อเราสามารถอ่านข้อมูลจากสตรีมเหตุการณ์ที่อ่านได้จะถูกยิง
ตั้งค่าการเข้ารหัส
โดยค่าเริ่มต้นสิ่งที่คุณอ่านจากสตรีมคือวัตถุบัฟเฟอร์ หากคุณกำลังอ่านสตริงนี่ไม่เหมาะกับคุณ ดังนั้นคุณสามารถตั้งค่าการเข้ารหัสของสตรีมโดยการเรียกใช้ readable.setEncoding () เช่นในตัวอย่างต่อไปนี้:
var fs = ต้องการ ('fs'); var readableStream = fs.createReadStream ('file.txt'); var data = ''; readableStream.setEncoding ('utf8'); readableStream.on ('data', ฟังก์ชัน (chunk) {data += chunk;};ในตัวอย่างข้างต้นหากเราตั้งค่าการเข้ารหัสของสตรีมเป็น UTF8 ข้อมูลจะถูกแยกวิเคราะห์เป็น UTF8 และก้อนในฟังก์ชันการโทรกลับจะเป็นสตริง
การวางท่อ
ท่อส่งเป็นกลไกที่ยอดเยี่ยมที่คุณสามารถอ่านข้อมูลจากแหล่งข้อมูลโดยไม่ต้องจัดการสถานะของสตรีมด้วยตัวเองและเขียนลงในปลายทางของคุณ ลองดูตัวอย่างต่อไปนี้:
var fs = ต้องการ ('fs'); var readableStream = fs.createReadStream ('file1.txt'); var writableStream = fs.createWritestream ('file2.txt'); readableStream.pipe (writableStream);ตัวอย่างด้านบนใช้เมธอด pipe () เพื่อเขียนเนื้อหาของ file1 ถึง file2 เนื่องจาก Pipe () จะช่วยให้คุณจัดการการไหลของข้อมูลคุณไม่จำเป็นต้องกังวลเกี่ยวกับความเร็วของการไหลของข้อมูล สิ่งนี้ทำให้ท่อ () ใช้งานง่ายและใช้งานง่าย
ควรสังเกตว่า Pipe () ส่งคืนสตรีมปลายทางเพื่อให้คุณสามารถเชื่อมโยงหลายสตรีมได้อย่างง่ายดาย!
ลิงค์ (การผูกมัด)
สมมติว่ามีไฟล์เก็บถาวรและคุณต้องการคลายซิป มีหลายวิธีในการทำภารกิจนี้ให้สำเร็จ แต่วิธีที่ง่ายที่สุดคือการใช้ท่อและลิงก์:
var fs = ต้องการ ('fs'); var zlib = ต้องการ ('zlib'); fs.createReadstream ('input.txt.gz') .pipe (zlib.creategunzip ()) .pipeก่อนอื่นเราสร้างสตรีมที่อ่านได้ผ่าน input.txt.gz จากนั้นปล่อยให้สตรีม zlib.creategunzip () สตรีมซึ่งจะบีบอัดเนื้อหา ในที่สุดเราเพิ่มสตรีมที่เขียนได้เพื่อเขียนเนื้อหาที่บีบอัดลงในไฟล์อื่น
วิธีอื่น ๆ
เราได้พูดคุยเกี่ยวกับแนวคิดที่สำคัญบางอย่างในสตรีมที่อ่านได้และนี่คือวิธีที่คุณต้องรู้:
1. READABLE.PAUSE () วิธีนี้จะหยุดการไหลของการไหลชั่วคราว กล่าวอีกนัยหนึ่งมันจะไม่กระตุ้นเหตุการณ์ข้อมูลอีกครั้ง
2. วิธีการอ่าน. resume () เป็นสิ่งที่ตรงกันข้ามกับด้านบนและจะอนุญาตให้หยุดการไหลชั่วคราวเพื่อกลับมาทำงานต่อ
3. rEADABLE.UNPIPE () วิธีการจะลบปลายทาง หากมีพารามิเตอร์ที่ผ่านเข้ามามันจะปล่อยให้สตรีมที่อ่านได้หยุดปลายทางเฉพาะของ Liu Xiang มิฉะนั้นจะลบปลายทางทั้งหมด
สตรีมที่เขียนได้
สตรีมที่เขียนได้ช่วยให้คุณสามารถเขียนข้อมูลไปยังปลายทางของคุณ เช่นเดียวกับสตรีมที่อ่านได้เหล่านี้เป็นเหตุการณ์ที่เกิดขึ้นและพวกเขายังก่อให้เกิดเหตุการณ์ที่แตกต่างกัน ลองมาดูเหตุการณ์และวิธีการที่จะถูกเรียกใช้ในสตรีมที่เขียนได้
เขียนถึงสตรีม
ในการเขียนข้อมูลเป็นสตรีมที่เขียนได้คุณต้องเรียกวิธีการเขียน () ในอินสแตนซ์สตรีมที่เขียนได้และดูตัวอย่างต่อไปนี้:
var fs = ต้องการ ('fs'); var readableStream = fs.createReadStream ('file1.txt'); var writableStream = fs.createWritestream ('file2.txt'); readableStream.setencoding ('utf8');รหัสข้างต้นนั้นง่ายมากเพียงแค่อ่านข้อมูลจากสตรีมอินพุตและเขียนลงในปลายทางด้วยการเขียน ()
วิธีนี้ส่งคืนค่าบูลีนเพื่อระบุว่าการเขียนสำเร็จหรือไม่ หากการส่งคืนจริงหมายความว่าการเขียนนั้นประสบความสำเร็จและคุณสามารถเขียนข้อมูลเพิ่มเติมได้ หากเป็นเท็จก็หมายถึงข้อผิดพลาดที่เกิดขึ้นและคุณไม่สามารถเขียนต่อไปได้ สตรีมที่เขียนได้ก่อให้เกิดเหตุการณ์ท่อระบายน้ำเพื่อบอกคุณว่าคุณสามารถเขียนข้อมูลต่อไปได้
หลังจากเขียนข้อมูล
เมื่อคุณไม่จำเป็นต้องเขียนข้อมูลคุณสามารถเรียกวิธีการสิ้นสุด () เพื่อบอกสตรีมว่าคุณเขียนเสร็จแล้ว สมมติว่า Res เป็นวัตถุตอบกลับ HTTP คุณมักจะส่งการตอบกลับไปยังเบราว์เซอร์:
res.write ('ข้อมูลบางส่วน !!');
res.end ();
เมื่อมีการเรียกว่าสิ้นสุด () ข้อมูลทั้งหมดจะถูกเขียนและสตรีมจะทริกเกอร์เหตุการณ์เสร็จสิ้น โปรดทราบว่าหลังจากการโทรสิ้นสุด () คุณไม่สามารถเขียนข้อมูลลงในสตรีมที่เขียนได้อีกต่อไป ตัวอย่างเช่นรหัสต่อไปนี้จะรายงานข้อผิดพลาด:
res.write ('ข้อมูลบางส่วน !!');
res.end ();
res.write ('พยายามเขียนอีกครั้ง'); //ข้อผิดพลาด !
นี่คือเหตุการณ์สำคัญบางอย่างที่เกี่ยวข้องกับสตรีมที่เขียนได้:
1. ข้อผิดพลาดไฟเมื่อเกิดข้อผิดพลาดในการเขียนหรือการเชื่อมโยง
2. กำหนดเมื่อสตรีมที่อ่านได้เชื่อมโยงกับสตรีมที่เขียนได้เหตุการณ์นี้จะทริกเกอร์
3. อูพีเพียจะยิงเมื่อมีการเรียกใช้ UNPIP โดยสตรีมที่อ่านได้
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น