สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ ในบทความนี้เราจะมาเรียนรู้ภาษา Rust กันต่อนะครับ

ตั้งแต่ตรงนี้ไปจะเป็นเนื้อหาที่ AI ทำมาให้นะครับ

🔹 Control Flow คืออะไร?

Control flow คือโครงสร้างที่ใช้ควบคุมลำดับการทำงานของโปรแกรม เช่น

• การตัดสินใจ (if / else)
• การทำซ้ำ (loop / while / for)

Rust มี control flow ที่ชัดเจนและปลอดภัย โดยบังคับให้เงื่อนไขต้องเป็น boolean (bool) เท่านั้น

🔹 การใช้ if

fn main() {
    let number = 7;

    if number < 5 {
        println!("น้อยกว่า 5");
    } else {
        println!("มากกว่าหรือเท่ากับ 5");
    }
}

• Rust ไม่อนุญาตให้ใช้ค่าที่ไม่ใช่ bool เป็นเงื่อนไข (เช่น 0 หรือ 1 แบบ C จะ error)

🔹 การใช้ else if

fn main() {
    let score = 85;

    if score >= 90 {
        println!("เกรด A");
    } else if score >= 80 {
        println!("เกรด B");
    } else if score >= 70 {
        println!("เกรด C");
    } else {
        println!("เกรด F");
    }
}

🔹 ใช้ if เป็น Expression

if สามารถคืนค่าได้ (เพราะเป็น expression)

fn main() {
    let condition = true;
    let number = if condition { 10 } else { 20 };

    println!("number = {}", number);
}

🔹 Loop แบบไม่มีที่สิ้นสุด (loop)

fn main() {
    let mut count = 0;

    loop {
        count += 1;
        println!("รอบที่ {}", count);

        if count == 5 {
            break; // หยุด loop
        }
    }
}

🔹 Loop พร้อม return ค่า

fn main() {
    let mut count = 0;

    let result = loop {
        count += 1;

        if count == 10 {
            break count * 2; // คืนค่าออกจาก loop
        }
    };

    println!("Result = {}", result);
}

🔹 การใช้ while

fn main() {
    let mut number = 3;

    while number > 0 {
        println!("{}!", number);
        number -= 1;
    }

    println!("ปล่อยจรวด!");
}

🔹 การใช้ for กับ Range

fn main() {
    for i in 1..5 { // 1 ถึง 4
        println!("i = {}", i);
    }

    for j in 1..=5 { // 1 ถึง 5
        println!("j = {}", j);
    }
}

🔹 การใช้ for กับ Collections

fn main() {
    let arr = [10, 20, 30, 40];

    for value in arr.iter() {
        println!("ค่า = {}", value);
    }
}

สรุปตอนที่ 2

• if / else ใช้สำหรับการตัดสินใจ
• if เป็น expression คืนค่าได้
• loop → loop ไม่รู้จบ, สามารถ break พร้อมค่าได้
• while → ทำงานจนกว่าเงื่อนไขจะเป็นเท็จ
• for → ใช้กับ range และ collection ได้อย่างปลอดภัย

ถึงตรงนี้ ถ้าใครติดปัญหาอะไรตรงไหน ก็สามารถ comment ไว้ใน Fanpage หรือ ทัก chat มาแชร์ปัญหากับผมได้ที่ Fanpage : Mos Programmer นะครับ หรือถ้าใครมีคำแนะนำดีๆ เกี่ยวกับภาษา Rust ก็สามารถ ทักมาบอกผมได้นะครับ

สุดท้ายนี้อยากจะฝากเพื่อนๆ พี่ๆ น้องๆ ช่วยแชร์ บทความนี้ไปให้เพื่อนๆ หรือคนรู้จักด้วยนะครับ แล้วก็อย่าลืม กดไลค์ กดติดตาม Fanpage : Mos Programmer จะได้ไม่พลาดเนื้อหาดีๆ กันนะครับ

สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ ในบทความนี้เราจะมาเจาะลึกพื้นฐานที่จำเป็น เช่น ตัวแปร ชนิดข้อมูล การพิมพ์ค่า และ Scope ซึ่งเป็นรากฐานของภาษา Rust กันครับ

ตั้งแต่ตรงนี้ไปจะเป็นเนื้อหาที่ AI ทำมาให้นะครับ

🔹 ตัวแปร (Variables)

ใน Rust ใช้คีย์เวิร์ด let เพื่อประกาศตัวแปร

fn main() {
    let x = 5;
    println!("x = {}", x);
}

📌 จุดสำคัญ:

• ตัวแปรใน Rust immutable (แก้ไขไม่ได้) ตามค่าเริ่มต้น
• ถ้าต้องการเปลี่ยนค่า ต้องใช้ mut

fn main() {
    let mut y = 10;
    println!("y ก่อนเปลี่ยน = {}", y);
    y = 20;
    println!("y หลังเปลี่ยน = {}", y);
}

🔹 Shadowing

Rust มีคุณสมบัติ Shadowing คือเราสามารถประกาศตัวแปรใหม่ที่ชื่อซ้ำกับตัวเก่าได้

fn main() {
    let x = 5;
    let x = x + 1;  // ตัวแปรใหม่ชื่อ x แต่ค่าต่างกัน
    let x = x * 2;
    println!("x = {}", x); // ได้ค่า 12
}

ข้อดีคือทำให้โค้ดอ่านง่ายขึ้น และสามารถเปลี่ยน type ของตัวแปรได้โดยไม่ต้องใช้ mut

🔹 ชนิดข้อมูล (Data Types)

Rust เป็นภาษา statically typed (ต้องรู้ชนิดข้อมูลก่อนคอมไพล์) แต่ส่วนใหญ่ Rust จะ infer (เดา) ชนิดข้อมูลให้เรา

ชนิดข้อมูลหลัก

1. จำนวนเต็ม (Integer)

• i8, i16, i32, i64, i128, isize (signed)
• u8, u16, u32, u64, u128, usize (unsigned)

let a: i32 = -10;
let b: u32 = 100;

2. ทศนิยม (Floating Point)

• f32, f64

let pi: f64 = 3.14159;

3. Boolean

let is_active: bool = true;

4. Character

let c: char = 'A';
let emoji: char = '😎';

🔹 การพิมพ์ค่า (Printing)

Rust ใช้ println! macro

fn main() {
    let name = "Rust";
    let age = 8;
    println!("Hello, {}! You are {} years old.", name, age);
}

ผลลัพธ์:

Hello, Rust! You are 8 years old.

🔹 Scope และ Shadowing

Rust ใช้ {} กำหนด scope ของตัวแปร

fn main() {
    let x = 10;

    {
        let x = 20; // ตัวแปร x ตัวใหม่
        println!("x ใน scope ย่อย = {}", x);
    }

    println!("x ใน scope หลัก = {}", x);
}

ผลลัพธ์:

x ใน scope ย่อย = 20
x ใน scope หลัก = 10

🔹 คอมเมนต์ (Comments)

• คอมเมนต์บรรทัดเดียว → //
• คอมเมนต์หลายบรรทัด → /* ... */
• Doc comments → /// (ใช้กับการเขียน documentation)

fn main() {
    // นี่คือคอมเมนต์บรรทัดเดียว
    let x = 5; /* คอมเมนต์ในบรรทัด */
    println!("x = {}", x);
}

🎯 สรุปตอนที่ 1

• let = ตัวแปร immutable, ใช้ mut ถ้าต้องการแก้ไข
• Rust รองรับ Shadowing
• มีชนิดข้อมูลหลัก: integer, float, bool, char
• ใช้ println! สำหรับพิมพ์ค่า
• Scope กำหนดขอบเขตตัวแปร
• คอมเมนต์ใช้ //

ถึงตรงนี้ ถ้าใครติดปัญหาอะไรตรงไหน ก็สามารถ comment ไว้ใน Fanpage หรือ ทัก chat มาแชร์ปัญหากับผมได้ที่ Fanpage : Mos Programmer นะครับ หรือถ้าใครมีคำแนะนำดีๆ เกี่ยวกับภาษา Rust ก็สามารถ ทักมาบอกผมได้นะครับ

สุดท้ายนี้อยากจะฝากเพื่อนๆ พี่ๆ น้องๆ ช่วยแชร์ บทความนี้ไปให้เพื่อนๆ หรือคนรู้จักด้วยนะครับ แล้วก็อย่าลืม กดไลค์ กดติดตาม Fanpage : Mos Programmer จะได้ไม่พลาดเนื้อหาดีๆ กันนะครับ

สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ เหตุผลที่ตัวผมเองทำบทความชุดนี้ขึ้นมา เพราะว่าผมมี Project อยู่ตัวนึง หลังจาก ลองศึกษาค้นคว้า หาข้อมูล และวางแผนทำ Project นี้ ก็พบว่า ต้องใช้ภาษา Rust ในการพัฒนา (แต่จริงๆก็ใช้ได้อีกหลายๆภาษา แต่จะเป็นภาษาเก่าๆ กับภาษายากๆ อย่าง C++) ดังนั้นตัวผมเองที่ไม่เคยเขียน Rust มาก่อนในชีวิต ก็เลยต้องมานับ 0 กันใหม่กับภาษานี้ แต่ไหนๆก็ต้องศึกษาละ ก็เลยเอามาทำเป็นบทความด้วย เผื่อว่าใครกำลังศึกษาภาษานี้อยู่ จะได้เหมือนกับว่า เรียนไปพร้อมกับผมเลย

ในตอนที่ 0 นี้เราจะมาเริ่มติดตั้ง เครื่องมือในการพัฒนากันเลย

ตั้งแต่ตรงนี้ไปจะเป็นเนื้อหาที่ AI ทำมาให้นะครับ

🦀 Rust คืออะไร?

Rust เป็นภาษาโปรแกรมระบบ (system programming language) ที่ออกแบบมาเพื่อให้ เร็ว, ปลอดภัย และสามารถทำงานแบบขนาน (concurrent) ได้อย่างมั่นใจ จุดเด่นคือ ไม่มี Garbage Collector แต่ยังสามารถป้องกัน bug ประเภท memory error ได้ เช่น null pointer, dangling pointer หรือ data race

Rust ถูกใช้จริงในหลายโครงการ เช่น

Firefox → ส่วนของ rendering engine

Dropbox → ระบบเก็บไฟล์ประสิทธิภาพสูง

Cloudflare → ระบบเครือข่ายระดับโลก

Linux Kernel → เริ่มใช้ Rust เขียน driver บางส่วนแล้ว

พูดง่ายๆ Rust คือ ภาษา C/C++ เวอร์ชันปลอดภัย แต่ยังคงความเร็วไว้ครบถ้วน

🛠️ การติดตั้ง Rust

Rust มีตัวจัดการเวอร์ชันชื่อว่า rustup ที่ใช้ติดตั้งและอัปเดตได้สะดวก

1. ติดตั้ง Rust (Linux / macOS)

เปิด terminal แล้วรันคำสั่ง:

curl - proto '=https' - tlsv1.2 -sSf https://sh.rustup.rs | sh

จากนั้นกด Enter และทำตามขั้นตอน

2. ติดตั้ง Rust (Windows)

• ดาวน์โหลดจาก https://rustup.rs
• ติดตั้งตาม wizard
• เสร็จแล้วเปิด PowerShell / CMD เพื่อลองใช้งาน

📦 เครื่องมือสำคัญ

เมื่อติดตั้งเสร็จแล้ว เราจะได้เครื่องมือหลักๆ 2 ตัวคือ

1. rustc → Rust compiler ใช้คอมไพล์ไฟล์ .rs ให้กลายเป็น binary

rustc main.rs
./main

2. cargo → ตัวจัดการโปรเจกต์ & dependency (เหมือน npm ของ Node.js หรือ pip ของ Python) ใช้สร้างโปรเจกต์, build, run, test ได้ครบในตัวเดียว

cargo new hello_rust
cd hello_rust
cargo run

📝 สร้างโปรเจกต์แรก “Hello, Rust!”

เปิด terminal แล้วพิมพ์

cargo new hello_rust
cd hello_rust

จะได้โครงสร้างโปรเจกต์ดังนี้:

hello_rust/
├── Cargo.toml # ไฟล์ config และ dependency
└── src/
└── main.rs # ไฟล์โค้ดหลัก

เปิดไฟล์ src/main.rs จะเจอโค้ดเริ่มต้น:

fn main() {
  println!("Hello, world!");
}

รันโปรแกรมด้วยคำสั่ง:

cargo run

ผลลัพธ์ที่ได้:

Hello, world!

🎯 สรุปตอนที่ 0

• Rust เป็นภาษาที่เน้น ความเร็ว + ความปลอดภัย
• ใช้ rustup เพื่อติดตั้ง Rust
• รู้จักเครื่องมือ rustc และ cargo
• สามารถเขียนโปรแกรมแรก “Hello, Rust!” ได้แล้ว

ถึงตรงนี้ ถ้าใครติดปัญหาอะไรตรงไหน ก็สามารถ comment ไว้ใน Fanpage หรือ ทัก chat มาแชร์ปัญหากับผมได้ที่ Fanpage : Mos Programmer นะครับ หรือถ้าใครมีคำแนะนำดีๆ เกี่ยวกับภาษา Rust ก็สามารถ ทักมาบอกผมได้นะครับ

สุดท้ายนี้อยากจะฝากเพื่อนๆ พี่ๆ น้องๆ ช่วยแชร์ บทความนี้ไปให้เพื่อนๆ หรือคนรู้จักด้วยนะครับ แล้วก็อย่าลืม กดไลค์ กดติดตาม Fanpage : Mos Programmer จะได้ไม่พลาดเนื้อหาดีๆ กันนะครับ

สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ ในบทความนี้เราจะมาเรียนรู้วิธีการเขียนโปรแกรมที่พร้อมรับมือกับสถานการณ์เหล่านี้อย่างสง่างาม ด้วยปรัชญา การจัดการข้อผิดพลาด (Error Handling) ในสไตล์ของ Go และพบกับคีย์เวิร์ดสุดสะดวกอย่าง defer ที่จะช่วยให้เราไม่ลืมจัดการทรัพยากรที่สำคัญครับ

Error Handling ใน Go เมื่อ “Error คือค่าๆ หนึ่ง”

สิ่งแรกที่ต้องเข้าใจคือ Go มอง Error แตกต่างจากภาษาอื่นโดยสิ้นเชิง ภาษาอื่น (เช่น Java, C#, Python) มักจะใช้ระบบ Exception Handling (try-catch) ซึ่งมองว่า Error คือ "เหตุการณ์พิเศษ" ที่จะหยุดการทำงานปกติและ "โยน" (Throw) ออกไปให้โค้ดส่วนอื่นรับไปจัดการ

ภาษา Go มองว่า Error คือ “ค่า” (Value) ธรรมดาๆ ค่าหนึ่ง เหมือนกับตัวเลขหรือข้อความ มันไม่ใช่เหตุการณ์พิเศษ แต่เป็นหนึ่งในผลลัพธ์ที่ คาดว่าจะเกิดขึ้นได้ ในการทำงานปกติ

เปรียบเทียบกับการทำอาหาร

try-catch: เหมือนการทำอาหารโดยคิดว่าวัตถุดิบทุกอย่างจะดีเลิศ ถ้าบังเอิญเจอไข่เน่า (Exception) กระบวนการทั้งหมดจะหยุดชะงักทันที แล้วคุณต้องไปจัดการกับความวุ่นวายในบล็อก catch แทน

Go: เหมือนเชฟมืออาชีพที่รู้ว่าไข่บางฟองอาจจะเน่าได้ ขั้นตอนการเช็คไข่จึงถูกรวมอยู่ในสูตรอาหารปกติ: “ตอกไข่ใส่ถ้วยเล็กๆ ก่อน -> เช็คว่าไข่เน่าหรือไม่ (if err != nil) -> ถ้าเน่าให้ทิ้งไป ถ้าดีค่อยเทใส่ชามผสม"

การตรวจสอบ Error ใน Go จึงเป็นส่วนหนึ่งของ Flow การทำงานปกติ ไม่ใช่ข้อยกเว้นครับ

Workflow การจัดการ Error ที่ถูกต้อง

เมื่อเข้าใจปรัชญาแล้ว เรามาดูขั้นตอนการทำงานกับ Error ที่โปรแกรมเมอร์ Go ใช้กันเป็นมาตรฐาน

Step 1: เรียกฟังก์ชันและรับค่า error
ฟังก์ชันที่อาจทำงานพลาดได้จะคืนค่า error เป็นค่าสุดท้ายเสมอ

file, err := os.Open("my_file.txt")

Step 2: ตรวจสอบทันที! (The Golden Rule)
นี่คือกฎทองคำ: หลังจากเรียกฟังก์ชันที่คืนค่า error ให้ตรวจสอบค่า err ทันที

file, err := os.Open("my_file.txt")
if err != nil {
    // ถ้า err ไม่ใช่ nil แสดงว่ามีข้อผิดพลาดเกิดขึ้น!
    // เราต้องจัดการมันตรงนี้
}

Step 3: จัดการ Error อย่าแค่ Print หรือสั่ง Panic!
มือใหม่มักจะจัดการ Error ด้วยการ fmt.Println(err) หรือ panic(err) ซึ่งส่วนใหญ่แล้วเป็นวิธีที่ไม่ค่อยดีเท่าไหร่ครับ

• ทำไม Println ถึงไม่ดี? เพราะมันแค่พิมพ์ข้อความออกหน้าจอ แต่ไม่ได้หยุดการทำงานส่วนที่เหลือซึ่งอาจต้องอาศัยผลลัพธ์จากส่วนที่พลาดไป ทำให้โปรแกรมอาจทำงานผิดพลาดต่อไป
• ทำไม panic ถึงไม่ดี? เพราะมันทำให้ทั้งโปรแกรม "ล่ม" และหยุดทำงานทันที ควรใช้ panic ในกรณีที่โปรแกรมไม่สามารถทำงานต่อได้จริงๆ เท่านั้น (เช่น ไม่สามารถเชื่อมต่อฐานข้อมูลหลักได้ตั้งแต่เริ่ม)

Step 4: (ข้อนี้สำคัญที่สุด) เพิ่มบริบทและ Return
วิธีจัดการ Error ที่ดีที่สุดในฟังก์ชันส่วนใหญ่คือ การส่งต่อ error กลับไปยังฟังก์ชันที่เรียกเรามา พร้อมกับเพิ่ม “บริบท” ว่า error นี้เกิดขึ้นตอนที่เรากำลังพยายามทำอะไร

เราใช้ fmt.Errorf และ %w (verb สำหรับ wrap error) ในการเพิ่มบริบท

ตัวอย่าง: สมมติเรามีฟังก์ชัน readConfig ที่ต้องเปิดไฟล์ config.json

func readConfig() error {
    file, err := os.Open("config.json")
    if err != nil {
        // ถ้าเราแค่ส่งต่อ error เดิมๆ คนเรียกจะไม่รู้ว่าเกิดจากอะไร
        // return err 

        // ควรเพิ่มบริบทว่าเกิดอะไรขึ้น แล้ว wrap error เดิมไปด้วย
        return fmt.Errorf("ไม่สามารถอ่านไฟล์ config ได้: %w", err)
    }
    defer file.Close()
    
    // ... ทำงานกับไฟล์ต่อไป ...
    return nil // คืนค่า nil ถ้าไม่มี error
}

func main() {
    err := readConfig()
    if err != nil {
        // error ที่ได้รับที่ main จะมีข้อความเต็มๆ ว่า
        // "ไม่สามารถอ่านไฟล์ config ได้: open config.json: no such file or directory"
        // แค่นี้เราก็จะสามารถ Debug ได้ง่ายขึ้นมากแล้ว
        log.Fatal(err) 
    }
}

การเพิ่มบริบทแบบนี้ ทำให้เมื่อเกิดปัญหาที่ main เราจะเห็นร่องรอยของปัญหาทั้งหมด ไม่ใช่แค่ error สุดท้ายที่ปลายเหตุ ทำให้การแก้ไขปัญหาง่ายขึ้นมหาศาล

defer คืออะไร? - ไม่ใช่ "ทำทันที" แต่คือ "เดี๋ยวจะทำแน่ๆ

defer คือคำสั่งที่ใช้ "แปะ" ฟังก์ชันไว้ก่อน โดยบอกกับ Go ว่า :

“ฟังก์ชันที่ฉันแปะ defer ไว้นี้ ยังไม่ต้องทำตอนนี้ นะ แต่ฉันขอสั่งจองไว้ก่อนว่า นายต้องทำให้ฉันแน่ๆ ในวินาทีสุดท้ายก่อนที่ฟังก์ชันหลักที่ครอบอยู่จะจบการทำงาน"

เปรียบเทียบให้เห็นภาพที่สุด: ให้นึกถึงการไปร้านอาหาร

• คุณเดินเข้าร้านอาหารแล้วสั่งอาหาร (เปรียบเหมือนการเปิดไฟล์ หรือเชื่อมต่อฐานข้อมูล)
• เรารู้ตัวว่ากินเสร็จยังไงก็ต้อง “จ่ายเงิน” แน่นอน แต่ยังไม่ใช่ตอนนี้ เราก็เลยบอกพนักงานเสิร์ฟไว้ล่วงหน้าเลยว่า “เดี๋ยวตอนผมจะกลับ ช่วยเอาบิลมาเก็บเงินด้วยนะ” (นี่คือการ defer ครับ)
• จากนั้นคุณก็นั่งกินอาหารไปตามปกติ…
• เมื่อคุณกินเสร็จและกำลังจะลุกออกจากร้าน (เปรียบเสมือนเรากำลังจะ return จากฟังก์ชัน) พนักงานเสิร์ฟก็จะเดินเอาบิลมาให้เราทันทีตามที่ได้สั่งพนักงานเสิร์ฟไว้

defer ก็คือการ "สั่งงานที่จะทำตอนจบ" นั่นเองครับ

ทำไม defer ถึงเป็นพระเอก? (แก้ปัญหาอะไร)

defer คือพระเอกในการ "คืนทรัพยากร" (Resource Cleanup) เช่น การปิดไฟล์, การปิดการเชื่อมต่อเน็ตเวิร์ก/ฐานข้อมูล

ยกตัวอย่างสถานการณ์ที่ “ไม่มี” defer:

func processFile() error {
    file, err := os.Open("data.txt")
    if err != nil {
        return err // << จุดที่ 1 ที่อาจออกจากฟังก์ชัน
    }

    // ... ทำงานกับไฟล์ 50 บรรทัด ...

    if someCondition {
        file.Close() // << ต้องไม่ลืมปิดไฟล์ตรงนี้
        return someError
    }

    // ... ทำงานกับไฟล์อีก 50 บรรทัด ...

    file.Close() // << และต้องไม่ลืมปิดไฟล์ตรงนี้ด้วย
    return nil
}

ปัญหา:

• โค้ดดูรก เพราะต้องมี file.Close() หลายที่
• เสี่ยงมากที่จะลืม! ถ้าเราเพิ่มเงื่อนไข if แล้ว return ไปอีกจุด แต่ลืมใส่ file.Close() ก็จะเกิดปัญหา "Resource Leak" ทันที

ทีนี้ลองมาดูสถานการณ์ที่ “มี” defer:

func processFile() error {
    file, err := os.Open("data.txt")
    if err != nil {
        return err
    }
    // บอก Go ทันทีหลังเปิดไฟล์สำเร็จว่า "เดี๋ยวตอนจบ ช่วยปิดไฟล์ให้ด้วยนะ"
    defer file.Close()

    // ... ทำงานกับไฟล์ 100 บรรทัดได้อย่างสบายใจ ...
    
    if someCondition {
        return someError // ไม่ต้องห่วง defer จะทำงานให้เอง
    }

    // ... ไม่ว่าฟังก์ชันจะจบตรงไหน หรือมีกี่ return ...
    // ... file.Close() จะถูกเรียกทำงานให้เองเสมอ 100%
    return nil
}

ข้อดี:

• โค้ดสะอาด: Close อยู่ที่เดียว ติดกับ Open อ่านง่ายมาก
• ปลอดภัย: ไม่มีทางลืมปิดไฟล์แน่นอน
• บำรุงรักษาง่าย: จะเพิ่ม return อีกกี่จุดก็ได้ ไม่ต้องกังวล

กฎของ defer: LIFO (Last-In, First-Out)

ถ้าในหนึ่งฟังก์ชันมี defer หลายอัน มันจะทำงานเหมือน "กองจาน" ซึ่ง “จานที่วางไว้บนสุด (defer อันล่าสุด) จะถูกหยิบออกไปก่อน”

ตัวอย่าง:

func main() {
    fmt.Println("เริ่มนับ...")

    defer fmt.Println("1") // อันนี้จะทำงานเป็นอันดับ 3 (อันแรกสุด)
    defer fmt.Println("2") // อันนี้จะทำงานเป็นอันดับ 2
    defer fmt.Println("3") // อันนี้จะทำงานเป็นอันดับ 1 (อันล่าสุด)

    fmt.Println("...นับเสร็จ!")
}

ผลลัพธ์ที่ได้:

เริ่มนับ...
...นับเสร็จ!
3
2
1

defer เป็นเครื่องมือที่เรียบง่ายแต่ช่วยให้โค้ด Go ของเราปลอดภัยและสะอาดขึ้นอย่างมหาศาลครับ

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

• Error Handling สอนให้เราจัดการกับความผิดพลาดอย่างเป็นระบบ
• defer เป็นเครื่องมือช่วยชีวิตที่ทำให้เราจัดการทรัพยากรได้อย่างปลอดภัยและไม่ตกหล่น

เราได้ครอบคลุมเครื่องมือหลักๆ สำหรับการเขียนโปรแกรมทั่วไปใน Go เกือบทั้งหมดแล้ว ในตอนต่อไป เราจะก้าวเข้าสู่โลกที่เป็น “หัวใจ” และเป็นความสามารถที่โดดเด่นที่สุดของ Go ที่ทำให้มันแตกต่างจากภาษาอื่น นั่นคือ Concurrency หรือการเขียนโปรแกรมให้ทำงานหลายๆ อย่างพร้อมกันได้อย่างง่ายดายและปลอดภัยด้วย Goroutines และ Channels ครับ

สำหรับใครที่ติดปัญหา หรือมีข้อสงสัยเกี่ยวกับการเขียน Go ก็สามารถทักไปหาผมได้ที่ Fanpage : Mos Programmer ได้นะครับ

สุดท้ายนี้ถ้าเห็นว่าบทความนี้น่าสนใจก็ฝากเพื่อนๆ พี่ๆ น้องๆ ช่วยแชร์ บทความนี้ไปให้เพื่อนๆ หรือคนรู้จักด้วยนะครับ แล้วก็อย่าลืม กดไลค์ กดติดตาม Fanpage : Mos Programmer จะได้ไม่พลาดเนื้อหาดีๆ กันนะครับ

สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ ในบทความนี้เราจะมารู้จักสิ่งที่เรียกว่า Interface กันครับ

Interface คืออะไร?

Interface เปรียบเสมือน “สัญญา” ในโลก Programming ครับ มันไม่ได้บอกว่า “สิ่งนั้นคืออะไร” แต่จะบอกว่า “สิ่งนั้นทำอะไรได้บ้าง”

เปรียบได้กับสิ่งที่เข้าใจง่ายที่สุดอย่างเช่น “เต้ารับไฟฟ้า” ครับ

เต้ารับไฟฟ้า (The Socket) = คือ Interface เต้ารับไฟฟ้ากำหนด “สัญญา” หรือ “กฎ” เอาไว้ว่า “ถ้าจะเสียบกับฉันได้ อุปกรณ์นั้นจะต้องมี ปลั๊กขาแบน 2 ขา” เต้ารับไม่สนใจเลยว่าอุปกรณ์นั้นจะเป็นพัดลม, ทีวี, ที่ชาร์จมือถือ หรือโคมไฟ ขอแค่มีปลั๊กที่ตรงตามกฎก็พอ

ปลั๊กเครื่องใช้ไฟฟ้า (The Plug) = คือ Type ที่ทำตามสัญญา ปลั๊กของพัดลม (มีขาแบน 2 ขา) เท่ากับว่าทำตามสัญญา สามารถเสียบได้ ปลั๊กคอมพิวเตอร์มี 3 ขา เท่ากับว่าไม่เป็นไปตามสัญญา ก็ไม่สามารถนำมาเสียบได้นั่นเองครับ

ทีนี้ตอนเอาไปเขียนใน Code ถ้าเรากำหนด Interface Shape ว่าต้องมี method Area() และเรามี Struct Circle ที่มี method Area() และมี Struct Rectangle ที่มี methodArea() Go จะถือว่าทั้ง Circle และ Rectangle เป็น Shape โดยอัตโนมัติ เราไม่จำเป็นต้องเขียนบอกโปรแกรมว่า Circle implements Shape เหมือนในภาษาอื่น

ตัวอย่างโค้ดสั้นๆ

// 1. สร้าง "สัญญา" (Interface)
// สัญญาคือ: ต้องหาพื้นที่ได้ (Area())
type Shape interface {
    Area() float64
}

// 2. สร้าง Type ที่จะมาทำตามสัญญา
type Circle struct { Radius float64 }
type Rectangle struct { Width, Height float64 }

// 3. ทำให้ Type ทำตามสัญญา (แค่สร้าง Method ให้ครบ)
func (c Circle) Area() float64 { return 3.14 * c.Radius * c.Radius }
func (r Rectangle) Area() float64 { return r.Width * r.Height }


// 4. ฟังก์ชันที่รับ "สัญญา" เป็น Input
// ฟังก์ชันนี้ไม่สนว่าจะเป็นวงกลมหรือสี่เหลี่ยม ขอแค่ทำตามสัญญา (หาพื้นที่ได้) ก็พอ
func printArea(s Shape) {
    fmt.Printf("พื้นที่คือ %.2f\n", s.Area())
}

func main() {
    myCircle := Circle{Radius: 5}
    myRectangle := Rectangle{Width: 4, Height: 6}

    // เราสามารถส่ง "อะไรก็ได้" ที่ทำตามสัญญา Shape เข้าไปได้
    printArea(myCircle)
    printArea(myRectangle)
}

เห็นมั้ยครับว่าเรา ไม่ได้เขียนที่ไหนเลยว่า Rectangle implements Shape หรืออะไรทำนองนั้น ภาษา Go จะรู้โดยอัตโนมัติว่าถ้า Type ไหนมี Method ทั้งหมดตามที่ Interface กำหนดไว้ ก็จะถือว่า Type นั้นทำตามสัญญาของ Interface ที่กำหนดไว้ทันที เราเรียกสิ่งนี้ว่า Implicit Implementation

นอกจากนี้ใน Go มี Interface พิเศษที่เรียกว่า “Empty Interface” ซึ่งเขียนว่า interface{} คือ Interface ที่ ไม่มี Method ที่บังคับให้ต้องทำตามเลย ผลก็คือ Type ทุกชนิดใน Go ทำตามสัญญาของ Empty Interface โดยอัตโนมัติ

เราจึงใช้ interface{} เพื่อสร้างฟังก์ชันที่สามารถรับค่าเป็นอะไรก็ได้ แบบนี้ครับ

func printAnything(value interface{}) {
    fmt.Printf("ค่าที่รับมาคือ '%v' และเป็นชนิด %T\n", value, value)
}

func main() {
    printAnything(42)
    printAnything("hello")
    printAnything(true)
    printAnything(Rectangle{Width: 3, Height: 4})
}

ข้อควรระวัง: interface{} ให้ความยืดหยุ่นสูง แต่ก็ต้องแลกมากับการที่เราไม่รู้ Type ที่แท้จริงของข้อมูล ซึ่งการจะนำไปใช้งานต่อต้องใช้เทคนิคขั้นสูงขึ้นที่เรียกว่า "Type Assertion"

นอกจากนี้สิ่งที่ต้องระวังอย่างมากอีกอย่างนึงก็คือ nil ซึ่งมักจะมาพร้อมกับ Empty Interface เสมอครับ

nil คืออะไร?

nil (อ่านว่า นิล) ในภาษา Go คือ "ค่าว่าง" หรือ "ความไม่มีอยู่" สำหรับข้อมูลบางประเภทครับ แล้วข้อมูลประเภทไหนที่สามารถเป็น nil ได้บ้าง?

• Slice ([]string): Slice ที่ยังไม่ได้ถูกสร้างขึ้น
• Map (map[string]int): Map ที่ยังไม่ได้ถูกสร้างขึ้น
• Pointer (*int): ตัวชี้ที่ยังไม่ได้ชี้ไปที่ข้อมูลใดๆ
• Interface (interface{}): Interface ที่ยังไม่มีการกำหนดค่าหรือ Type ใดๆ
• Function (func()): ตัวแปรฟังก์ชันที่ยังไม่ได้กำหนดค่าเป็นฟังก์ชันใดๆ
• Channel (chan int): Channel ที่ยังไม่ได้ถูกสร้างขึ้น

ข้อควรระวัง : “nil pointer dereference” (Panic!) นี่คือ Error ที่เจ็บปวดที่สุดสำหรับมือใหม่ มันเกิดขึ้นเมื่อเราพยายาม ใช้งานข้อมูลจากตัวแปรที่เป็น nil

ดังนั้น Type ใดๆ ที่มี Method ทั้งหมดตามที่ Interface กำหนดไว้ แต่ค่าที่เก็บไว้เป็น nil เราจึงจำเป็นจะต้องระวังเป็นพิเศษ เพื่อไม่ให้เกิด Panic ขึ้นนั่นเองครับ

สรุปเลย Interface คือแนวคิดที่ช่วยให้เราเขียนโค้ดที่ยืดหยุ่น, ไม่ผูกติดกัน (Decoupled), และนำกลับมาใช้ใหม่ได้ง่าย โดยเปลี่ยนมุมมองจากการเขียนโค้ดที่อิงกับ “มันคืออะไร” (Concrete Type) ไปเป็นการอิงกับ “มันทำอะไรได้บ้าง” (Behavior)

เราได้เดินทางมาครอบคลุมแกนหลักของภาษา Go เกือบทั้งหมดแล้ว ตั้งแต่พื้นฐาน, โครงสร้างข้อมูล, ไปจนถึงการจัดระเบียบโค้ด ในตอนต่อไป เราจะมาเจาะลึกในหัวข้อที่สำคัญอย่างยิ่งในการสร้างแอปพลิเคชันที่เสถียร นั่นคือ การจัดการข้อผิดพลาด (Error Handling) ในสไตล์ของ Go และการใช้ defer เพื่อช่วยจัดการทรัพยากรให้สะอาดปลอดภัยครับ

สำหรับใครที่ติดปัญหา หรือมีข้อสงสัยเกี่ยวกับการเขียน Go ก็สามารถทักไปหาผมได้ที่ Fanpage : Mos Programmer ได้นะครับ

สุดท้ายนี้ถ้าเห็นว่าบทความนี้น่าสนใจก็ฝากเพื่อนๆ พี่ๆ น้องๆ ช่วยแชร์ บทความนี้ไปให้เพื่อนๆ หรือคนรู้จักด้วยนะครับ แล้วก็อย่าลืม กดไลค์ กดติดตาม Fanpage : Mos Programmer จะได้ไม่พลาดเนื้อหาดีๆ กันนะครับ

สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ บทความนี้สร้างขึ้นเพื่อให้ความรู้ และความบันเทิงนะครับ ถ้าใครไม่ซีเรียสก็อ่านขำๆได้นะครับ

พอดีช่วงนี้มี Event จอง Nintendo Switch 2 กัน แต่ผมก็ไม่ได้สนใจ เนื่องจากว่ายังหาเหตุผลให้ไปซื้อมาเล่นไม่ได้ เครื่องเก่าที่มีอยู่ก็แทบไม่ได้เล่นเลย ทำแต่งาน เวลาว่างก็แทบไม่มีละ

แต่พอดีว่าทั้งใน Social Media บวกกับน้องๆในที่ทำงาน บ่นๆกันเรื่องจอง Nintendo Switch 2 ผมก็เลยลองเข้าไปจองกับเค้าบ้าง แต่ก็แห้วตลอดเลย (แหะๆ) ก็เลยแอบไปลองถามในกลุ่ม ไปสอดส่องหาข่าวสารนิดนึง

ต้องบอกก่อนเลยว่า ก่อนหน้าที่จะมาสืบข่าวเรื่องนี้ ผมเองไม่ได้ติดตามอะไรเลย เรื่องการจองเครื่องก็สอบถามใน Social ก่อนที่จะมาเขียนบทความนี่แหละครับ เท่าที่ได้เรื่องมาก็น่าจะประมาณว่า

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

ซึ่งถ้าเป็นระบบทั่วไป ประมาณนี้ มันก็ไม่น่าจะล่มถูกมั้ยครับ แล้วปัญหามันอยู่ที่ตรงไหนล่ะ เรามานั่งวิเคราะห์กันครับ

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

เท่าที่ผมลองวิเคราะห์ และลองวาดออกมา Flow ก็น่าจะประมาณนี้ ถ้าใครมองว่าต้องปรับตรงไหนเพิ่ม ก็ Comment เพิ่มเติมใน Facebook ละกันนะครับ

STEP 1 — ลูกค้าเข้าหน้าเว็บตาม Link ที่ได้รับมา

STEP 2 — ลูกค้าเลือก Dealer

STEP 3 — หน้าเว็บจะส่งต่อไปยังหน้ารอคิว

STEP 4 — ในหน้ารอคิว เริ่มต้นก็จะทำการเรียก api เพื่อทำการเช็คคิวก่อน ว่ามีใครรอคิวก่อนหน้าหรือป่าว ถ้ามีก็จะมีการตั้งเวลาไว้ประมาณนึง แล้วก็ค่อยไปยิง api เพื่อเช็คใหม่อีกรอบ วนๆไปแบบนี้จนกว่าจะถึงคิวของลูกค้า

STEP 5 — พอถึงคิวลูกค้าก็จะเข้าสู่หน้าจอง ซึ่งหน้าจองก็จะโหลดข้อมูลต่างๆมาให้ลูกค้าได้กรอกข้อมูลสำหรับจองคิว ทั้งข้อมูลสาขา และข้อมูลเครื่องเกม

STEP 6 — ลูกค้ากรอกข้อมูลแล้วกด Submit เพื่อส่งข้อมูลไปยัง Backend

STEP 7 — ในส่วนของ Backend ก็จะทำการประมวลผล ตามเงื่อนไขที่ตั้งไว้ ถ้าไม่ติดเงื่อนไขอะไรก็จะสามารถส่ง email ออกไปได้

ทีนี้มาเดากันต่อครับว่าปัญหาสามารถเกิดขึ้นได้ที่ Step ไหนบ้าง

เท่าที่ผมลองคิดๆดู STEP 4 ก็มีความเป็นไปได้ที่จะเกิด การ query ข้อมูลอย่างหนักทำให้ database รับภาระเยอะ เพราะว่าจะมีการส่ง request จากทางฝั่ง frontend ส่งไปเป็นระยะๆ ซึ่งตรงนี้ จะต้อง คูณด้วยจำนวน browser ที่เปิดดูหน้านี้อยู่ด้วย แต่ตรงนี้ก็สามารถแก้ไขได้โดยการใช้ cache storage อย่างเช่น redis หรือ dynamoDB มารองรับตรงนี้แทน ทำให้ไม่ต้องไปแตะ database บ่อยๆ ซึ่งถ้าใช้วิธีนี้ สิ่งที่ตามมาก็น่าจะเป็นเรื่องของ Resource ที่จัดสรรค์ให้กับตัว api ว่าเพียงพอต่อจำนวน request มั้ย ซึ่งถ้ายอมเพิ่ม resource ให้ หรืออาจจะเตรียมไว้ให้สามารถ scale ได้ตั้งแต่แรก STEP 4 ก็น่าจะผ่านไป

STEP ที่มีความเป็นไปได้ถัดไปก็น่าจะเป็น STEP 5 เนื่องจากว่าจะต้องดึงข้อมูลสาขา ต่างๆออกมา ซึ่งก็จะมี Logic ในการดึงข้อมูลตรงนี้ด้วย อาจจะต้องเริ่มดูจากส่วนของ database ก่อนเลยว่า เก็บข้อมูลสาขาลง database แบบไหน เป็น sql หรือ nosql ข้อมูลสาขา และข้อมูลจำนวนเครื่อง หรือจำนวนโควต้าต่างๆ เก็บรวมกันอยู่ใน table หรือ collection เดียวกัน หรือว่าอยู่ต่างที่กัน ต้องจับมา join กันหรือป่าว หรือว่าจริงๆแล้วแยกเป็น microservice ข้อมูลสาขาเก็บที่นึง ข้อมูลโควต้าเก็บอีกที่นึง ซึ่งอาจจะต้องแยกเป็นแต่ละหัวข้อก่อน

• ในกรณีที่เก็บลง sql และอยู่ table เดียวกัน ก็อาจจะเป็นเพราะมีการ update ข้อมูลอยู่ตลอดเวลาทำให้ database รับภาระหนักเกินไป อาจจะต้องใช้ cache storage มาเก็บข้อมูลในส่วนที่ต้องทำการดึงไปใช้ แทนการแตะ database ตรงๆแทน
• แต่ถ้าเป็นการเก็บลง nosql อันนี้อาจจะต้องดูต่อว่า index กำหนดได้ถูกต้องมั้ย data ที่เก็บลง database มี field ที่ต้องการครบหรือป่าว หรือว่าเก็บไว้แยก collection กัน ถ้าแยก collection อันนี้อาจจะต้องรื้อ data structure ใหม่ แล้วทำการรวม data ให้มาอยู่ในก้อนเดียวกัน เพื่อไม่ให้เกิดการ join ขึ้น เนื่องจาก การ join กันใน nosql เป็นอะไรที่ทำงานได้ช้ามากๆ
• หรือถ้าเก็บใน sql แต่แยก table กัน อันนี้อาจจะต้องดูว่า index ถูกต้องมั้ย มี index สำหรับ join และ index สำหรับ where ครบหรือป่าว หรือจะให้ดีก็เก็บลง cache storage ไปเลยจะดีกว่า
• แต่ถ้าหากว่าเป็นการดึงข้อมูลจาก database แล้วเอามา get api จาก microservice อื่นๆอีกที หรือไม่ว่าจะเป็นการ get ข้อมูลจาก api ตัวนึง แล้วเอา data มารวมกับ api อีกตัวนึง อันนี้ยิ่งจำเป็นจะต้องทำเป็น cache storage ด่วนๆเลยเพราะวิธีการนี้ ทำให้ระบบเสียเวลาซ้ำซ้อนเข้าไปอีกนั่นเอง
• แต่ถ้าหากว่าทั้งหมดทั้งมวลเก็บลง cache storage ไปหมดแล้ว แต่ก็ยังช้าอยู่ก็อาจจะต้องพิจารณาอัด resource ให้แทน ให้เพียงพอต่อการรับ load ที่เข้ามา

แต่ถ้าลองดูแล้วปรากฎว่าตรงนี้ยังไม่ใช่ ก็จะเหลือ STEP สุดท้าย STEP 7 ในการเช็ค เงื่อนไขต่างๆ ว่าในการเช็คแต่ละเงื่อนไข มี Logic ที่ซับซ้อนหรือป่าว หรือว่ามีการดึงข้อมูลที่ไม่จำเป็นออกมาด้วยมั้ย เพราะเท่าที่เข้าใจจากการเดา(ขอย้ำว่าจากการเดานะครับ) STEP นี้จะเป็นการเช็คเงื่อนไขต่างๆซ้ำอีกรอบ ก่อนจะเอาลง database ถ้าไม่ได้ดึงข้อมูลเกินกว่าที่จำเป็นก็จะมีอีกเรื่องก็คือเรื่องของ Index ที่ต้องดูว่าสร้างไว้ถูกต้อง เพียงพอ หรือว่าสร้างมากเกินจำเป็นหรือป่าว เนื่องจากว่าการสร้าง Index มากเกินไป ก็ทำให้เสีย performance ในการ insert update delete ข้อมูลใน database ได้นั่นเองครับ

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

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

โดย Flow ของผมจะแบ่งออกเป็น 2 ส่วน โดยส่วนแรกจะเป็นการ submit form เพื่อขอ code สำหรับนำไปกรอกเพื่อจอง ประมาณนี้

STEP 1 — ลูกค้ากรอกข้อมูลส่วนตัว เลขบัตรประชาชนและ Email เข้าไปในระบบ

STEP 2 — ตัวระบบเองจะทำการ Hash ข้อมูลบัตรประชาชนลูกค้า พร้อมทั้ง Generate Code ขึ้นมาชุดนึง แล้วเก็บลง Cache Storage ตรงนี้ผมเลือกเป็น Redis ละกัน (ที่เลือกเพราะใช้เป็นอยู่เจ้าเดียวครับ 55555) โดยให้ Hash ของเราเป็น Key และ Code เป็น Value ครับ ซึ่งตรงนี้จะมี Logic อยู่นิดนึง โดยการนำ Hash ของเราไปเช็คกับ Redis ก่อนว่ามีข้อมูลหรือยัง ถ้ามีแล้วก็แสดงว่าเคยจองไปแล้ว เราก็จะ็ตี Fail กลับไป

STEP 3 — เราเอาข้อมูลที่ได้รับมาจากลูกค้าส่งต่อไปให้ Message Queue ของเรา ตรงนี้ผมเลือกเป็น Kafka ละกัน (เนื่องจากเหตุผลเดียวกันกับข้างบนเลย) ตรงนี้ผมใช้ เวลาที่ลูกค้า request เข้ามา เอามาทำเป็น Partition Key แล้วให้ queue ของผมเป็นแบบ FIFO ซึ่งตรงนี้อาจจะทำงานช้าหน่อย แต่ไม่เป็นไร เราปล่อยมันทำไป เสร็จเมื่อไหร่ก็เมื่อนั้น

STEP 4 — ตรงนี้จะมี Consumer คอยเอา Message จาก Kafka มา Process ต่อโดยอาจจะกำหนดกลุ่มของลูกค้าไปเลยว่าลูกค้าสามารถนำ Code ไปใช้ได้ในช่วงเวลาไหนบ้าง หรืออาจจะทำการแบ่ง Lot ในการส่ง Email ให้ลูกค้าใน STEP นี้ ยกตัวอย่าง อย่างเช่นว่า เราอยากให้ช่วง 11.00–12.00 ของวันถัดไป มีลูกค้าเข้ามาทำการจองได้สูงสุดพร้อมกันที่ 2,000 คนเราก็จะสามารถ control ได้ จากนั้นก็เก็บลง database และ cache storage ให้เรียบร้อย

STEP 5 — ตรงนี้ผม Design เผื่อไว้ว่าเราอาจจะมี Batch สำหรับ ส่ง email แยกเก็บไว้ หรืออาจจะทำเป็น cronjob อีกทีก็ได้เหมือนกัน เผื่อว่าบางที เราอาจจะยังไม่พร้อมส่ง Email ณ ตอนนั้น หรืออาจจะเกิดเหตุฉุกเฉินทำให้ยังไม่สามารถส่ง Email ให้ลูกค้าได้ แต่ถ้าพร้อมจะส่ง mail ให้ลูกค้าเมื่อไหร่ก็ค่อยสั่งให้ระบบทำงานอีกทีครับ

พอถึงตรงนี้ลูกค้าก็จะทยอยได้ Email กันบ้างแล้ว บางคนอาจจะได้ใช้ บางคนอาจจะได้เร็ว แต่ไม่ต้องมีใครมานั่งรอกดจอง แล้วนั่งเฝ้าหน้าจอระหว่างที่ระบบล่มทั้งวันแล้ว ซึ่งพอลูกค้าได้ Email ก็จะเข้าสู่ Flow ถัดไปครับ

พอลูกค้าได้รับ Email ใน Mail ของลูกค้าก็จะมี Code ซึ่งแยกไปตามแต่ละบุคคล โดยจะมี STEP ตามนี้ครับ

STEP 1 — ลูกค้านำ Code ที่ได้มากรอกในหน้าเว็บ พร้อมกับระบุเลขบัตรประชาชนของตัวเองจากนั้นก็กด Submit โลดดด

STEP 2 — ตัวระบบเองจะนำ เลขบัตรประชาชนที่ได้ไป Hash แล้ว Get ค่าจาก Redis ของเรา เพื่อนำค่าที่ได้มาเช็คว่า มีข้อมูลจริงมั้ย code ที่ส่งมาถูกหรือป่าว แล้วช่วงเวลาที่กดมา ตรงกับที่ระบบกำหนดไว้มั้ย ถ้าไม่ตรงก็ตี Fail กลับไปได้เลยตรงนี้ครับ แต่ถ้าตรงก็ให้ไปต่อ

STEP 3 — ตรงนี้ก็ให้ลูกค้าเลือกรุ่น เลือกข้อมูลสาขา เลือกวันที่และเวลาที่จะรับได้เลย พอเสร็จแล้วก็กดส่ง แล้วเราค่อยไปเช็คว่าข้อมูลที่ลูกค้ากรอกมา สามารถใช้จองได้มั้ย ถ้าใช้ไม่ได้ ไม่ตรงเงื่อนไข ก็ตอบ Fail กลับไปเลย แต่ถ้าใช้ได้ก็เก็บลง database แล้วก็ส่ง Email แจ้งลูกค้าว่าเรียบร้อย เท่านี้เป็นอันจบ Flow ยิ้มได้เลย

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

ถึงตรงนี้ถ้าใครมีไอเดียดีๆ หรือมี Comment อยากติชม ก็สามารถเข้าไปทักหาผม หรืออาจจะไป Comment ในโพสได้เหมือนกันนะครับ

สุดท้ายนี้ถ้าเห็นว่าบทความนี้น่าสนใจก็ฝากเพื่อนๆ พี่ๆ น้องๆ ช่วยแชร์ บทความนี้ไปให้เพื่อนๆ หรือคนรู้จักด้วยนะครับ แล้วก็อย่าลืม กดไลค์ กดติดตาม Fanpage : Mos Programmer จะได้ไม่พลาดเนื้อหาดีๆ กันนะครับ

สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ ในบทความนี้เราจะมาแก้ปัญหานี้กันด้วยการเรียนรู้เครื่องมือที่สำคัญที่สุดอย่างหนึ่งในการเขียนโปรแกรม นั่นคือการสร้าง ฟังก์ชัน (Functions) ครับ

Function คืออะไร?

Function คือ “กล่องเครื่องมือ” หรือ “สูตรอาหาร” ที่เราสร้างขึ้นมาเก็บชุดคำสั่งไว้ แล้วตั้งชื่อให้มัน เพื่อให้เราสามารถเรียกใช้งานซ้ำๆ ได้ง่ายๆ ครับ

ลองนึกภาพฟังก์ชันเหมือน “เครื่องปั่นน้ำผลไม้”

1. Input (สิ่งที่เราใส่เข้าไป): คือ ผลไม้, น้ำแข็ง, โยเกิร์ต ที่เราใส่ลงไปในโถปั่น

• ในโลกโปรแกรมมิง เราเรียกสิ่งนี้ว่า พารามิเตอร์ (Parameter)

2. Process (สิ่งที่เกิดขึ้น): คือการที่เครื่องปั่น หมุนปั่นส่วนผสมทั้งหมดให้เข้ากัน เราไม่จำเป็นต้องรู้ว่ามอเตอร์ทำงานยังไง รู้แค่ว่ามันทำงานของมัน

• ในโลกโปรแกรมมิง นี่คือ โค้ดที่อยู่ข้างในฟังก์ชัน

3. Output (สิ่งที่เราได้ออกมา): คือ น้ำผลไม้ปั่น (Smoothie) ที่พร้อมดื่ม

• ในโลกโปรแกรมมิง เราเรียกสิ่งนี้ว่า ค่าที่ส่งคืน (Return Value)

ข้อดีของ function โดยหลักๆ เลยก็คือ

• Reusability (ใช้ซ้ำได้): แทนที่จะเขียนโค้ดบวกลบคูณหารซ้ำๆ เราก็สร้างฟังก์ชัน calculate() ขึ้นมาอันเดียวแล้วเรียกใช้เมื่อไหร่ก็ได้
• Organization (จัดระเบียบ): ช่วยแบ่งโปรแกรมที่ซับซ้อนออกเป็นส่วนเล็กๆ ที่เข้าใจง่าย
• Readability (อ่านง่าย): ฟังก์ชันที่มีชื่อสื่อความหมาย (เช่น printReport()) จะช่วยให้คนอื่นเข้าใจได้ทันทีว่าโค้ดส่วนนั้นทำอะไร

หน้าตา function ก็จะเป็นประมาณนี้

func ชื่อฟังก์ชัน(พารามิเตอร์) (ชนิดข้อมูลที่ส่งคืน) {
    //
    // ส่วนของการทำงาน (Function Body)
    //
    return ค่าที่ส่งคืน
}

โครงสร้างของ function จะประกอบด้วย

1. คีย์เวิร์ด func (The func Keyword)
คือ “คำสั่งเริ่มต้น” ที่บอก Go ว่า “สิ่งที่จะตามมานี้คือการนิยามฟังก์ชันนะ” ดังนั้นทุกครั้งที่จะสร้างฟังก์ชัน จะต้องขึ้นต้นด้วยคำว่า func เสมอ

2. ชื่อฟังก์ชัน (Function Name)
คือชื่อที่เราตั้งขึ้นเพื่อใช้อ้างอิงหรือเรียกใช้งานฟังก์ชันนี้ในภายหลัง

• หลักการตั้งชื่อที่ดี: ควรเป็นชื่อที่สื่อความหมายว่าฟังก์ชันนั้นทำอะไร เช่น calculateTotalPrice, getUserFromDB, printReport
• ใน Go นิยมใช้รูปแบบ camelCase ในการตั้งชื่อ (คำแรกขึ้นต้นด้วยตัวเล็ก คำถัดไปขึ้นต้นด้วยตัวใหญ่) เช่น calculateArea หรือถ้าต้องการนำไปใช้นอก Package ก็จะใช้รูปแบบ PascalCase ในการตั้งชื่อ (คำแรกขึ้นต้นด้วยตัวใหญ่ คำถัดไปขึ้นต้นด้วยตัวใหญ่) เช่น CreateProduct

3. พารามิเตอร์ (Parameter)

คือ “ช่องรับข้อมูลเข้า” (Input) ของฟังก์ชัน เปรียบเสมือนวัตถุดิบที่เราจะส่งเข้าไปให้ฟังก์ชันทำงาน จะอยู่ภายในวงเล็บ ( ) ประกอบด้วย ชื่อพารามิเตอร์ ตามด้วย ชนิดข้อมูล

func add(parameterName int)

บางครั้งฟังก์ชันอาจจะ ไม่มีพารามิเตอร์เลยก็ได้ ()

func add()

หรือถ้ามีหลายตัว ให้คั่นด้วยเครื่องหมาย , (comma)

func add(a int,b int)

Trick: ถ้าพารามิเตอร์หลายตัวติดกันเป็นชนิดข้อมูลเดียวกัน สามารถรวบการประกาศชนิดข้อมูลไว้ท้ายสุดได้

// แบบเต็ม
func add(a int, b int)

// แบบย่อ (นิยมใช้)
func add(a, b int)

4. Return Types ( ... )

คือ ชนิดของข้อมูลที่เราต้องการ Return กลับออกไปเมื่อฟังก์ชันทำงานเสร็จแล้ว แต่ถ้าเราไม่ต้องการคืนค่าอะไรออกจาก function เราก็ไม่ต้องใส่ส่วนนี้เลย นอกจากนี้ถ้าเราต้องการ return ค่าออกไป ก็สามารถทำได้อีก 2 แบบนั่นคือ

• คืนค่าเดียว: สามารถใส่แค่ชนิดข้อมูลได้เลย ไม่ต้องมีวงเล็บ เช่น int หรือ string
• คืนค่าหลายค่า: ต้องใส่วงเล็บครอบ และคั่นชนิดข้อมูลด้วย , เช่น (int, error) ซึ่งเป็นรูปแบบที่พบบ่อยมากใน Go สำหรับการคืนค่าผลลัพธ์พร้อมกับสถานะ error

5. Function Body { ... }
คือส่วนที่อยู่ภายในวงเล็บปีกกา { } เป็นส่วนที่เก็บ “ชุดคำสั่ง” หรือ “ขั้นตอนการทำงาน” ทั้งหมดของฟังก์ชัน ถ้าฟังก์ชันมีการกำหนดว่าจะต้องคืนค่า (Return Types) ภายใน Body จะต้องมีคำสั่ง return เพื่อส่งค่ากลับไปให้ตรงตามชนิดที่กำหนดไว้

มาดูตัวอย่างฟังก์ชันที่ใช้งานจริงเพื่อเทียบกับโครงสร้างกันครับ

ตัวอย่างที่ 1: ฟังก์ชันที่ไม่มีการรับค่าและคืนค่า

package main
import "fmt"

// สร้างฟังก์ชันชื่อ sayHello
func sayHello() {
    fmt.Println("สวัสดี! ยินดีต้อนรับสู่โลกของ Go Functions")
}

func main() {
    // เรียกใช้งานฟังก์ชัน
    sayHello()
}

ตัวอย่างที่ 2: ฟังก์ชันที่รับค่า (Parameters) และคืนค่า (Return Value)

package main
import "fmt"

// ฟังก์ชัน add รับค่า a และ b (ชนิด int)
// และคืนค่าผลรวมเป็นชนิด int
func add(a int, b int) int {
    result := a + b
    return result
}

// ถ้าพารามิเตอร์เป็นชนิดเดียวกัน สามารถเขียนย่อได้
func subtract(a, b int) int {
    return a - b
}

func main() {
    sum := add(10, 5)
    fmt.Println("ผลบวกคือ:", sum) // ผลลัพธ์: 15

    difference := subtract(10, 5)
    fmt.Println("ผลต่างคือ:", difference) // ผลลัพธ์: 5
}

ตัวอย่างที่ 3: ฟังก์ชันที่รับค่า (Parameters) และคืนค่าหลายค่า

package main

import (
 "fmt"
 "errors"
)

// ฟังก์ชันหารเลข ที่คืนค่า 2 อย่าง:
// 1. ผลหาร (float64)
// 2. ข้อผิดพลาด (error)
func divide(a, b float64) (float64, error) {
    if b == 0 {
        // ถ้าตัวหารเป็น 0, ให้คืนค่า 0 และ error message
        return 0, errors.New("ไม่สามารถหารด้วยศูนย์ได้")
    }
    // ถ้าสำเร็จ, ให้คืนค่าผลลัพธ์ และ error เป็น nil (ไม่มีข้อผิดพลาด)
    return a / b, nil
}

func main() {
    // กรณีสำเร็จ
    result, err := divide(10.0, 2.0)
    if err != nil {
        fmt.Println("เกิดข้อผิดพลาด:", err)
    } else {
        fmt.Println("ผลหารคือ:", result) // ผลลัพธ์: 5
    }

    // กรณีเกิดข้อผิดพลาด
    result, err = divide(10.0, 0)
    if err != nil {
        fmt.Println("เกิดข้อผิดพลาด:", err) // ผลลัพธ์: เกิดข้อผิดพลาด: ไม่สามารถหารด้วยศูนย์ได้
    } else {
        fmt.Println("ผลหารคือ:", result)
    }
}

Method คืออะไร?

Method คือฟังก์ชันที่ “ผูกติด” อยู่กับ type ที่เราสร้างขึ้น (ส่วนใหญ่คือ struct) มันทำให้เราสามารถเรียกใช้ฟังก์ชันจากตัวแปรของ Type นั้นได้โดยตรง และถูกเรียกอีกชื่อว่า Reciever function หรือจะเรียกว่า Reciever method ก็ได้เหมือนกัน แล้วแต่ที่ว่าจะเรียกแบบไหน

ความแตกต่างระหว่าง Function ปกติ และ Method

• Function เราสามารถเรียกใช้งานได้เลย
• Method: จำเป็นจะต้องสร้าง instance ของ struct ก่อนถึงจะเรียก method ผ่าน instance ได้อีกที

ทีนี้เรามาลองสร้าง Method ให้กับ struct ที่เราคุ้นเคยกัน

package main
import "fmt"

// 1. นิยาม Struct
type Rectangle struct {
    Width  float64
    Height float64
}

// 2. สร้าง Method ชื่อ area() สำหรับ Rectangle
// (r Rectangle) คือส่วนที่เรียกว่า "Receiver"
// มันทำให้โค้ดในฟังก์ชันนี้สามารถเข้าถึงฟิลด์ของ r (เช่น r.Width) ได้
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func main() {
    // 3. สร้าง Instance ของ Rectangle
    rect := Rectangle{Width: 10, Height: 5}

    // 4. เรียกใช้งาน Method ผ่านตัวแปร rect ได้เลย
    fmt.Printf("สี่เหลี่ยมผืนผ้าขนาด %.fx%.f\n", rect.Width, rect.Height)
    fmt.Println("มีพื้นที่เท่ากับ:", rect.Area()) // ผลลัพธ์: 50
}

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

สำหรับใครที่ติดปัญหา หรือมีข้อสงสัยเกี่ยวกับการเขียน Go ก็สามารถทักไปหาผมได้ที่ Fanpage : Mos Programmer ได้นะครับ

สุดท้ายนี้ถ้าเห็นว่าบทความนี้น่าสนใจก็ฝากเพื่อนๆ พี่ๆ น้องๆ ช่วยแชร์ บทความนี้ไปให้เพื่อนๆ หรือคนรู้จักด้วยนะครับ แล้วก็อย่าลืม กดไลค์ กดติดตาม Fanpage : Mos Programmer จะได้ไม่พลาดเนื้อหาดีๆ กันนะครับ

สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ ในบทความนี้ เราจะมาไขคำตอบของสองคำถามนี้ด้วย Structs และ Maps ซึ่งเป็นโครงสร้างข้อมูลที่สำคัญมากๆ ใน Go ครับ

Struct คืออะไร?

Struct (อ่านว่า สตรัค หรือเต็มๆก็คือ สตรัคเจอร์) คือ “แม่แบบ” หรือ “พิมพ์เขียว” ที่เราสร้างขึ้นเองสำหรับเก็บข้อมูลหลายๆ อย่างที่เกี่ยวข้องกันไว้ในที่เดียวกัน

ลองนึกถึง “บัตรประชาชน” เป็นตัวอย่างที่ดีที่สุดครับ บนบัตรประชาชนใบหนึ่งไม่ได้มีแค่ข้อมูลเดียว แต่ประกอบไปด้วยข้อมูลหลายส่วน เช่น

• ชื่อ-นามสกุล (เป็นข้อมูลชนิด ข้อความ)
• เลขประจำตัว (เป็นข้อมูลชนิด ข้อความ หรือ ตัวเลข)
• วันเกิด (เป็นข้อมูลชนิด วันที่)
• ที่อยู่ (เป็นข้อมูลชนิด ข้อความ)

ถ้าไม่มี “บัตรประชาชน” เราจะต้องถือข้อมูลเหล่านี้แยกกันเป็นชิ้นๆ ซึ่งมันคงจะวุ่นวายมากเลยทีเดียวครับ

วิธีประกาศและใช้งาน Struct เรา ให้เราใช้คีย์เวิร์ด type ตามด้วยชื่อ Struct และ struct เพื่อสร้างแม่แบบของเรา แบบนี้ครับ

package main

import "fmt"

// 1. สร้าง แม่แบบ ของข้อมูลสินค้า โดยใช้ struct
// เรากำลังสร้าง Type ใหม่ที่ชื่อว่า Product
type Product struct {
    ID    string
    Name  string
    Price float64
    Stock int
}

func main() {
    // 2. สร้างข้อมูลสินค้าขึ้นมาจาก แม่แบบ ของเรา
    // เราเรียกสิ่งนี้ว่า "Instance" ของ Struct
    product1 := Product{
        ID:    "P001",
        Name:  "Laptop Pro 15",
        Price: 55900.50,
        Stock: 25,
    }

    product2 := Product{
        ID:    "P002",
        Name:  "Wireless Mouse",
        Price: 899.00,
        Stock: 150,
    }

    // 3. การเข้าถึงข้อมูลแต่ละฟิลด์ (Field) ทำได้โดยใช้เครื่องหมายจุด (.)
    fmt.Println("ข้อมูลสินค้าชิ้นแรก:")
    fmt.Printf("  ชื่อ: %s\n", product1.Name)
    fmt.Printf("  ราคา: %.2f บาท\n", product1.Price)

    fmt.Println("\nข้อมูลสินค้าชิ้นที่สอง:")
    fmt.Printf("  รหัส: %s\n", product2.ID)
    fmt.Printf("  จำนวนในสต็อก: %d ชิ้น\n", product2.Stock)
}

Struct ใช้แก้ปัญหาอะไรในเคสนี้ ?

ลองจินตนาการว่าเราจะเก็บข้อมูลของหนังสือ 1 เล่ม ถ้าไม่มี Struct เราอาจต้องทำแบบนี้

var bookTitle1 string = "Harry Potter"
var bookAuthor1 string = "J.K. Rowling"
var bookPages1 int = 400

ถ้ามีหนังสือ 100 เล่มล่ะ? เราก็ต้องสร้างตัวแปรแบบนี้อีก 300 ชุด ซึ่งจัดการได้ยากมาก แต่ถ้าเราใช้ Struct เราสามารถสร้าง “แม่แบบ” ของหนังสือขึ้นมาก่อน แบบนี้ได้

// 1. สร้างแม่แบบ ที่ชื่อว่า Book
type Book struct {
    Title  string
    Author string
    Pages  int
}

จากนั้น เวลาเราจะสร้างข้อมูลหนังสือเล่มใหม่ ก็แค่นำ แม่แบบ น้ีไปใช้ แบบนี้ครับ

// 2. สร้างหนังสือเล่มจริงจากแม่แบบ
book1 := Book{
    Title:  "Harry Potter",
    Author: "J.K. Rowling",
    Pages:  400,
}

book2 := Book{
    Title: "The Lord of the Rings",
    Author: "J.R.R. Tolkien",
    Pages: 1178,
}

// 3. การเข้าถึงข้อมูลก็ง่ายและอ่านรู้เรื่อง
fmt.Println(book1.Title) // แสดงผล: Harry Potter
fmt.Println(book2.Author) // แสดงผล: J.R.R. Tolkien

เท่านี้เราก็จะสามารถจัดการข้อมูลของเราได้แล้ว

Map คืออะไร?

Map คือชุดข้อมูลที่เก็บข้อมูลเป็นคู่ๆ แบบ “Key-Value” ซึ่งเราใช้ “Key” เพื่อค้นหา “Value” ที่คู่กันได้อย่างรวดเร็ว

เปรียบเทียบให้เห็นภาพที่สุด ลองนึกถึง “พจนานุกรม” สักเล่มนึง พจนานุกรมทั้งเล่ม เปรียบเสมือนข้อมูล type Map ของเรา ส่วน คำศัพท์ ที่เราเปิดหา (เช่น “Cat”) คือ Key และ ความหมาย ของคำศัพท์นั้น (เช่น “แมว, สัตว์เลี้ยงลูกด้วยนม”) ก็คือ Value นั่นเองครับ

เราสามารถประกาศตัวแปร type Map ได้ โดยใช้คีย์เวิร์ด map[KeyType]ValueType แบบนี้ครับ

package main

import "fmt"

func main() {
    // สร้าง Map โดยใช้ make
    // Key เป็น string และ Value เป็น int (เช่น ชื่อวิชา และ คะแนน)
    scores := make(map[string]int)

    // การเพิ่มหรือแก้ไขข้อมูล
    scores["Math"] = 95
    scores["Science"] = 88
    scores["History"] = 76

    fmt.Println("คะแนนทั้งหมด:", scores) // ผลลัพธ์: map[History:76 Math:95 Science:88]

    // การดึงข้อมูล
    mathScore := scores["Math"]
    fmt.Println("คะแนนวิชาคณิตศาสตร์:", mathScore)

    // การลบข้อมูล
    delete(scores, "History")
    fmt.Println("คะแนนหลังลบวิชาประวัติศาสตร์:", scores)

    // การสร้าง Map พร้อมกำหนดค่าเริ่มต้น
    capitals := map[string]string{
        "Thailand": "Bangkok",
        "Japan":    "Tokyo",
        "USA":      "Washington, D.C.",
    }
    fmt.Println("เมืองหลวงของญี่ปุ่นคือ:", capitals["Japan"])
}

แต่การใช้ Map นั้นมีข้อควรระวังอยู่อย่างนึงครับ ถ้าเราค้นหา Key ที่ไม่มีอยู่ ค่าที่ได้จะเป็นค่าว่าง (Zero Value) ของ Value Type นั้นๆ (เช่น 0 สำหรับ int, “” สำหรับ string) ซึ่งอาจทำให้เราสับสนได้ว่า “Key ไม่มีอยู่จริง” หรือ “Key มีอยู่แต่ค่าของมันคือ 0”

Go จึงมีวิธีตรวจสอบที่ค่อนข้างนิยม เรียกว่า “comma ok” ครับ หน้าตาก็จะเป็นแบบนี้

// ... ต่อจากโค้ด Map ด้านบน ...
// ลองค้นหาคะแนนวิชาศิลปะ (Art) ซึ่งไม่มีอยู่
artScore, ok := scores["Art"]
if ok {
    // ถ้า ok เป็น true แสดงว่ามี Key นี้อยู่จริง
    fmt.Println("คะแนนวิชาศิลปะคือ:", artScore)
} else {
    // ถ้า ok เป็น false แสดงว่าไม่มี Key นี้ใน Map
    fmt.Println("ไม่พบข้อมูลคะแนนวิชาศิลปะ")
}

ทีนี้เราลองเอา Struct และ Map มารวมกันดู โดยผมจะทำเป็นตัวอย่าง จัดการคลังสินค้าด้วย Struct และ Map ก็แล้วกันนะครับ code ก็จะมีรายละเอียดตามนี้

• ใช้ Struct เพื่อเป็นแม่แบบของข้อมูลสินค้า
• ใช้ Map เพื่อเป็นคลังสินค้า โดยใช้ “รหัสสินค้า” (ID) เป็น Key และใช้ “ข้อมูลสินค้า” (Product Struct) เป็น Value

ตัวอย่าง Code

package main

import "fmt"

// แม่แบบข้อมูลสินค้า (เหมือนเดิม)
type Product struct {
    Name  string
    Price float64
}

func main() {
    // สร้างคลังสินค้า (Map) ที่เก็บ Product
    // Key คือ รหัสสินค้า (string), Value คือ Product
    inventory := make(map[string]Product)

    // เพิ่มสินค้าเข้าคลัง
    inventory["P001"] = Product{Name: "Gaming Keyboard", Price: 2500.0}
    inventory["P002"] = Product{Name: "27-inch Monitor", Price: 7800.0}

    // ค้นหาสินค้าด้วยรหัส "P002"
    fmt.Println("--- ค้นหาสินค้า P002 ---")
    product, ok := inventory["P002"]
    if ok {
        fmt.Printf("พบสินค้า: %s, ราคา: %.2f บาท\n", product.Name, product.Price)
    } else {
        fmt.Println("ไม่พบสินค้า P002")
    }

    // วนลูปดูสินค้าทั้งหมดในคลัง
    fmt.Println("\n--- สินค้าทั้งหมดในคลัง ---")
    for id, prod := range inventory {
        fmt.Printf("รหัส: %s -> สินค้า: %s, ราคา: %.2f บาท\n", id, prod.Name, prod.Price)
    }
}

ถึงตรงนี้เราได้เรียนรู้วิธีการใช้งาน Struct และ Map กันไปแล้ว แต่โค้ดของเรายังอยู่รวมกันใน func main() ทั้งหมด ในตอนต่อไป เราจะมาเรียนรู้วิธีการจัดระเบียบ "พฤติกรรม" ของโปรแกรม โดยการสร้าง "ฟังก์ชัน (Functions)" ของเราเอง เพื่อให้โค้ดสะอาด อ่านง่าย และนำกลับมาใช้ใหม่ได้ครับ

สำหรับใครที่ติดปัญหา หรือมีข้อสงสัยเกี่ยวกับการเขียน Go ก็สามารถทักไปหาผมได้ที่ Fanpage : Mos Programmer ได้นะครับ

สุดท้ายนี้ถ้าเห็นว่าบทความนี้น่าสนใจก็ฝากเพื่อนๆ พี่ๆ น้องๆ ช่วยแชร์ บทความนี้ไปให้เพื่อนๆ หรือคนรู้จักด้วยนะครับ แล้วก็อย่าลืม กดไลค์ กดติดตาม Fanpage : Mos Programmer จะได้ไม่พลาดเนื้อหาดีๆ กันนะครับ

สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ บทความนี้ก็จะเป็นการสรุปสุดท้ายของบทความชุด “หัดเขียนโปรแกรมกับเจ้าหลามน้อย Python” แล้วนะครับ

สรุปสิ่งที่คุณได้เรียนรู้มา

ตลอดบทเรียนที่ผ่านมา เราได้ปูพื้นฐานสำคัญของ Python ตั้งแต่เริ่มต้นเลยนะครับ ลองมาทบทวนกันหน่อยว่าเราได้เรียนรู้อะไรไปบ้าง:

ตอนที่ 0

• เราได้ทำการการติดตั้ง Python และ VS Code ซึ่งเป็นเครื่องมือคู่ใจของเรา

ตอนที่ 1

• เราได้ทำความรู้จักว่า Python คืออะไร?
• เราได้รู้จัก Syntax ต่างๆ และ Type ของตัวแปรใน Python

ตอนที่ 2

• เรียนรู้เรื่อง Datetime และ String

ตอนที่ 3

• เราได้เรียนรู้เรื่อง คำสั่งเงื่อนไข IF , IF … Else และ เครื่องหมาย ตรรกศาสตร์ต่างๆ

ตอนที่ 4

• รู้จักกับ Loop

ตอนที่ 5

• เรียนรู้กับสิ่งที่เรียกว่า ฟังก์ชัน (Functions)

ตอนที่ 6

• ได้รู้จักกับ โครงสร้างข้อมูล (Data Structures)

ตอนที่ 7

• รับมือกับข้อผิดพลาด (handle errors)

ตอนที่ 8

• รู้จักการนำเข้าโค้ดจาก โมดูล หรือ แพ็กเกจ อื่น ๆ

ตอนที่ 9

• “การจัดการไฟล์” (File Handling)

นี่คือหัวใจหลักของ Python ที่จะทำให้คุณสามารถเขียนโปรแกรมพื้นฐานต่าง ๆ ได้อย่างมั่นใจครับ

การเดินทางต่อไปในโลก Python

การเรียนรู้โปรแกรมมิ่งเป็นกระบวนการที่ไม่สิ้นสุดครับ ยิ่งคุณฝึกฝนและเรียนรู้มากขึ้นเท่าไหร่ คุณก็จะยิ่งเก่งขึ้นเท่านั้น นี่คือแนวทางที่คุณสามารถเรียนรู้ Python ต่อไปได้ครับ:

1. ลงมือเขียนโค้ดเยอะ ๆ: “รู้” กับ “ทำได้” ไม่เหมือนกันครับ วิธีที่ดีที่สุดคือการลงมือเขียนโค้ดจริง ๆ ลองทำโจทย์ง่าย ๆ ในอินเทอร์เน็ต หรือลองสร้างโปรแกรมเล็ก ๆ ที่คุณสนใจ
2. เรียนรู้โครงสร้างข้อมูลเพิ่มเติม: Python ยังมีโครงสร้างข้อมูลอื่น ๆ ที่น่าสนใจ เช่น Dictionary (พจนานุกรม) และ Set (เซ็ต) ซึ่งมีประโยชน์มากในการจัดการข้อมูลประเภทต่าง ๆ ครับ
3. เรียนรู้เรื่อง “การเขียนโปรแกรมเชิงวัตถุ” (Object-Oriented Programming — OOP): นี่คือแนวคิดการเขียนโปรแกรมที่สำคัญมาก ๆ และใช้กันอย่างแพร่หลาย Python เป็นภาษาที่รองรับ OOP ได้ดีครับ
4. ศึกษาไลบรารีและเฟรมเวิร์กยอดนิยม:

• Data Science / Machine Learning: ถ้าสนใจสายข้อมูล ลองดู NumPy, Pandas, Matplotlib, Scikit-learn, TensorFlow, PyTorch
• Web Development: ถ้าอยากทำเว็บไซต์ ลองดู Django หรือ Flask
• Automation / Scripting: คุณจะพบว่า Python มีไลบรารีมากมายที่ช่วยทำงานอัตโนมัติได้เกือบทุกอย่างครับ
• Game Development: Pygame ก็เป็นตัวเลือกที่ดีสำหรับการเริ่มต้นครับ

5. เข้าร่วม Community: ค้นหากลุ่มคนรัก Python ทั้งบน Facebook, Discord, Stack Overflow หรือ Reddit ครับ การได้พูดคุย ถามคำถาม และช่วยเหลือผู้อื่น จะช่วยให้คุณพัฒนาเร็วขึ้นมาก

6. อ่านเอกสาร (Documentation): เอกสารทางการของ Python และของไลบรารีต่าง ๆ เป็นแหล่งข้อมูลที่ดีที่สุดครับ ลองฝึกอ่านและทำความเข้าใจดู

สุดท้ายนี้ ผมขอแสดงความยินดีกับคุณอีกครั้งนะครับที่ก้าวเข้ามาในโลกของ Python และอดทนเรียนรู้มาจนถึงตรงนี้ การเรียนรู้การเขียนโค้ดเป็นทักษะที่มีค่ามากในยุคปัจจุบัน และผมหวังว่าบทความนี้จะเป็นก้าวแรกที่มั่นคงในการเดินทางของคุณครับ

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

แล้วก็ยังไง ฝากกดติดตาม Fanpage : Mos Programmer เพื่อที่เราจะได้ออกเดินทางไปกับเนื้อหาความรู้ใหม่ๆด้วยกัน สำหรับบทความชุดนี้ก็มีเพียงเท่านี้ แล้วเจอกันใหม่กับบทความชุดถัดไปครับ

สวัสดีครับ ผมมอส เจ้าของ Fanpage : Mos Programmer ครับ ในบทความนี้ เราจะมาเรียนรู้โครงสร้างข้อมูลพื้นฐาน 2 ชนิดที่ใช้สำหรับจัดการข้อมูลเป็นชุดใน Go นั่นคือ Arrays และ Slices กันครับ

1. อาร์เรย์ (Array)

ลองนึกภาพ Array เหมือน “แผงไข่ไก่” ครับ มันถูกสร้างมาให้มีจำนวนช่องที่แน่นอน (เช่น 12 ช่อง) เราไม่สามารถยัดไข่ฟองที่ 13 เข้าไปได้ และไม่สามารถทำให้แผงเล็กลงเหลือ 10 ช่องได้

คุณสมบัติหลักของ Array:

• ขนาดคงที่ (Fixed-size): ขนาดของ Array จะถูกกำหนดตั้งแต่ตอนสร้างและไม่สามารถเปลี่ยนแปลงได้
• เก็บข้อมูลชนิดเดียวกัน (Homogeneous): สมาชิกทุกตัวใน Array ต้องเป็นข้อมูลชนิดเดียวกัน

การประกาศและใช้งาน Array
เราประกาศ Array โดยระบุขนาดไว้ในวงเล็บ []

package main

import "fmt"

func main() {
    // ประกาศ Array ชื่อ 'scores' เพื่อเก็บข้อมูลชนิด int จำนวน 3 ช่อง
    // ทุกช่องจะถูกกำหนดค่าเริ่มต้นเป็น 0 (Zero Value ของ int)
    var scores [3]int
    fmt.Println("Array เริ่มต้น:", scores) // ผลลัพธ์: [0 0 0]

    // กำหนดค่าให้สมาชิกแต่ละช่อง (Index เริ่มนับที่ 0)
    scores[0] = 85
    scores[1] = 92
    scores[2] = 78
    fmt.Println("หลังกำหนดค่า:", scores)       // ผลลัพธ์: [85 92 78]
    fmt.Println("คะแนนตัวแรก:", scores[0]) // ผลลัพธ์: 85

    // การประกาศพร้อมกำหนดค่าทันที
    // เราสามารถใช้ ... เพื่อให้ Go นับขนาดให้เองได้
    weekdays := [...]string{"จันทร์", "อังคาร", "พุธ", "พฤหัสบดี", "ศุกร์"}
    fmt.Println("จำนวนวันทำงาน:", len(weekdays)) // len() ใช้หาความยาว
}

สรุปสำหรับ Array: มีประโยชน์เมื่อคุณรู้จำนวนข้อมูลที่แน่นอนและมั่นใจว่าจะไม่เปลี่ยนแปลง แต่ในการใช้งานส่วนใหญ่ใน Go เรามักจะหันไปใช้สิ่งที่ยืดหยุ่นกว่า นั่นคือ “Slice”

2. สไลซ์ (Slice)

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

Slice คือ “ส่วนแสดงผล” ของ Array ที่ซ่อนอยู่เบื้องหลัง แต่มีกลไกที่ทำให้มันยืดหยุ่นและทรงพลังกว่ามาก

คุณสมบัติหลักของ Slice:

• ขนาดยืดหยุ่น (Dynamic-size): สามารถเพิ่ม (หรือลด) สมาชิกได้ตามต้องการ
• เป็นที่นิยมใช้งานสูง: เป็นวิธีมาตรฐานในการจัดการข้อมูลเป็นลำดับใน Go

การประกาศและใช้งาน Slice
การประกาศ Slice จะคล้ายกับ Array แต่เราจะ ไม่ระบุขนาด ในวงเล็บ []

package main

import "fmt"

func main() {
    // ประกาศ Slice ของ string (ค่าเริ่มต้นคือ nil หรือว่างเปล่า)
    var fruits []string
    fmt.Println("Fruits ตอนแรก:", fruits)

    // การเพิ่มข้อมูลใน Slice ทำได้ด้วยฟังก์ชัน append()
    // *** สำคัญมาก: append จะคืนค่าเป็น Slice ใหม่ เราต้องรับค่ากลับมาเสมอ ***
    fruits = append(fruits, "Apple")
    fruits = append(fruits, "Banana")
    fruits = append(fruits, "Mango")

    fmt.Println("Fruits ล่าสุด:", fruits)
    fmt.Println("ตอนนี้มีผลไม้:", len(fruits), "ชนิด") // ผลลัพธ์: 3

    // การประกาศพร้อมกำหนดค่าทันที (วิธีที่นิยม)
    vegetables := []string{"Carrot", "Cabbage", "Broccoli"}
    fmt.Println("ผักที่มี:", vegetables)
}

ความลับที่ทำให้ Slice ต่างจาก Array อยู่ตรงที่ ข้างใน Slice เองประกอบไปด้วย Array 1 ตัว และ มีสิ่งที่เรียกว่า Length และ Capacity คอยกำกับเอาไว้ ว่า Slice ของเราตอนนี้มีสมาชิกกี่ตัว และสามารถเก็บสมาชิกทั้งหมดได้กี่ตัว ซึ่งเราสามารถดูค่าได้ด้วยฟังก์ชัน len() และ cap()

มาทำความเข้าใจต่อว่า Length และ Capacity คืออะไร

Length (เรียกสั้นๆว่า len หรือ ความยาว)

len คือ จำนวนสมาชิกที่มีอยู่จริง ใน Slice ณ ปัจจุบัน ลองนึกภาพตาม ถ้าเรามีตะกร้าผลไม้ และตอนนี้เราใส่แอปเปิ้ลลงไป 3 ลูก len ของตะกร้าคือ 3

Capacity — cap ความจุ

cap คือ ขนาดของหน่วยความจำที่ Slice ได้จองไว้ ใน Array ที่ซ่อนอยู่เบื้องหลัง หรือพูดง่ายๆ คือ จำนวนสมาชิกสูงสุดที่ Slice สามารถมีได้ ก่อนที่ จะต้องไปหาหน่วยความจำใหม่ที่ใหญ่กว่าเดิม ลองนึกภาพตาม: ตะกร้าผลไม้ของเรา (Slice) อาจจะใส่ของได้สูงสุด 10 ลูก (นี่คือ cap) แต่ตอนนี้เราเพิ่งใส่ไปแค่ 3 ลูก (นี่คือ len) หมายความว่าเรายังสามารถใส่ผลไม้เพิ่มได้อีก 7 ลูก โดยไม่ต้องไปเปลี่ยนตะกร้าใบใหม่

คำแนะนำเพิ่มเติม : cap เกี่ยวข้องโดยตรงกับ ประสิทธิภาพ (Performance) ของโปรแกรม ถ้าหากว่าเรารู้อยู่แล้วว่า Slice ของเราจะมีสมาชิกประมาณ 1,000 ตัว การสร้าง Slice ด้วย make([]int, 0, 1000) จะเร็วกว่าการสร้าง Slice ว่างๆ แล้วปล่อยให้มันขยายขนาดเองหลายๆ ครั้งนั่นเองครับ

มาดูตัวอย่างการใช้งานดีกว่าครับ

package main

import "fmt"

func main() {
    // สร้าง Slice ด้วย make เพื่อกำหนด len และ cap เริ่มต้น
    // make([]string, 3, 5) หมายถึง:
    // - สร้าง Slice ของ string
    // - ให้มี length เริ่มต้น = 3
    // - ให้มี capacity เริ่มต้น = 5
    numbers := make([]int, 3, 5)

    fmt.Printf("เริ่มต้น -> len: %d, cap: %d, slice: %v\n", len(numbers), cap(numbers), numbers)
    fmt.Println("----------------------------------")

    // --- ลองเพิ่มข้อมูลเข้าไป ---
    // ตอนนี้ len = 3, cap = 5 ยังมีที่ว่างใน capacity
    fmt.Println("Append 1 ตัว...")
    numbers = append(numbers, 40)
    fmt.Printf("ผลลัพธ์ -> len: %d, cap: %d, slice: %v\n", len(numbers), cap(numbers), numbers)
    fmt.Println("สังเกต: len เพิ่ม แต่ cap เท่าเดิม เพราะยังอยู่ในความจุที่จองไว้")
    fmt.Println("----------------------------------")

    // --- เพิ่มอีก 1 ตัวจนเต็ม capacity ---
    fmt.Println("Append อีก 1 ตัว (จนเต็ม cap)...")
    numbers = append(numbers, 50)
    fmt.Printf("ผลลัพธ์ -> len: %d, cap: %d, slice: %v\n", len(numbers), cap(numbers), numbers)
    fmt.Println("สังเกต: ตอนนี้ len เท่ากับ cap แล้ว (5/5)")
    fmt.Println("----------------------------------")

    // --- จุดสำคัญ! เพิ่มข้อมูลอีก 1 ตัว เกิน capacity เดิม ---
    fmt.Println("Append ตัวที่ทำให้เกิน cap เดิม...")
    numbers = append(numbers, 60)
    fmt.Printf("ผลลัพธ์ -> len: %d, cap: %d, slice: %v\n", len(numbers), cap(numbers), numbers)
    fmt.Println("!!! สังเกต: Go ได้จองหน่วยความจำชุดใหม่ที่ใหญ่กว่าเดิมให้เราอัตโนมัติ !!!")
    fmt.Println("โดยทั่วไป cap ใหม่จะเพิ่มเป็นสองเท่าของ cap เดิม (5 -> 10)")
}

ผลลัพธ์

เริ่มต้น -> len: 3, cap: 5, slice: [0 0 0]
----------------------------------
Append 1 ตัว...
ผลลัพธ์ -> len: 4, cap: 5, slice: [0 0 0 40]
สังเกต: len เพิ่ม แต่ cap เท่าเดิม เพราะยังอยู่ในความจุที่จองไว้
----------------------------------
Append อีก 1 ตัว (จนเต็ม cap)...
ผลลัพธ์ -> len: 5, cap: 5, slice: [0 0 0 40 50]
สังเกต: ตอนนี้ len เท่ากับ cap แล้ว (5/5)
----------------------------------
Append ตัวที่ทำให้เกิน cap เดิม...
ผลลัพธ์ -> len: 6, cap: 10, slice: [0 0 0 40 50 60]
!!! สังเกต: Go ได้จองหน่วยความจำชุดใหม่ที่ใหญ่กว่าเดิมให้เราอัตโนมัติ !!!
โดยทั่วไป cap ใหม่จะเพิ่มเป็นสองเท่าของ cap เดิม (5 -> 10)

3. การ “ตัด” แบ่ง Slice (Slicing)

นี่คือความสามารถที่เป็นที่มาของชื่อ “Slice” เราสามารถ “ตัด” บางส่วนของ Slice (หรือ Array) เพื่อสร้าง Slice ใหม่ที่มองไปยังข้อมูลชุดเดิมได้

รูปแบบ: slice[low:high] (หมายถึง เอาตั้งแต่ index low ไปจนถึง ก่อน high)

package main

import "fmt"

func main() {
    numbers := []int{10, 20, 30, 40, 50}
    // Index:        0,  1,  2,  3,  4

    // เอาตั้งแต่ index 1 ถึงก่อน 4 (คือ index 1, 2, 3)
    middle := numbers[1:4]
    fmt.Println("Middle:", middle) // ผลลัพธ์: [20 30 40]

    // ละ low หมายถึง เริ่มจาก 0
    // เอาตั้งแต่เริ่มต้น ถึงก่อน index 2 (คือ index 0, 1)
    firstTwo := numbers[:2]
    fmt.Println("First two:", firstTwo) // ผลลัพธ์: [10 20]

    // ละ high หมายถึง ไปจนสุด
    // เอาตั้งแต่ index 3 ไปจนสุด
    lastTwo := numbers[3:]
    fmt.Println("Last two:", lastTwo) // ผลลัพธ์: [40 50]
}

4. Array vs. Slice: สรุปความแตกต่าง

กฎง่ายๆ สำหรับมือใหม่: เมื่อไม่แน่ใจว่าจะใช้อะไร ให้เลือกใช้ Slice เนื่องจากมีความยืดหยุ่นในการใช้งานสูงกกว่า Array นั่นเองครับ

ในตอนต่อไป เราจะมาทำความรู้จักกับ Structs และ Maps เพื่อจัดการกับข้อมูลที่มีโครงสร้างซับซ้อนกันครับ

สำหรับใครที่ติดปัญหา หรือมีข้อสงสัยเกี่ยวกับการเขียน Go ก็สามารถทักไปหาผมได้ที่ Fanpage : Mos Programmer ได้นะครับ

สุดท้ายนี้ถ้าเห็นว่าบทความนี้น่าสนใจก็ฝากเพื่อนๆ พี่ๆ น้องๆ ช่วยแชร์ บทความนี้ไปให้เพื่อนๆ หรือคนรู้จักด้วยนะครับ แล้วก็อย่าลืม กดไลค์ กดติดตาม Fanpage : Mos Programmer จะได้ไม่พลาดเนื้อหาดีๆ กันนะครับ