Go Academy · บทเรียน

การสตรีมไฟล์ขนาดใหญ่

ประมวลผลไฟล์โดยไม่โหลดทั้งหมด

การสตรีมไฟล์ขนาดใหญ่ เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

ปัญหาของการโหลดทั้งหมด

การอ่านไฟล์ขนาดหลายกิกะไบต์ลงในหน่วยความจำด้วย os.ReadFile อาจใช้ RAM จนหมดได้ ทางเลือกคือให้สตรีมข้อมูล โดยประมวลผลแต่ละกลุ่มเมื่อข้อมูลมาถึง

แนวคิดการสตรีม

การสตรีมหมายถึงการเก็บข้อมูลไว้ในหน่วยความจำเพียงช่วงเล็ก ๆ ในแต่ละครั้ง เมื่อใช้ร่วมกับบัฟเฟอร์ คุณจะประมวลผลอินพุตที่มีขนาดใหญ่เท่าใดก็ได้โดยใช้หน่วยความจำคงที่

อ่านทีละบรรทัดด้วย Scanner

สำหรับข้อความ bufio.Scanner ที่ทำงานกับตัวอ่านจะประมวลผลทีละบรรทัด ไม่ว่าไฟล์จะมีขนาดเท่าใด ในที่นี้เราใช้ strings.Reader จำลองไฟล์

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	src := strings.NewReader("alpha\nbeta\ngamma")
	s := bufio.NewScanner(src)
	for s.Scan() {
		fmt.Println("processed:", s.Text())
	}
}

การนับโดยไม่โหลดทั้งหมด

คุณสามารถคำนวณสถิติจากสตรีมขนาดใหญ่ได้ โดยเก็บข้อมูลไว้ในหน่วยความจำเพียงเล็กน้อย

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	s := bufio.NewScanner(strings.NewReader("a\nbb\nccc"))
	total := 0
	for s.Scan() {
		total += len(s.Text())
	}
	fmt.Println("total chars:", total)
}

กลุ่มข้อมูลขนาดคงที่

สำหรับข้อมูลไบนารี ให้อ่านลงในบัฟเฟอร์ขนาดคงที่ด้วย Read ค่า n จะบอกว่ามีไบต์ถูกเติมลงไปกี่ไบต์

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	src := strings.NewReader("0123456789")
	buf := make([]byte, 4)
	for {
		n, err := src.Read(buf)
		if n > 0 {
			fmt.Printf("chunk: %s\n", buf[:n])
		}
		if err == io.EOF {
			break
		}
	}
}

io.Copy สำหรับการสตรีม

io.Copy(dst, src) จะสตรีมข้อมูลทั้งหมดจากตัวอ่านไปยังตัวเขียนโดยใช้บัฟเฟอร์ภายในขนาดเล็ก จึงไม่ต้องโหลดข้อมูลทั้งหมด

package main

import (
	"io"
	"os"
	"strings"
)

func main() {
	src := strings.NewReader("streamed straight through\n")
	io.Copy(os.Stdout, src)
}

การรวมบัฟเฟอร์ของตัวอ่านและตัวเขียน

ห่อหุ้มทั้งสองด้านด้วย bufio เพื่อการแปลงข้อมูลแบบสตรีมที่มีประสิทธิภาพ ได้แก่ อ่านโดยใช้บัฟเฟอร์ ประมวลผล เขียนโดยใช้บัฟเฟอร์ และส่งข้อมูลออก

package main

import (
	"bufio"
	"os"
	"strings"
)

func main() {
	r := bufio.NewScanner(strings.NewReader("one\ntwo"))
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for r.Scan() {
		w.WriteString(r.Text() + "!\n")
	}
}

การรับประกันหน่วยความจำคงที่

เนื่องจากขนาดบัฟเฟอร์คงที่ การใช้หน่วยความจำจึงไม่เปลี่ยนแปลง ไม่ว่าอินพุตจะมีขนาด 1KB หรือ 1TB นี่คือข้อได้เปรียบสำคัญของการสตรีม

หลีกเลี่ยงข้อผิดพลาดที่พบบ่อย

อย่าเรียกใช้ os.ReadFile กับไฟล์ขนาดใหญ่
จัดการไบต์จำนวน n ให้เสร็จก่อนตรวจสอบข้อผิดพลาดเสมอ
อย่าลืมเรียกใช้ Flush() กับตัวเขียนที่ใช้บัฟเฟอร์

การแปลงสตรีม

ในที่นี้เราจะเปลี่ยนแต่ละบรรทัดให้เป็นตัวพิมพ์ใหญ่ขณะสตรีมข้อมูลผ่าน โดยเก็บไว้ในหน่วยความจำครั้งละเพียงหนึ่งบรรทัด

package main

import (
	"bufio"
	"os"
	"strings"
)

func main() {
	s := bufio.NewScanner(strings.NewReader("hi\nthere"))
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for s.Scan() {
		w.WriteString(strings.ToUpper(s.Text()) + "\n")
	}
}

ควรใช้การสตรีมเมื่อใด

ใช้การสตรีมเมื่อขนาดอินพุตใหญ่หรือไม่ทราบขนาด หรือเมื่อสามารถประมวลผลข้อมูลทีละส่วนได้ ควรโหลดข้อมูลทั้งหมดเฉพาะเมื่อเป็นข้อมูลขนาดเล็กที่มีขอบเขตแน่นอนและจำเป็นต้องใช้พร้อมกันทั้งหมด

ตรวจสอบความเข้าใจ

ทดสอบความรู้เกี่ยวกับการสตรีม

สรุปทบทวน

คุณได้เรียนรู้การประมวลผลข้อมูลขนาดใหญ่โดยไม่ต้องโหลดข้อมูลทั้งหมด

ใช้ Scanner สำหรับข้อความทีละบรรทัด
ใช้ Read กับบัฟเฟอร์ขนาดคงที่สำหรับกลุ่มข้อมูลไบนารี
ใช้ io.Copy สำหรับการส่งข้อมูลจากสตรีมหนึ่งไปยังอีกสตรีมหนึ่ง
ใช้บัฟเฟอร์ทั้งสองด้าน ส่งข้อมูลจากตัวเขียนออก และใช้หน่วยความจำคงที่

คำถามที่พบบ่อย

บทเรียน “การสตรีมไฟล์ขนาดใหญ่” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การสตรีมไฟล์ขนาดใหญ่” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การสตรีมไฟล์ขนาดใหญ่”

ประมวลผลไฟล์โดยไม่โหลดทั้งหมด คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การสตรีมไฟล์ขนาดใหญ่” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม

ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Go Academy