ทุกโปรแกรมเมอร์ต้องเคยเจอกับงานที่ต้องทำซ้ำ เช่น

การหาผลรวมของตัวเลข
การคำนวณค่า Factorial
หรือการสร้างลำดับ Fibonacci

โดยทั่วไปแล้วจะมีอยู่ 2 วิธีในการทำงานซ้ำ:

Recursion (การเรียกซ้ำ) — ฟังก์ชันเรียกตัวเองซ้ำ ๆ
Iteration (การวนซ้ำ) — ใช้ลูป เช่น for หรือ while เพื่อทำงานซ้ำ

แม้ทั้งสองวิธีให้ผลลัพธ์เหมือนกัน แต่ต่างกันในด้าน ประสิทธิภาพ (performance), การใช้หน่วยความจำ (memory usage) และ ความเข้าใจง่ายของโค้ด (readability)

มาดูกันว่า JavaScript และ Go จัดการแนวทางทั้งสองแบบนี้แตกต่างกันอย่างไร 👇

1. Recursion — การเรียกซ้ำ (Function Calling Itself)

🔹 JavaScript: Recursion

function factorial(n) {
  if (n === 0) return 1;
  return n * factorial(n - 1);
}

console.log(factorial(5)); // Output: 120

อธิบาย:
factorial(5) จะเรียกตัวเองซ้ำเรื่อย ๆ จนถึง factorial(0)
จากนั้นค่าจะถูกส่งกลับและคูณย้อนขึ้นมาทีละชั้น

ข้อดี:
✅ โค้ดอ่านง่าย และเข้าใจแนวคิดทางคณิตศาสตร์ได้ตรงไปตรงมา
✅ เหมาะกับปัญหาที่มีลักษณะ “ซ้ำซ้อนแบบลดลง” เช่น การไล่โครงสร้างต้นไม้ (Tree Traversal)

ข้อเสีย:
❌ ใช้หน่วยความจำใน Stack มาก → เสี่ยงเกิด “Stack Overflow” หาก recursion ลึกเกินไป
❌ ช้ากว่า iteration ในงานที่ต้องเรียกซ้ำจำนวนมาก

🔹 Go: Recursion

package main

import "fmt"

func factorial(n int) int {
	if n == 0 {
		return 1
	}
	return n * factorial(n-1)
}

func main() {
	fmt.Println(factorial(5)) // Output: 120
}

อธิบาย:
ทำงานแบบเดียวกับ JavaScript แต่ Go จัดการ Stack ได้มีประสิทธิภาพมากกว่าเล็กน้อย
เพราะ Go compiler บางเวอร์ชันมีการ “optimize” การเรียกซ้ำในบางกรณี (Tail Recursion Optimization)

สรุป:
Recursion ใน Go เหมาะกับงานที่ต้องแยกย่อยซ้ำ ๆ เช่น

Tree Traversal
Depth-First Search (DFS)
Recursive Parsing

2. Iteration — การวนซ้ำ (Using Loops)

🔹 JavaScript: Iteration

function factorialIterative(n) {
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

console.log(factorialIterative(5)); // Output: 120

ข้อดี:
✅ ใช้หน่วยความจำ (stack) น้อยกว่า recursion
✅ เร็วกว่าในกรณีที่ต้องทำงานซ้ำจำนวนมาก

ข้อเสีย:
❌ โค้ดอาจยาวและซับซ้อนกว่า recursion เล็กน้อย
❌ ไม่เหมาะกับปัญหาที่มีโครงสร้าง recursive โดยธรรมชาติ เช่น Tree หรือ Graph

🔹 Go: Iteration

package main

import "fmt"

func factorialIterative(n int) int {
	result := 1
	for i := 1; i <= n; i++ {
		result *= i
	}
	return result
}

func main() {
	fmt.Println(factorialIterative(5)) // Output: 120
}

ข้อดี:
✅ ประสิทธิภาพสูง เหมาะกับระบบ Production
✅ ใช้หน่วยความจำน้อย
✅ Go compiler สามารถ optimize loop ได้อย่างมีประสิทธิภาพ

3. การเปรียบเทียบ Recursion และ Iteration

คุณสมบัติ	Recursion	Iteration
แนวคิด	ฟังก์ชันเรียกตัวเอง	ใช้ลูปทำงานซ้ำ
Readability	อ่านง่ายในปัญหาที่ซับซ้อน	เข้าใจง่ายในงานทั่วไป
Performance	ช้ากว่าเล็กน้อย	เร็วกว่ามาก
Memory Usage	ใช้ Stack มาก	ใช้หน่วยความจำน้อย
เหมาะกับ	Tree, Graph, Divide & Conquer	Loop, Counting, Accumulation

4. ตัวอย่างการใช้งานจริง — Tree Traversal (DFS)

🔹 JavaScript: Recursive Tree Traversal

const tree = {
  value: 1,
  children: [{ value: 2 }, { value: 3, children: [{ value: 4 }] }]
};

function traverse(node) {
  console.log(node.value);
  if (node.children) {
    node.children.forEach(traverse);
  }
}

traverse(tree);

🔹 Go: Recursive Tree Traversal

package main

import "fmt"

type Node struct {
	Value    int
	Children []*Node
}

func traverse(n *Node) {
	fmt.Println(n.Value)
	for _, child := range n.Children {
		traverse(child)
	}
}

func main() {
	tree := &Node{
		Value: 1,
		Children: []*Node{
			{Value: 2},
			{Value: 3, Children: []*Node{{Value: 4}}},
		},
	}
	traverse(tree)
}

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

5. แนวทางการเลือกใช้

🧠 ใช้ Recursion เหมาะกับปัญหาที่มีโครงสร้างซ้ำซ้อน เช่น

Tree / Graph Traversal
Divide & Conquer (เช่น Merge Sort, Quick Sort)

⚙️ ใช้ Iteration เหมาะกับงานทั่วไป เช่น

Loop, Counting, Summation
โดยเฉพาะในระบบ Production ที่ต้องการความเร็วและความเสถียร

💡 ใน Go: การวนซ้ำ (Iteration) ถูก optimize ดีกว่าการเรียกซ้ำ

💻 ใน JavaScript: Recursion เหมาะกับการสอนแนวคิดและการจำลอง algorithm แต่ในระบบจริง Iteration มักเสถียรกว่า

สรุป

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

สถานการณ์	วิธีที่เหมาะสม
ปัญหา Tree / Graph	🧠 Recursion
งานทั่วไป / การวนซ้ำ	⚙️ Iteration
เน้น Performance	⚡ Iteration (โดยเฉพาะใน Go)
เน้นความเข้าใจง่าย	💡 Recursion

ตอนต่อไป

ใน EP.38 ของซีรีส์ JS2GO
เราจะพาคุณไปเรียนรู้ การจัดการ Buffer และ Stream ใน Node.js และ Go เพื่อเข้าใจการทำงานกับข้อมูลขนาดใหญ่ เช่น การอ่านไฟล์, การส่งข้อมูลผ่านเครือข่าย (Network), และการจัดการ Memory อย่างมีประสิทธิภาพในระบบ Production ⚙️

อ่านบทความ Series อื่นๆ

🔵 Facebook: https://www.facebook.com/superdev.academy.th

🔴 YouTube : Superdev Academy

📸 Instagram: Superdev Academy

🎬 TikTok: https://www.tiktok.com/@superdevacademy?lang=th-TH

🌐 Website: https://www.superdevacademy.com/