ในระบบ Production การทำงานกับข้อมูลขนาดใหญ่ เช่น

• การอ่านไฟล์ log
• การดาวน์โหลดข้อมูลผ่านเครือข่าย
• หรือการส่ง response กลับจาก API

สิ่งสำคัญคือ ประสิทธิภาพ, การใช้หน่วยความจำอย่างคุ้มค่า, และ ความเสถียรของระบบ

ทั้ง JavaScript (Node.js) และ Go (Golang) ต่างมีแนวทางในการจัดการข้อมูลเหล่านี้อย่างชาญฉลาด ผ่านแนวคิดสำคัญสองอย่างคือ Buffer และ Stream

ในบทความนี้ เราจะมาเรียนรู้วิธีการใช้งาน Buffer และ Stream ทั้งใน Node.js และ Go พร้อมตัวอย่างโค้ดจริง และแนวทางเลือกใช้อย่างเหมาะสมในระบบ Production 🚀

1. Buffer คืออะไร?

Buffer คือพื้นที่หน่วยความจำชั่วคราวที่ใช้เก็บข้อมูล “ก่อน” หรือ “ระหว่าง” การอ่าน–เขียนข้อมูล มันช่วยให้เราสามารถจัดการข้อมูลขนาดใหญ่ได้โดยไม่ต้องโหลดทั้งหมดเข้ามาพร้อมกัน (เช่น ไฟล์ขนาด 1GB)

🔹 Buffer ใน Node.js

ใน Node.js มี class ชื่อ Buffer สำหรับจัดการข้อมูลแบบ binary โดยตรง

const fs = require('fs');

fs.readFile('example.txt', (err, data) => {
  if (err) throw err;
  console.log(data);            // แสดงข้อมูลแบบ buffer
  console.log(data.toString()); // แปลงเป็น string
});

สร้าง Buffer ด้วยตัวเอง:

const buf = Buffer.from('Hello Superdev!');
console.log(buf);            // <Buffer 48 65 6c 6c 6f ...>
console.log(buf.toString()); // Hello Superdev!

ข้อดีของ Buffer ใน Node.js
✅ จัดการข้อมูล binary ได้โดยตรง
✅ เหมาะกับงานที่ต้องอ่าน/เขียนไฟล์หรือข้อมูลผ่าน network
✅ ใช้หน่วยความจำอย่างมีประสิทธิภาพกว่าการโหลดข้อมูลทั้งหมดในครั้งเดียว

🔹 Buffer ใน Go

ใน Go จะใช้ bytes.Buffer จาก package bytes ซึ่งเป็นโครงสร้างข้อมูลสำหรับเก็บข้อมูลชั่วคราวในรูปแบบ byte stream

package main

import (
	"bytes"
	"fmt"
)

func main() {
	var buffer bytes.Buffer
	buffer.WriteString("Hello Superdev!")
	fmt.Println(buffer.String())
}

ข้อดีของ Buffer ใน Go
✅ ใช้หน่วยความจำอย่างมีประสิทธิภาพ
✅ เขียนข้อมูลต่อเนื่องได้โดยไม่ต้องสร้าง string ใหม่ทุกครั้ง
✅ เหมาะกับการประมวลผลข้อมูลแบบต่อเนื่อง เช่น log aggregation หรือ network streaming

2. Stream คืออะไร?

Stream คือการส่งข้อมูล “ทีละส่วน” (chunk) แทนการโหลดทั้งหมดพร้อมกัน แนวทางนี้ช่วยให้ระบบสามารถจัดการข้อมูลขนาดใหญ่ได้ โดยไม่ใช้หน่วยความจำมากเกินไป

🔹 Stream ใน Node.js

ใน Node.js ทุกอย่างที่เกี่ยวข้องกับ I/O เช่น File, Network, หรือ HTTP สามารถทำงานแบบ Stream ได้

const fs = require('fs');

const readable = fs.createReadStream('bigfile.txt', { encoding: 'utf8' });

readable.on('data', chunk => {
  console.log('📦 Received chunk:', chunk.length);
});

readable.on('end', () => {
  console.log('✅ Done reading file');
});

อธิบาย:

• Node.js จะอ่านไฟล์เป็นชิ้น (chunk) ละประมาณ 64KB
• ไม่จำเป็นต้องโหลดทั้งไฟล์เข้า memory
• เหมาะกับงาน log, media, หรือ API streaming

เขียนไฟล์กลับแบบ stream:

const writeStream = fs.createWriteStream('output.txt');
writeStream.write('Superdev Stream Example\n');
writeStream.end('✅ Finished writing!');

🔹 Stream ใน Go

ใน Go การทำงานแบบ Stream จะอาศัย interface หลักของภาษา คือ io.Reader และ io.Writer

package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	file, err := os.Open("bigfile.txt")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	buffer := make([]byte, 1024)
	for {
		n, err := file.Read(buffer)
		if err == io.EOF {
			break
		}
		if err != nil {
			panic(err)
		}
		fmt.Printf("📦 Read %d bytes\n", n)
	}
	fmt.Println("✅ Done reading file")
}

อธิบาย:

• ใช้ buffer ขนาด 1024 bytes เพื่ออ่านข้อมูลทีละรอบ
• ควบคุมการใช้หน่วยความจำได้เอง
• ใช้หลักเดียวกันกับ network streaming เช่น net.Conn

เขียนไฟล์แบบ stream:

output, _ := os.Create("output.txt")
defer output.Close()
output.Write([]byte("Superdev Stream Example\n"))
output.Write([]byte("✅ Finished writing!"))

3. การเปรียบเทียบ Buffer และ Stream

4. แนวทางเลือกใช้ในระบบ Production

💡 ใช้ Buffer เมื่อ:

• ข้อมูลมีขนาดเล็ก
• สามารถโหลดทั้งหมดไว้ในหน่วยความจำได้
• เช่น การจัดการ string, JSON, หรือ log ขนาดเล็ก

⚡ ใช้ Stream เมื่อ:

• ข้อมูลมีขนาดใหญ่ เช่น upload/download ไฟล์ หรือ network transfer
• ต้องการลดการใช้หน่วยความจำ
• ทำงานแบบ real-time เช่น video streaming หรือ API responses

Node.js:
เหมาะกับระบบ API, File Streaming, หรือ Real-time Application

Go:
เหมาะกับระบบ backend ที่ต้องการ throughput สูงและ latency ต่ำ เช่น Data Pipeline หรือ Log Processor

5. ตัวอย่างการเลือกใช้ในระบบจริง

สรุป

การเข้าใจ Buffer และ Stream คือพื้นฐานสำคัญของการพัฒนาโปรแกรมที่ต้องจัดการข้อมูลขนาดใหญ่ เพราะช่วยให้ระบบของคุณ ทำงานเร็วขึ้น, ใช้ memory น้อยลง, และ รองรับโหลดได้มากขึ้น

✅ ใช้ Stream สำหรับงาน I/O จำนวนมาก
✅ ใช้ Buffer สำหรับข้อมูลขนาดเล็กหรือการประมวลผลชั่วคราว
💻 Node.js: ยืดหยุ่น ใช้งานง่าย เหมาะกับ real-time application
⚙️ Go: ประสิทธิภาพสูง รองรับ I/O concurrency ได้ดีกว่าในระบบระดับ enterprise

ตอนต่อไป

ใน EP.39 ของซีรีส์ JS2GO
เราจะพาคุณไปเรียนรู้เรื่อง Channels และ Pipelines ใน Go สำหรับ Data Processing เพื่อเข้าใจแนวคิดการประมวลผลข้อมูลแบบ asynchronous และ parallel รวมถึงเทคนิคออกแบบ pipeline ที่สามารถทำงานหลายขั้นตอนพร้อมกันได้อย่างมีประสิทธิภาพ ⚡