Node มีชุดข้อมูล API ของสตรีมข้อมูลที่สามารถประมวลผลไฟล์เช่นการประมวลผลสตรีมเครือข่ายซึ่งสะดวกมากในการใช้งาน แต่จะอนุญาตให้ประมวลผลไฟล์ตามลำดับและไม่สามารถอ่านและเขียนไฟล์แบบสุ่ม ดังนั้นจึงจำเป็นต้องใช้การดำเนินการระบบไฟล์พื้นฐานบางอย่าง
บทนี้ครอบคลุมพื้นฐานของการประมวลผลไฟล์รวมถึงวิธีเปิดไฟล์อ่านส่วนหนึ่งของไฟล์ข้อมูลเขียนและปิดไฟล์
API ไฟล์ของโหนดจำนวนมากเกือบจะเป็นแบบจำลองของไฟล์ API ที่เกี่ยวข้องใน UNIX (POSIX) ตัวอย่างเช่นวิธีการใช้ตัวอธิบายไฟล์ เช่นเดียวกับใน UNIX ตัวอธิบายไฟล์ยังเป็นหมายเลขจำนวนเต็มในโหนดซึ่งแสดงถึงดัชนีของเอนทิตีในตาราง descriptor ไฟล์กระบวนการ
มี 3 ตัวอธิบายไฟล์พิเศษ - 1, 2 และ 3 พวกเขาเป็นตัวแทนของอินพุตมาตรฐานเอาต์พุตมาตรฐานและตัวอธิบายไฟล์ข้อผิดพลาดมาตรฐานตามลำดับ อินพุตมาตรฐานตามชื่อหมายถึงเป็นสตรีมแบบอ่านอย่างเดียวซึ่งกระบวนการใช้เพื่ออ่านข้อมูลจากคอนโซลหรือช่องทางกระบวนการ เอาต์พุตมาตรฐานและข้อผิดพลาดมาตรฐานเป็นตัวอธิบายไฟล์ที่ใช้กับข้อมูลเอาต์พุตเท่านั้น พวกเขามักจะใช้ในการส่งออกข้อมูลไปยังคอนโซลกระบวนการหรือไฟล์อื่น ๆ ข้อผิดพลาดมาตรฐานมีหน้าที่รับผิดชอบในการส่งออกข้อความแสดงข้อผิดพลาดในขณะที่เอาต์พุตมาตรฐานรับผิดชอบการส่งออกกระบวนการทั่วไป
เมื่อกระบวนการเริ่มต้นแล้วตัวอธิบายไฟล์เหล่านี้สามารถใช้งานได้และพวกเขาไม่ได้มีไฟล์จริงที่สอดคล้องกัน คุณไม่สามารถอ่านและเขียนข้อมูลได้ในสถานที่สุ่ม (หมายเหตุของนักแปล: ข้อความต้นฉบับคือคุณสามารถเขียนและอ่านจากตำแหน่งเฉพาะภายในไฟล์ขึ้นอยู่กับบริบทผู้เขียนอาจเขียนน้อยลง "ไม่") และสามารถอ่านและส่งออกตามลำดับเช่นสตรีมข้อมูลเครือข่ายปฏิบัติการและข้อมูลที่เขียนไม่สามารถแก้ไขได้
ไฟล์ธรรมดาไม่อยู่ภายใต้ข้อ จำกัด นี้ ตัวอย่างเช่นในโหนดคุณสามารถสร้างไฟล์ที่สามารถต่อท้ายข้อมูลไปยังหางเท่านั้นและคุณยังสามารถสร้างไฟล์ที่อ่านและเขียนตำแหน่งสุ่ม
การดำเนินการที่เกี่ยวข้องกับไฟล์เกือบทั้งหมดเกี่ยวข้องกับการประมวลผลพา ธ ไฟล์ บทนี้จะแนะนำฟังก์ชั่นเครื่องมือเหล่านี้ก่อนจากนั้นอธิบายการอ่านไฟล์เชิงลึกการเขียนและการดำเนินการข้อมูล
กระบวนการไฟล์
เส้นทางไฟล์แบ่งออกเป็นสองประเภท: เส้นทางสัมพัทธ์และเส้นทางที่สมบูรณ์และใช้เพื่อแสดงไฟล์เฉพาะ คุณสามารถรวมพา ธ ไฟล์ดึงข้อมูลชื่อไฟล์และตรวจพบว่าไฟล์มีอยู่หรือไม่
ในโหนดคุณสามารถใช้สตริงเพื่อจัดการเส้นทางไฟล์ แต่จะทำให้ปัญหาซับซ้อนขึ้น ตัวอย่างเช่นคุณต้องการเชื่อมต่อส่วนต่าง ๆ ของเส้นทางบางส่วนจบลงด้วย "/" แต่บางส่วนไม่ได้และตัวแยกเส้นทางอาจแตกต่างกันในระบบปฏิบัติการที่แตกต่างกันดังนั้นเมื่อคุณเชื่อมต่อพวกเขารหัสจะเป็นคำพูดและลำบากมาก
โชคดีที่โหนดมีโมดูลที่เรียกว่าเส้นทางที่สามารถช่วยให้คุณสร้างมาตรฐานเชื่อมต่อแยกวิเคราะห์เส้นทางแปลงจากเส้นทางสัมบูรณ์เป็นเส้นทางสัมพัทธ์แยกส่วนต่าง ๆ ของข้อมูลจากเส้นทางและตรวจพบว่าไฟล์มีอยู่หรือไม่ โดยทั่วไปโมดูลพา ธ เป็นเพียงการประมวลผลสตริงและจะไม่ไปที่ระบบไฟล์สำหรับการตรวจสอบ (ข้อยกเว้นฟังก์ชั่น path.exists)
มาตรฐานของเส้นทาง
การทำให้เป็นมาตรฐานก่อนที่จะจัดเก็บหรือใช้เส้นทางมักเป็นความคิดที่ดี ตัวอย่างเช่นพา ธ ไฟล์ที่ได้รับจากไฟล์อินพุตหรือการกำหนดค่าของผู้ใช้หรือเส้นทางที่เชื่อมต่อด้วยเส้นทางสองเส้นทางขึ้นไปควรได้มาตรฐาน เส้นทางสามารถทำให้เป็นมาตรฐานโดยใช้ฟังก์ชันปกติของโมดูลพา ธ และยังสามารถจัดการได้ ".. ", "." // "ตัวอย่างเช่น:
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.normalize ('/foo/bar // baz/asdf/quux/.. ');
// => '/foo/bar/baz/asdf'
เส้นทางการเชื่อมต่อ
การใช้ฟังก์ชั่น PATH.Join () คุณสามารถเชื่อมโยงสายไฟได้มาก คุณสามารถส่งสายพา ธ ทั้งหมดไปยังฟังก์ชันเข้าร่วม () ตามลำดับ:
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.join ('/foo', 'bar', 'baz/asdf', 'Quux', '.. ');
// => '/foo/bar/baz/asdf'
อย่างที่คุณเห็น path.join () จะทำให้เส้นทางภายในปกติโดยอัตโนมัติ
เส้นทาง
ใช้ path.resolve () เพื่อแก้ไขหลายเส้นทางในเส้นทางที่แน่นอน ฟังก์ชั่นของมันเป็นเหมือนการดำเนินการ "CD" ทีละคนบนเส้นทางเหล่านี้ ซึ่งแตกต่างจากพารามิเตอร์ของคำสั่ง cd พา ธ เหล่านี้อาจเป็นไฟล์และพวกเขาไม่จำเป็นต้องมีอยู่ในชีวิตจริง - เมธอด path.resolve () จะไม่เข้าถึงระบบไฟล์พื้นฐานเพื่อตรวจสอบว่าเส้นทางนั้นมีอยู่หรือไม่
ตัวอย่างเช่น:
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.resolve ('/foo/bar', './baz');
// =>/foo/bar/baz
path.resolve ('/foo/bar', '/tmp/file/');
// =>/tmp/ไฟล์
หากผลการแยกวิเคราะห์ไม่ใช่เส้นทางที่แน่นอน PATH.ResOlve () จะผนวกไดเรกทอรีการทำงานปัจจุบันเป็นเส้นทางไปยังผลลัพธ์การแยกวิเคราะห์ตัวอย่างเช่น:
การคัดลอกรหัสมีดังนี้:
path.resolve ('wwwroot', 'static_files/png/', '../gif/image.gif');
// ถ้าไดเรกทอรีการทำงานปัจจุบันคือ/home/myself/node มันจะกลับมา
// => /home/myself/node/wwwroot/static_files/gif/image.gif '
คำนวณเส้นทางสัมพัทธ์ของสองเส้นทางสัมบูรณ์
path.relative () สามารถบอกคุณได้ว่าคุณข้ามจากที่อยู่สัมบูรณ์หนึ่งไปยังที่อยู่สัมบูรณ์อื่นเช่น:
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.relative ('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
// => ../../impl/bbb
แยกข้อมูลจากเส้นทาง
ใช้เส้นทาง "/foo/bar/myfile.txt" เป็นตัวอย่าง หากคุณต้องการรับเนื้อหาทั้งหมดของไดเรกทอรีหลัก (/foo/bar) หรืออ่านไฟล์อื่น ๆ ของไดเรกทอรีระดับเดียวกันสำหรับสิ่งนี้คุณต้องใช้ path.dirname (filepath) เพื่อรับส่วนไดเรกทอรีของเส้นทางไฟล์เช่น:
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.dirname ('/foo/bar/baz/asdf/quux.txt');
// =>/foo/bar/baz/asdf
หรือหากคุณต้องการรับชื่อไฟล์จากเส้นทางไฟล์นั่นคือส่วนสุดท้ายของเส้นทางไฟล์คุณสามารถใช้ฟังก์ชัน path.basename:
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.basename ('/foo/bar/baz/asdf/quux.html')
// => quux.html
พา ธ ไฟล์อาจมีส่วนขยายไฟล์ซึ่งมักจะเป็นส่วนหนึ่งของสตริงหลังจากสุดท้าย " อักขระในชื่อไฟล์
path.basename ยังสามารถยอมรับสตริงชื่อส่วนขยายเป็นพารามิเตอร์ที่สองเพื่อให้ชื่อไฟล์ที่ส่งคืนจะลบส่วนขยายโดยอัตโนมัติและส่งคืนส่วนชื่อของไฟล์:
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.basename ('/foo/bar/baz/asdf/quux.html', '.html');
// => quux
ในการทำเช่นนี้คุณต้องรู้นามสกุลไฟล์ก่อน คุณสามารถใช้ path.extname () เพื่อรับส่วนขยาย:
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.extName ('/a/b/index.html');
// => '.html'
path.extName ('/a/bc/index');
-
path.extName ('/a/bc/.');
-
path.extName ('/a/bc/d.');
-
ตรวจสอบว่าเส้นทางมีอยู่จริง
จนถึงตอนนี้การดำเนินการประมวลผลพา ธ ที่กล่าวถึงข้างต้นไม่มีส่วนเกี่ยวข้องกับระบบไฟล์พื้นฐาน แต่เป็นเพียงการดำเนินการสตริง อย่างไรก็ตามบางครั้งคุณต้องพิจารณาว่าเส้นทางไฟล์มีอยู่หรือไม่ ตัวอย่างเช่นบางครั้งคุณต้องพิจารณาว่ามีไฟล์หรือไดเรกทอรีอยู่หรือไม่ หากไม่มีอยู่คุณสามารถใช้ path.exsits ():
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.exists ('/etc/passwd', ฟังก์ชั่น (มีอยู่) {
console.log ('มีอยู่:' มีอยู่);
// => จริง
-
path.exists ('/doT_not_exist', ฟังก์ชั่น (มีอยู่) {
console.log ('มีอยู่:' มีอยู่);
// => เท็จ
-
หมายเหตุ: เริ่มต้นจากเวอร์ชัน Node0.8 มีการย้ายจากโมดูลเส้นทางไปยังโมดูล FS และกลายเป็น fs.exists ยกเว้นเนมสเปซไม่มีอะไรเปลี่ยนแปลงอีก:
การคัดลอกรหัสมีดังนี้:
var fs = ต้องการ ('fs');
fs.exists ('/doT_not_exist', ฟังก์ชั่น (มีอยู่) {
console.log ('มีอยู่:' มีอยู่);
// => เท็จ
-
path.exists () เป็นการดำเนินการ I/O เนื่องจากเป็นแบบอะซิงโครนัสจึงจำเป็นต้องใช้ฟังก์ชั่นการโทรกลับ เมื่อการดำเนินการ I/O ส่งคืนฟังก์ชั่นการโทรกลับจะถูกเรียกและผลลัพธ์จะถูกส่งผ่านไป นอกจากนี้คุณยังสามารถใช้ path.existssync เวอร์ชันซิงโครนัสซึ่งมีฟังก์ชั่นเดียวกันยกเว้นว่าไม่เรียกฟังก์ชันการโทรกลับ แต่ส่งคืนผลลัพธ์โดยตรง:
การคัดลอกรหัสมีดังนี้:
var path = ต้องการ ('เส้นทาง');
path.existssync ('/etc/passwd');
// => จริง
รู้เบื้องต้นเกี่ยวกับโมดูล FS
โมดูล FS มีฟังก์ชั่นที่เกี่ยวข้องทั้งหมดสำหรับการสืบค้นไฟล์และการประมวลผล การใช้ฟังก์ชั่นเหล่านี้คุณสามารถสืบค้นข้อมูลไฟล์อ่านเขียนและปิดไฟล์ นำเข้าโมดูล FS เช่นนี้:
การคัดลอกรหัสมีดังนี้:
var fs = ต้องการ ('fs')
ข้อมูลไฟล์สอบถามข้อมูล
บางครั้งคุณอาจต้องรู้ข้อมูลไฟล์เช่นขนาดไฟล์วันที่สร้างหรือสิทธิ์ คุณสามารถใช้ฟังก์ชั่น fs.stath เพื่อสอบถามข้อมูลเมตาของไฟล์หรือไดเรกทอรี:
การคัดลอกรหัสมีดังนี้:
var fs = ต้องการ ('fs');
fs.stat ('/etc/passwd', ฟังก์ชั่น (err, stats) {
ถ้า (err) {โยน err;}
console.log (สถิติ);
-
ข้อมูลตัวอย่างรหัสนี้จะมีเอาต์พุตคล้ายกับต่อไปนี้
การคัดลอกรหัสมีดังนี้:
{dev: 234881026
INO: 95028917
โหมด: 33188
nlink: 1,
UID: 0,
GID: 0,
rdev: 0,
ขนาด: 5086,
blksize: 4096,
บล็อก: 0,
ATIME: FRI, 18 พ.ย. 2554 22:44:47 GMT,
mtime: thu, 08 ก.ย. 2011 23:50:04 GMT,
Ctime: Thu, 08 ก.ย. 2554 23:50:04 GMT}
1. การโทร FS.STAT () จะผ่านอินสแตนซ์ของคลาสสถิติเป็นพารามิเตอร์ไปยังฟังก์ชันการโทรกลับ คุณสามารถใช้อินสแตนซ์สถิติได้เช่นนี้:
2.stats.isfile () - ส่งคืนจริงถ้าเป็นไฟล์มาตรฐานไม่ใช่ไดเรกทอรีซ็อกเก็ตลิงก์สัญลักษณ์หรืออุปกรณ์มิฉะนั้นเท็จ
3.stats.isdiretory () - ถ้าเป็นไดเรกทอรีให้ส่งคืนอังคารมิฉะนั้นเท็จ
4.Stats.isblockDevice () - ส่งคืนจริงถ้าเป็นอุปกรณ์บล็อก ในระบบ UNIX ส่วนใหญ่อุปกรณ์บล็อกมักจะอยู่ในไดเรกทอรี /dev
5. Stats.ischracterdevice () - กลับมาจริงถ้าเป็นอุปกรณ์ตัวละคร
6.Stats.IssyMbolickLink () - ส่งคืนจริงถ้ามันเป็นลิงค์ไฟล์
7.Stats.isfifo () - ถ้าเป็น FIFO (UNIX ชื่อพิเศษประเภทพิเศษ) จะส่งคืนจริง
8. Stats.issocket () - ถ้าเป็นซ็อกเก็ต Unix (สิ่งที่ต้องทำ: googe it)
เปิดไฟล์
ก่อนที่จะอ่านหรือประมวลผลไฟล์คุณต้องใช้ฟังก์ชั่น Fs.Open ก่อนเพื่อเปิดไฟล์จากนั้นฟังก์ชันการเรียกกลับที่คุณให้จะถูกเรียกและรับ descriptor ของไฟล์ ในภายหลังคุณสามารถใช้ตัวอธิบายไฟล์นี้เพื่ออ่านและเขียนไฟล์ที่เปิด:
การคัดลอกรหัสมีดังนี้:
var fs = ต้องการ ('fs');
fs.open ('/path/to/file', 'r', ฟังก์ชั่น (err, fd) {
// ได้รับ FD File Descriptor
-
พารามิเตอร์แรกของ Fs.Open คือเส้นทางไฟล์และพารามิเตอร์ที่สองคือแท็กบางตัวที่ใช้เพื่อระบุว่าไฟล์เปิดโหมดใด แท็กเหล่านี้อาจเป็น R, R+, W, W+, A หรือ A+ ด้านล่างนี้เป็นคำอธิบายของแท็กเหล่านี้ (จากหน้า fopen ของเอกสาร UNIX)
1.R - เปิดไฟล์ในโหมดอ่านอย่างเดียวตำแหน่งเริ่มต้นของสตรีมข้อมูลเริ่มต้นที่ไฟล์
2.R+ - เปิดไฟล์ในลักษณะที่อ่านได้และเขียนได้และตำแหน่งเริ่มต้นของสตรีมข้อมูลเริ่มต้นที่ไฟล์
3.W - หากไฟล์มีอยู่ให้ล้างความยาวของไฟล์ด้วย 0 นั่นคือเนื้อหาของไฟล์จะหายไป หากไม่มีอยู่ให้ลองสร้างมัน ตำแหน่งเริ่มต้นของสตรีมข้อมูลเริ่มต้นที่ไฟล์
4.W+ - เปิดไฟล์ในลักษณะที่อ่านได้และเขียนได้ หากไฟล์ไม่มีอยู่ให้ลองสร้าง หากไฟล์มีอยู่ให้ล้างความยาวของไฟล์ด้วย 0 นั่นคือเนื้อหาของไฟล์จะหายไป ตำแหน่งเริ่มต้นของสตรีมข้อมูลเริ่มต้นที่ไฟล์
5.A - เปิดไฟล์ในลักษณะการเขียนเท่านั้น หากไฟล์ไม่มีอยู่ให้ลองสร้าง ตำแหน่งเริ่มต้นของสตรีมข้อมูลอยู่ที่ส่วนท้ายของไฟล์ การดำเนินการเขียนที่ตามมาแต่ละครั้งต่อท้ายข้อมูลที่ด้านหลังของไฟล์
6.A+ - เปิดไฟล์ในลักษณะที่อ่านได้และเขียนได้ หากไฟล์ไม่มีอยู่ให้ลองสร้าง ตำแหน่งเริ่มต้นของสตรีมข้อมูลอยู่ที่ส่วนท้ายของไฟล์ การดำเนินการเขียนที่ตามมาแต่ละครั้งจะผนวกข้อมูลที่ด้านหลังของไฟล์
อ่านไฟล์
เมื่อเปิดไฟล์แล้วคุณสามารถเริ่มอ่านเนื้อหาไฟล์ได้ แต่ก่อนที่คุณจะเริ่มคุณต้องสร้างบัฟเฟอร์เพื่อวางข้อมูล วัตถุบัฟเฟอร์นี้จะถูกส่งผ่านไปยังฟังก์ชั่น fs.read เป็นพารามิเตอร์และจะถูกเติมด้วยข้อมูลโดย fs.read
การคัดลอกรหัสมีดังนี้:
var fs = ต้องการ ('fs');
fs.open ('./ my_file.txt', 'r', ฟังก์ชั่นเปิด (err, fd) {
if (err) {โยน err}
var readBuffer = บัฟเฟอร์ใหม่ (1024)
bufferoffset = 0,
bufferLength = readBuffer.length,
Fileposition = 100;
fs.read (fd,
ReadBuffer
bufferoffset
BufferLength
Fileposition
ฟังก์ชั่นอ่าน (err, readbytes) {
ถ้า (err) {โยน err; -
console.log ('เพียงแค่อ่าน' + readbytes + 'bytes');
if (readbytes> 0) {
console.log (readbuffer.slice (0, readbytes));
-
-
-
รหัสข้างต้นพยายามเปิดไฟล์ หลังจากเปิดสำเร็จ (เรียกใช้ฟังก์ชั่นที่เปิดอยู่) มันจะเริ่มขอให้อ่านข้อมูล 1024 ไบต์ถัดไปจากไบต์ที่ 100 ของสตรีมไฟล์ (บรรทัดที่ 11)
พารามิเตอร์สุดท้ายของ fs.read () เป็นฟังก์ชันการโทรกลับ (บรรทัด 16) เมื่อเกิดสถานการณ์สามสถานการณ์ต่อไปนี้จะถูกเรียก:
1. เกิดข้อผิดพลาด
2. ข้อมูลถูกอ่านสำเร็จ
3. ไม่มีข้อมูลที่จะอ่าน
หากเกิดข้อผิดพลาดพารามิเตอร์แรก (ERR) จะให้ฟังก์ชั่นการเรียกกลับพร้อมกับวัตถุที่มีข้อความแสดงข้อผิดพลาดมิฉะนั้นพารามิเตอร์นี้จะเป็นโมฆะ หากข้อมูลถูกอ่านสำเร็จพารามิเตอร์ที่สอง (ReadBytes) จะระบุขนาดของข้อมูลที่อ่านในบัฟเฟอร์ หากค่าเป็น 0 นั่นหมายความว่าการสิ้นสุดของไฟล์ได้มาถึงแล้ว
หมายเหตุ: เมื่อวัตถุบัฟเฟอร์ถูกส่งไปยัง fs.open () การควบคุมของวัตถุบัฟเฟอร์จะถูกถ่ายโอนไปยังคำสั่งอ่าน เฉพาะเมื่อฟังก์ชั่นการโทรกลับถูกเรียกว่าการควบคุมวัตถุบัฟเฟอร์จะถูกส่งคืนให้คุณ ดังนั้นก่อนหน้านี้อย่าอ่านและเขียนหรือปล่อยให้การเรียกใช้ฟังก์ชันอื่นใช้วัตถุบัฟเฟอร์นี้ มิฉะนั้นคุณอาจอ่านข้อมูลที่ไม่สมบูรณ์และแย่กว่านั้นคุณอาจเขียนข้อมูลลงในวัตถุบัฟเฟอร์นี้พร้อมกัน
เขียนไฟล์
ผ่านวัตถุบัฟเฟอร์ที่มีข้อมูลโดยส่งไปยัง fs.write () และเขียนข้อมูลไปยังไฟล์เปิด:
การคัดลอกรหัสมีดังนี้:
var fs = ต้องการ ('fs');
fs.open ('./ my_file.txt', 'a', ฟังก์ชั่นเปิด (err, fd) {
ถ้า (err) {โยน err; -
var writeBuffer = บัฟเฟอร์ใหม่ ('การเขียนสตริงนี้')
BufferPosition = 0,
bufferLength = writeBuffer.Length, filePosition = null;
fs.write (fd,
Writebuffer
บัฟเฟอร์
BufferLength
Fileposition
ฟังก์ชั่นเขียน (ทำผิดเขียน) {
ถ้า (err) {โยน err; -
console.log ('เขียน' + เขียน + 'ไบต์');
-
-
ในตัวอย่างนี้บรรทัดที่สองของรหัสพยายามเปิดไฟล์ในโหมดผนวก (a) จากนั้นบรรทัดที่เจ็ดของรหัส (หมายเหตุของนักแปล: ข้อความต้นฉบับคือ 9) เขียนข้อมูลไปยังไฟล์ วัตถุบัฟเฟอร์จะต้องมาพร้อมกับข้อมูลหลายอย่างเป็นพารามิเตอร์:
1. ข้อมูลบัฟเฟอร์
2. ข้อมูลที่จะเขียนเริ่มต้นในบัฟเฟอร์ที่ไหน
3. ความยาวของข้อมูลที่จะเขียน
4. จะเขียนข้อมูลไปยังไฟล์ได้ที่ไหน
5. ฟังก์ชั่นการโทรกลับที่เรียกว่าหลังจากการดำเนินการเสร็จสิ้น
ในตัวอย่างนี้พารามิเตอร์ FilePostion เป็นโมฆะซึ่งหมายความว่าฟังก์ชั่นการเขียนจะเขียนข้อมูลไปยังตำแหน่งปัจจุบันของตัวชี้ไฟล์ เนื่องจากเป็นไฟล์ที่เปิดในโหมดผนวกตัวชี้ไฟล์อยู่ที่ส่วนท้ายของไฟล์
เช่นเดียวกับการดำเนินการอ่านอย่าใช้วัตถุบัฟเฟอร์ขาเข้าที่ใช้ในระหว่างการดำเนินการ fs.write เมื่อ fs.write เริ่มดำเนินการมันจะได้รับการควบคุมเหนือวัตถุบัฟเฟอร์นั้น คุณสามารถรอได้จนกว่าจะมีการเรียกใช้ฟังก์ชันการโทรกลับก่อนที่จะนำกลับมาใช้ใหม่
ปิดไฟล์
คุณอาจสังเกตเห็นว่าจนถึงตอนนี้ตัวอย่างทั้งหมดในบทนี้ไม่มีรหัสที่จะปิดไฟล์ เนื่องจากเป็นเพียงตัวอย่างเล็กและง่ายเมื่อใช้เพียงครั้งเดียวระบบปฏิบัติการทำให้มั่นใจได้ว่าไฟล์ทั้งหมดจะถูกปิดเมื่อกระบวนการโหนดสิ้นสุดลง
อย่างไรก็ตามในแอปพลิเคชันจริงเมื่อเปิดไฟล์แล้วคุณต้องการให้แน่ใจว่าคุณปิดท้าย ในการทำเช่นนี้คุณจะต้องติดตามตัวอธิบายไฟล์ที่เปิดทั้งหมดเหล่านั้นแล้วโทรหา fs.close (fd [, callback]) เมื่อพวกเขาไม่ได้ใช้เพื่อปิดในที่สุดอีกต่อไป หากคุณไม่สนใจมันเป็นเรื่องง่ายที่จะพลาดตัวบ่งชี้ไฟล์บางตัว ตัวอย่างต่อไปนี้มีฟังก์ชั่นที่เรียกว่า OpenAndWriteToSystemLog ซึ่งแสดงวิธีปิดไฟล์อย่างระมัดระวัง:
การคัดลอกรหัสมีดังนี้:
var fs = ต้องการ ('fs');
ฟังก์ชั่น openandwriteTosystemlog (writeBuffer, callback) {
fs.open ('./ my_file', 'a', ฟังก์ชั่นเปิด (err, fd) {
if (err) {return callback (err); -
ฟังก์ชั่น NotifyError (ERR) {
fs.close (fd, function () {
การโทรกลับ (err);
-
-
var bufferOffset = 0,
bufferLength = writeBuffer.length,
fileposition = null;
fs.write (fd, writebuffer, bufferoffset, bufferlength, fileposition
ฟังก์ชั่นเขียน (ทำผิดเขียน) {
ถ้า (err) {return notifyError (err); -
fs.close (fd, function () {
การโทรกลับ (err);
-
-
-
-
-
OpenAndWriteTosystemLog (
บัฟเฟอร์ใหม่ ('เขียนสตริงนี้')
ฟังก์ชั่นเสร็จสิ้น (err) {
ถ้า (err) {
console.log ("ข้อผิดพลาดขณะเปิดและเขียน:", err.message);
กลับ;
-
console.log ('ทั้งหมดทำโดยไม่มีข้อผิดพลาด');
-
-
ที่นี่มีฟังก์ชั่นที่เรียกว่า OpenAndWriteToSystemLog ซึ่งยอมรับวัตถุบัฟเฟอร์ที่มีข้อมูลที่จะเขียนและฟังก์ชั่นการเรียกกลับที่เรียกว่าหลังจากการดำเนินการเสร็จสมบูรณ์หรือเกิดข้อผิดพลาด หากเกิดข้อผิดพลาดพารามิเตอร์แรกของฟังก์ชันการเรียกกลับจะมีวัตถุข้อผิดพลาดนี้
โปรดทราบว่าฟังก์ชั่นภายใน NotifyError ซึ่งปิดไฟล์และรายงานข้อผิดพลาดที่เกิดขึ้น
หมายเหตุ: จนกว่าจะถึงตอนนี้คุณจะรู้วิธีใช้การดำเนินการอะตอมพื้นฐานเพื่อเปิดอ่านเขียนและปิดไฟล์ อย่างไรก็ตามโหนดยังมีชุดตัวสร้างขั้นสูงที่อนุญาตให้คุณประมวลผลไฟล์ในวิธีที่ง่ายกว่า
ตัวอย่างเช่นคุณต้องการใช้วิธีที่ปลอดภัยในการอนุญาตให้มีการดำเนินการเขียนสองรายการขึ้นไปเพื่อผนวกข้อมูลไปยังไฟล์พร้อมกันและคุณสามารถใช้ Writestream ได้
นอกจากนี้หากคุณต้องการอ่านพื้นที่บางส่วนของไฟล์คุณสามารถพิจารณาใช้ readstream กรณีการใช้งานทั้งสองนี้จะถูกนำมาใช้ในบทที่ 9 "การอ่านและการเขียนสตรีมมิ่งของข้อมูล"
สรุป
เมื่อคุณใช้ไฟล์คุณจะต้องประมวลผลและแยกข้อมูลเส้นทางไฟล์ในกรณีส่วนใหญ่ โดยการใช้โมดูลพา ธ คุณสามารถเชื่อมต่อพา ธ กำหนดเส้นทางที่เป็นมาตรฐานคำนวณความแตกต่างของเส้นทางและแปลงเส้นทางสัมพัทธ์เป็นเส้นทางสัมบูรณ์ คุณสามารถแยกส่วนประกอบพา ธ เช่นส่วนขยายชื่อไฟล์ไดเรกทอรี ฯลฯ
Node จัดเตรียมชุดของ API พื้นฐานในโมดูล FS เพื่อเข้าถึงระบบไฟล์และ API พื้นฐานใช้ตัวอธิบายไฟล์เพื่อจัดการไฟล์ คุณสามารถเปิดไฟล์ด้วย fs.open เขียนไฟล์ด้วย fs.write อ่านไฟล์ด้วย fs.read และปิดไฟล์ด้วย fs.close
เมื่อเกิดข้อผิดพลาดคุณควรใช้ตรรกะการจัดการข้อผิดพลาดที่ถูกต้องเพื่อปิดไฟล์ - เพื่อให้แน่ใจว่าตัวอธิบายไฟล์เปิดเหล่านั้นจะถูกปิดก่อนที่การโทรจะส่งคืน