I/O ย่อมาจาก Input/Output
การป้อนข้อมูลหมายถึงข้อมูลทั้งหมดที่เข้ามาในบางสิ่งบางอย่าง (คอมพิวเตอร์ วิธี Ruby สมองของคุณ)
ตัวอย่างการป้อนข้อมูล :
- กดแป้นของคุณบนแป้นพิมพ์
- คลิกเมาส์
- หนังสือที่คุณอ่าน
โดยเอาต์พุต เราหมายถึงทุกสิ่งที่ออกมาซึ่งเป็นผลมาจากอินพุต
ตัวอย่างผลงาน :
- ผลลัพธ์ของ 1 + 1
- เขียนบทสรุปของบทความที่คุณอ่าน
- กาแฟ
ใน Ruby เมื่อเราพูดถึง i/o เรามักจะหมายถึงการอ่านไฟล์ การทำงานกับซ็อกเก็ตเครือข่าย และการพิมพ์ข้อมูลบนหน้าจอ
ทำความเข้าใจคลาส IO
IO ก็เป็นคลาสใน Ruby ด้วย
เป็นคลาสหลักสำหรับอ็อบเจ็กต์อื่นๆ เช่น File &Socket .
วัตถุ IO ทั้งหมดมีการดำเนินการเหล่านี้ :
- เปิด / ปิด
- อ่าน
- เขียน
ออบเจ็กต์ IO อิงตาม ตัวอธิบายไฟล์ .
ทุกกระบวนการที่ทำงานอยู่ในคอมพิวเตอร์ของคุณมีตารางข้อมูลภายใน
ส่วนหนึ่งของตารางนี้มีรายการตัวอธิบายไฟล์
ตัวอธิบายไฟล์คือ การจับคู่ระหว่างจำนวนเต็มกับชื่อไฟล์ .
คุณสามารถดูรายการตัวอธิบายไฟล์นี้ได้ใน Linux
ด้วยคำสั่งนี้ :
# Assuming you have irb open on another window ls -lh /proc/`pgrep irb`/fd/ # lrwx------ 1 jesus jesus 64 Feb 3 15:54 0 -> /dev/pts/3 # lrwx------ 1 jesus jesus 64 Feb 3 15:54 1 -> /dev/pts/3 # lrwx------ 1 jesus jesus 64 Feb 3 15:54 2 -> /dev/pts/3
คุณสามารถสร้าง file descriptor ใหม่ใน Ruby ด้วย sysopen วิธีการ
ตัวอย่าง :
fd = IO.sysopen('/dev/null', 'w')
# 10
ตอนนี้คุณสามารถเปิดช่องทางการสื่อสารด้วยตัวอธิบายไฟล์นี้ (10 )
ถูกใจสิ่งนี้ :
io = IO.new(fd)
และเขียนลงไป :
io << 'orange'
สังเกตว่า IO ไม่สนใจว่า file descriptor จะจับคู่กับไฟล์จริง อุปกรณ์ (เช่น ฮาร์ดดิสก์) หรือซ็อกเก็ตเครือข่าย
วิธีการเปิดไฟล์อธิบายสำหรับการเขียน
เมื่อคุณสร้าง file descriptor ใหม่โดยใช้ sysopen หรือเปิดไฟล์โดยใช้ File.open คุณมีทางเลือกไม่กี่ทาง
โดยค่าเริ่มต้น การสื่อสารเป็นแบบอ่านอย่างเดียว
คุณสามารถระบุโหมดได้ :
r(อ่านค่าเริ่มต้น)w(เขียน)w+(อ่านและเขียน)a(ต่อท้าย)
ตัวอย่าง :
fd = IO.sysopen('/dev/tty1', 'w+')
นี่เป็นการเปิด /dev/tty1 พร้อมโหมดอ่าน + เขียน
3 สตรีม IO มาตรฐาน
เมื่อคุณเปิดโปรแกรมใหม่ (เอดิเตอร์ เทอร์มินัล ล่าม Ruby ฯลฯ) โปรแกรมจะเปิดช่องทางการสื่อสาร 3 ช่องทางตามค่าเริ่มต้น
3 ไฟล์อธิบาย
พวกเขา :
- stdin (อินพุต)
- stdout (เอาต์พุต)
- stderr (ข้อผิดพลาด)
ใน Ruby คุณสามารถเข้าถึงสิ่งเหล่านี้ได้โดยตรง โดยใช้รูปแบบคงที่หรือรูปแบบตัวแปรส่วนกลาง
ตัวอย่าง :
$stdout << "abc\n"
เมื่อคุณเขียนถึง $stdout เหมือนกับการเรียกใช้เมธอด puts
เอาต์พุตมาตรฐาน เชื่อมโยงกับเทอร์มินัลของคุณ
lrwx------ 1 jesus jesus 64 Feb 3 15:54 0 -> /dev/pts/3
/dev/pts/3นี้ เป็นอุปกรณ์เสมือนที่เครื่องอ่านบัตรของคุณอ่านเพื่อแสดงข้อความบนหน้าจอ
ข้อผิดพลาดมาตรฐาน ใช้สำหรับเอาต์พุตด้วยเช่นกัน แต่จะช่วยให้เทอร์มินัลของคุณมีโอกาสนำเสนอเนื้อหานี้ในรูปแบบที่ต่างออกไป เช่น ในแบบอักษรที่ใหญ่กว่า หรือในสีที่แตกต่างจากข้อความปกติ
คุณสามารถใช้ warn วิธีการพิมพ์ผิดพลาดมาตรฐาน
อินพุตมาตรฐาน คือที่ที่ผู้ใช้ป้อนข้อมูลอ่านจาก
คุณสามารถใช้ gets วิธีการอ่านจากอินพุตมาตรฐาน
วิธีการล้าง STDOUT และปิดใช้งานการบัฟเฟอร์
ออบเจ็กต์ IO มีบัฟเฟอร์ภายใน
ข้อมูลอินพุตจำนวนหนึ่งจะถูกบันทึกไว้ก่อนที่จะสามารถอ่านได้ .
นั่นเป็นเหตุผลที่บางครั้งคุณใช้ puts ...
แต่คุณไม่เห็นอะไรเลยจนกว่าโปรแกรมจะสิ้นสุด หรือบัฟเฟอร์เต็ม!
คุณสามารถปิดใช้งานการบัฟเฟอร์เช่นนี้ได้ :
$stdout.sync = true
หรือคุณสามารถล้างบัฟเฟอร์ด้วยตนเอง :
$stdout.flush
เมื่อปิดใช้งานบัฟเฟอร์ คุณจะเห็นผลลัพธ์โดยไม่ต้องรอ
การอ่านแบบแยกส่วน
เมื่อคุณอ่านจากวัตถุ IO คุณ read จนกว่าสตรีมจะจบลงด้วยสัญญาณ END-OF-FILE (EOF) สตรีมจะปิดลง หรือคุณได้รับจำนวนไบต์ที่กำหนด
สำหรับการเขียนโปรแกรมเครือข่ายและไฟล์ขนาดใหญ่ การอ่านเป็นส่วนเล็กๆ จะเป็นประโยชน์
อ่านเป็นท่อนๆ ได้ดังนี้ :
data = "" until io.eof? data << io.read(2048) end
ด้วยรหัสนี้ คุณสามารถประมวลผลข้อมูลเมื่อมีให้ใช้งานได้ โดยไม่ต้องรอให้การดาวน์โหลดทั้งหมดเสร็จสิ้น
สังเกตว่า eof? จะ "ปิดกั้น"
การบล็อกหมายความว่ารหัสของคุณจะ พักเครื่องจนถึง ระบบปฏิบัติการส่งสัญญาณว่ามี ข้อมูลใหม่ให้อ่าน .
วิธีใช้ท่อ IO สำหรับการสื่อสารสองทาง
Ruby ให้คุณสร้างท่อได้
ไพพ์คือคู่ของตัวอธิบายไฟล์ที่เชื่อมต่อถึงกัน
ใช้สำหรับการสื่อสารระหว่างกระบวนการ (IPC)
ตัวอย่าง :
read, write = IO.pipe
คุณสามารถใช้สิ่งนี้กับ fork เมธอด (ไม่มีใน Windows) เพื่อสร้างสำเนาของกระบวนการปัจจุบัน
กระบวนการทั้งสองนี้สามารถสื่อสารโดยใช้ไพพ์ได้
ตัวอย่าง :
if fork
write.close
puts "Message received: #{read.gets}"
read.close
else
read.close
write << "Buy some bananas!"
write.close
end
ซึ่งส่งผลใน :
# Message received: Buy some bananas!
วิธีใช้เคอร์เนลเปิดเมธอด
Ruby มี open . ที่ยืดหยุ่นมาก วิธีการ
ช่วยให้คุณสามารถเปิดไฟล์และอ่านข้อมูลจาก URL และแม้แต่เปิดไพพ์เพื่อเรียกใช้คำสั่งภายนอก
ตัวอย่าง :
open "abc.txt"
นั่นเป็นเหตุผลที่ควรหลีกเลี่ยงวิธีนี้ .
มีความเสี่ยงด้านความปลอดภัยที่สามารถทำสิ่งเหล่านี้ได้ทั้งหมด
ควรใช้ open . เฉพาะแทน วิธีที่คุณต้องการ
ตัวอย่าง :
File.open # File IO.popen # Process open URI.parse(...).open # URL open
ทั้งหมดนี้ส่งคืน IO วัตถุ
สรุป
คุณได้เรียนรู้เกี่ยวกับอินพุต/เอาต์พุตใน Ruby แล้ว! คุณได้เรียนรู้เกี่ยวกับ file descriptor แล้ว IO คลาส, บัฟเฟอร์, อ่านเป็นชิ้น &มาตรฐาน IO ลำธาร
อย่าลืมแชร์บทความนี้หากคุณชอบ
ขอบคุณสำหรับการอ่าน
