ตัวอ่านแบบมีบัฟเฟอร์
อ่านอย่างมีประสิทธิภาพด้วย bufio
ตัวอ่านแบบมีบัฟเฟอร์ เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
เหตุใดจึงใช้ Buffer อ่านข้อมูล
การอ่านทีละไบต์จากไฟล์หรือเครือข่ายจะเรียกใช้ระบบ ทุกครั้ง ซึ่งช้า
แพ็กเกจ bufio จะห่อหุ้มตัวอ่านและอ่านข้อมูลเป็นกลุ่มใหญ่ลงในบัฟเฟอร์ในหน่วยความจำ จากนั้นจึงนำข้อมูลที่อ่านทีละน้อยมาให้จากบัฟเฟอร์นั้น
- เรียกใช้ระบบน้อยลง
- เร็วขึ้นมากเมื่ออ่านข้อมูลทีละน้อยหลายครั้ง
การสร้าง bufio.Reader
ห่อหุ้ม io.Reader ใด ๆ ด้วย bufio.NewReader ในที่นี้เราห่อหุ้ม strings.Reader
package main
import (
"bufio"
"fmt"
"strings"
)
func main() {
r := bufio.NewReader(strings.NewReader("Hello, Go!"))
fmt.Printf("buffered reader ready: %T\n", r)
}การอ่าน Bytes
ReadByte จะส่งคืนไบต์ถัดไปทีละไบต์ โดยอ่านจากบัฟเฟอร์ ไม่ใช่เรียกใช้ระบบใหม่
package main
import (
"bufio"
"fmt"
"strings"
)
func main() {
r := bufio.NewReader(strings.NewReader("Go"))
b1, _ := r.ReadByte()
b2, _ := r.ReadByte()
fmt.Printf("%c%c\n", b1, b2)
}ReadString จนถึงตัวคั่น
ReadString(delim) จะอ่านจนพบไบต์ตัวคั่นครั้งแรก และส่งคืนข้อมูลทั้งหมด รวมตัวคั่นด้วย
package main
import (
"bufio"
"fmt"
"strings"
)
func main() {
r := bufio.NewReader(strings.NewReader("first,second,third"))
part, _ := r.ReadString(',')
fmt.Printf("%q\n", part)
}การดูข้อมูลถัดไป
Peek(n) จะส่งคืนไบต์ถัดไปจำนวน n ไบต์ โดยไม่ดึงไบต์เหล่านั้นออกไป เหมาะอย่างยิ่งสำหรับตัดสินใจว่าจะแยกวิเคราะห์อย่างไรก่อนดำเนินการต่อ
package main
import (
"bufio"
"fmt"
"strings"
)
func main() {
r := bufio.NewReader(strings.NewReader("HTTP/1.1"))
head, _ := r.Peek(4)
fmt.Printf("starts with: %s\n", head)
}ขนาดบัฟเฟอร์
bufio.NewReaderSize(r, size) จะกำหนดความจุของบัฟเฟอร์ บัฟเฟอร์ที่ใหญ่ขึ้นหมายถึงการอ่านจากแหล่งข้อมูลเบื้องหลังน้อยลง แต่ใช้หน่วยความจำมากขึ้น
package main
import (
"bufio"
"fmt"
"strings"
)
func main() {
r := bufio.NewReaderSize(strings.NewReader("data"), 4096)
fmt.Println("buffer size:", r.Size())
}ReadLine เทียบกับ ReadString
ReadString('\n') จะเก็บอักขระขึ้นบรรทัดใหม่ไว้ ตัวแยกวิเคราะห์จำนวนมากจึงต้องการตัดอักขระนี้ออก ส่วน Scanner (ในบทเรียนถัดไป) จะจัดการเรื่องนี้ให้โดยอัตโนมัติ
ใช้ ReadString เมื่อต้องควบคุมตัวคั่นอย่างเต็มที่
การจัดการ io.EOF
เมื่อสตรีมเบื้องหลังไม่มีข้อมูลเหลืออยู่ เมธอดการอ่านจะส่งคืน io.EOF ควรตรวจสอบค่านี้เสมอเพื่อทราบว่าเมื่อใดควรหยุด
package main
import (
"bufio"
"fmt"
"io"
"strings"
)
func main() {
r := bufio.NewReader(strings.NewReader("ab"))
for {
c, err := r.ReadByte()
if err == io.EOF {
break
}
fmt.Printf("%c", c)
}
fmt.Println()
}ReadRune สำหรับ Unicode
ReadRune จะถอดรหัสรูน UTF-8 เต็มรูปแบบ ซึ่งอาจครอบคลุมหลายไบต์ ใช้เมธอดนี้กับข้อความที่มีอักขระที่ไม่ใช่ ASCII
package main
import (
"bufio"
"fmt"
"strings"
)
func main() {
r := bufio.NewReader(strings.NewReader("héllo"))
for {
ru, _, err := r.ReadRune()
if err != nil {
break
}
fmt.Printf("%c ", ru)
}
fmt.Println()
}อ่านจนเสร็จ
รูปแบบที่ใช้กันทั่วไปคือวนลูปด้วย ReadString จนถึง EOF เพื่อประมวลผลสตรีมทีละบรรทัดพร้อมควบคุมรายละเอียดได้อย่างเต็มที่
package main
import (
"bufio"
"fmt"
"io"
"strings"
)
func main() {
r := bufio.NewReader(strings.NewReader("a\nb\nc\n"))
for {
line, err := r.ReadString('\n')
fmt.Print("got: " + line)
if err == io.EOF {
break
}
}
}ควรใช้ bufio.Reader เมื่อใด
- ห่อหุ้มแหล่งข้อมูลที่ทำงานช้า เช่น ไฟล์และซ็อกเก็ต
- ต้องอ่านข้อมูลทีละน้อยหลายครั้ง
- ต้องดูข้อมูลล่วงหน้า หรืออ่านตามตัวคั่นหรือรูน
สำหรับการอ่านทีละบรรทัดแบบง่าย ควรใช้ bufio.Scanner (ในบทเรียนถัดไป)
ตรวจสอบความเข้าใจ
ทดสอบความเข้าใจเกี่ยวกับตัวอ่านที่ใช้บัฟเฟอร์
สรุปทบทวน
คุณได้เรียนรู้ว่า bufio.Reader ลดการเรียกใช้ระบบด้วยการใช้บัฟเฟอร์
NewReader/NewReaderSizeใช้ห่อหุ้ม io.ReaderReadByte,ReadRune,ReadStringอ่านข้อมูลจากบัฟเฟอร์Peekดูข้อมูลล่วงหน้าโดยไม่นำข้อมูลออกไป- หยุดเมื่อพบ
io.EOF
คำถามที่พบบ่อย
บทเรียน “ตัวอ่านแบบมีบัฟเฟอร์” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ตัวอ่านแบบมีบัฟเฟอร์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ตัวอ่านแบบมีบัฟเฟอร์”
อ่านอย่างมีประสิทธิภาพด้วย bufio คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “ตัวอ่านแบบมีบัฟเฟอร์” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม
ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ตัวอ่านแบบมีบัฟเฟอร์
- ตัวสแกน
- ตัวเขียนแบบมีบัฟเฟอร์
- การสตรีมไฟล์ขนาดใหญ่