อินเทอร์เฟซ Reader
หัวใจของอินพุต/เอาต์พุตใน Go
อินเทอร์เฟซ Reader เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
หัวใจของการรับส่งข้อมูลใน Go
io.Reader เป็นอินเทอร์เฟซเดียวที่รวมอินพุตทุกชนิดใน Go ไว้ด้วยกัน ไม่ว่าจะเป็นไฟล์ การเชื่อมต่อเครือข่าย สตริง สตรีมที่บีบอัด และอื่น ๆ
โค้ดที่รับ io.Reader จะทำงานกับแหล่งข้อมูล ใด ๆ ได้
คำจำกัดความของอินเทอร์เฟซ
สัญญามีขนาดเล็กมาก:
Read(p []byte) (n int, err error)
เมธอดนี้จะเติมข้อมูลลงใน p ได้สูงสุด len(p) ไบต์ แล้วส่งคืนจำนวนไบต์ที่อ่านได้ (n) และข้อผิดพลาด
การอ่านจากสตริง
strings.NewReader จะแปลงสตริงให้เป็น io.Reader
package main
import (
"fmt"
"strings"
)
func main() {
r := strings.NewReader("Hello")
buf := make([]byte, 5)
n, _ := r.Read(buf)
fmt.Printf("read %d bytes: %s\n", n, buf[:n])
}กฎ n ก่อนข้อผิดพลาด
Read อาจส่งคืนไบต์จำนวน n > 0 และข้อผิดพลาดในการเรียกครั้งเดียวกันได้ ควรประมวลผลไบต์จำนวน n ก่อน แล้วจึงตรวจสอบข้อผิดพลาด
การอ่านในลูป
ตัวอ่านส่วนใหญ่ต้องใช้ลูป เพราะการเรียก Read เพียงครั้งเดียวอาจส่งคืนไบต์น้อยกว่าจำนวนที่ขอ
package main
import (
"fmt"
"io"
"strings"
)
func main() {
r := strings.NewReader("abcdef")
buf := make([]byte, 2)
for {
n, err := r.Read(buf)
if n > 0 {
fmt.Printf("%s ", buf[:n])
}
if err == io.EOF {
break
}
}
fmt.Println()
}io.ReadAll
เมื่อข้อมูลมีขนาดเล็กและมีขอบเขตแน่นอน io.ReadAll จะอ่านข้อมูลทั้งหมดลงในสไลซ์ไบต์ให้คุณ
package main
import (
"fmt"
"io"
"strings"
)
func main() {
r := strings.NewReader("read it all")
data, _ := io.ReadAll(r)
fmt.Println(string(data))
}ตัวอ่านจาก Bytes
bytes.NewReader จะห่อหุ้มสไลซ์ไบต์ เหมาะสำหรับกรณีที่มีข้อมูลอยู่ในหน่วยความจำแล้ว
package main
import (
"bytes"
"fmt"
"io"
)
func main() {
r := bytes.NewReader([]byte{72, 105})
data, _ := io.ReadAll(r)
fmt.Println(string(data))
}ฟังก์ชันที่รับตัวอ่าน
เขียนฟังก์ชันให้รับ io.Reader แทนชนิดข้อมูลที่เจาะจง จากนั้นฟังก์ชันเดียวกันจะอ่านข้อมูลจากไฟล์ ซ็อกเก็ต หรือสตริงสำหรับทดสอบได้
package main
import (
"fmt"
"io"
"strings"
)
func countBytes(r io.Reader) int {
data, _ := io.ReadAll(r)
return len(data)
}
func main() {
fmt.Println(countBytes(strings.NewReader("hello")))
}io.EOF ไม่ใช่ข้อผิดพลาด
ให้ถือว่า io.EOF เป็นสัญญาณปกติที่บอกว่าสตรีมสิ้นสุดลง ไม่ใช่ความล้มเหลว เฉพาะข้อผิดพลาดอื่นเท่านั้นที่บ่งชี้ถึงปัญหาจริง
LimitReader
io.LimitReader(r, n) จะห่อหุ้มตัวอ่านเพื่อให้หยุดหลังอ่านไปแล้ว n ไบต์ เหมาะสำหรับจำกัดปริมาณข้อมูลที่อ่าน
package main
import (
"fmt"
"io"
"strings"
)
func main() {
r := io.LimitReader(strings.NewReader("abcdefgh"), 3)
data, _ := io.ReadAll(r)
fmt.Println(string(data))
}เหตุใดอินเทอร์เฟซเดียวจึงมีประโยชน์
- แยกโค้ดออกจากแหล่งข้อมูล
- ทดสอบได้ง่ายด้วยสตริงหรือไบต์
- นำไปประกอบกับตัวห่อหุ้มอย่าง LimitReader, gzip และอื่น ๆ ได้
ตรวจสอบความเข้าใจ
ทดสอบความรู้เกี่ยวกับ io.Reader
สรุปทบทวน
คุณได้เรียนรู้อินเทอร์เฟซหลักสำหรับอินพุต
Read(p []byte) (int, error)คือสัญญาทั้งหมด- วนลูปจนถึง
io.EOFและประมวลผลไบต์จำนวน n ก่อน io.ReadAll,strings/bytes.NewReader,LimitReader- รับ
io.Readerในส่วนติดต่อของโปรแกรม
คำถามที่พบบ่อย
บทเรียน “อินเทอร์เฟซ Reader” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “อินเทอร์เฟซ Reader” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “อินเทอร์เฟซ Reader”
หัวใจของอินพุต/เอาต์พุตใน Go คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “อินเทอร์เฟซ Reader” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม
ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- อินเทอร์เฟซ Reader
- อินเทอร์เฟซ Writer
- ฟังก์ชันอรรถประโยชน์ io
- การใช้งานตัวอ่านแบบกำหนดเอง