การค้นหาข้อมูล (Searching) คือหนึ่งในกระบวนการพื้นฐานของทุกระบบ ไม่ว่าจะเป็น

• การค้นหาผู้ใช้ในฐานข้อมูล
• การค้นหาสินค้าในร้านค้าออนไลน์
• หรือการค้นหาคำในเอกสาร

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

ในบทความนี้ เราจะเปรียบเทียบการทำงานของ Searching Algorithms ระหว่าง JavaScript และ Go
ผ่าน 3 เทคนิคหลัก ได้แก่

1️⃣ Linear Search (ค้นหาแบบเส้นตรง)
2️⃣ Binary Search (ค้นหาแบบแบ่งครึ่ง)
3️⃣ Map-based Lookup (ค้นหาแบบ Key-Value)

พร้อมแนวทางการเลือกใช้ให้เหมาะสมกับระบบจริง 🚀

1. Linear Search — ค้นหาแบบเส้นตรง

หลักการ:
วนลูปตรวจสอบแต่ละค่าทีละตัวไปเรื่อย ๆ จนกว่าจะพบข้อมูลที่ตรงกับเป้าหมาย

🔹 JavaScript: Linear Search

function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) return i;
  }
  return -1;
}

const nums = [10, 25, 30, 45, 60];
console.log(linearSearch(nums, 30));  // Output: 2
console.log(linearSearch(nums, 99));  // Output: -1

🔹 Go: Linear Search

package main

import "fmt"

func linearSearch(arr []int, target int) int {
	for i, v := range arr {
		if v == target {
			return i
		}
	}
	return -1
}

func main() {
	nums := []int{10, 25, 30, 45, 60}
	fmt.Println(linearSearch(nums, 30)) // Output: 2
	fmt.Println(linearSearch(nums, 99)) // Output: -1
}

สรุป:
✅ เข้าใจง่าย ใช้งานได้กับข้อมูลทุกประเภท
❌ ช้าเมื่อต้องค้นหาในข้อมูลจำนวนมาก
Complexity: O(n)

2. Binary Search — ค้นหาแบบแบ่งครึ่ง

หลักการ:
ใช้ได้เฉพาะกับข้อมูลที่ “เรียงลำดับแล้ว” เท่านั้น โดยจะทำการ “แบ่งครึ่ง” ขอบเขตการค้นหาในแต่ละรอบ เพื่อลดจำนวนครั้งในการตรวจสอบ

🔹 JavaScript: Binary Search

function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;

  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) return mid;
    if (arr[mid] < target) left = mid + 1;
    else right = mid - 1;
  }

  return -1;
}

const sorted = [10, 25, 30, 45, 60];
console.log(binarySearch(sorted, 45)); // Output: 3

🔹 Go: Binary Search

package main

import "fmt"

func binarySearch(arr []int, target int) int {
	left, right := 0, len(arr)-1
	for left <= right {
		mid := (left + right) / 2
		if arr[mid] == target {
			return mid
		}
		if arr[mid] < target {
			left = mid + 1
		} else {
			right = mid - 1
		}
	}
	return -1
}

func main() {
	sorted := []int{10, 25, 30, 45, 60}
	fmt.Println(binarySearch(sorted, 45)) // Output: 3
}

สรุป:
✅ ทำงานรวดเร็วมากหากข้อมูล “เรียงลำดับแล้ว”
❌ ใช้ไม่ได้กับข้อมูลที่ยังไม่เรียงลำดับ
Complexity: O(log n)

3. Map-based Lookup — การค้นหาแบบ Key-Value

หลักการ:
แทนที่จะค้นหาทีละตัว ระบบจะเก็บข้อมูลในรูปแบบ Key → Value เมื่อค้นหา สามารถเข้าถึงข้อมูลได้โดยตรงในเวลา O(1)

🔹 JavaScript: Using Map

const userMap = new Map();
userMap.set("john", { age: 25 });
userMap.set("jane", { age: 30 });

console.log(userMap.get("john"));  // { age: 25 }
console.log(userMap.has("alice")); // false

🔹 Go: Using map

package main

import "fmt"

func main() {
	users := map[string]int{
		"john": 25,
		"jane": 30,
	}

	if age, exists := users["john"]; exists {
		fmt.Println("John:", age)
	} else {
		fmt.Println("Not found")
	}
}

สรุป:
✅ เร็วที่สุด (O(1))
✅ เหมาะกับระบบที่มีการค้นหาบ่อย เช่น cache, user lookup, หรือ routing
❌ ใช้หน่วยความจำมากกว่าเล็กน้อย

4. สรุปเปรียบเทียบ Searching Algorithms

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

🧭 Linear Search → ใช้ในกรณีข้อมูลมีขนาดเล็ก หรือไม่เรียงลำดับ
⚡ Binary Search → ใช้กับข้อมูลที่เรียงแล้ว เช่น การค้นหาหมายเลข หรือสินค้า
🚀 Map-based Lookup → เหมาะกับระบบที่ต้องค้นหาบ่อย เช่น

• Session Management
• API Caching
• User Storage

ตัวอย่างการใช้งานจริง:

• ระบบ Login → ใช้ Map-based Lookup (username → user info)
• ระบบค้นหาแบบ Autocomplete → ใช้ Binary Search
• ระบบสอนหรือจำลอง Algorithm → ใช้ Linear Search

สรุป

การเลือกใช้ Searching Algorithm ที่เหมาะสมสามารถเพิ่มประสิทธิภาพของระบบได้มหาศาล โดยเฉพาะเมื่อปริมาณข้อมูลมีขนาดใหญ่ขึ้น

• 💻 JavaScript → เหมาะกับการเรียนรู้ algorithm และการประยุกต์ใช้งานฝั่ง frontend
• ⚙️ Go → เหมาะกับระบบ production-level ที่ต้องการความเร็วและการจัดการหน่วยความจำอย่างมีประสิทธิภาพ

ตอนต่อไป

ใน EP.37 ของซีรีส์ JS2GO เราจะพาคุณไปเรียนรู้เรื่อง Recursion และ Iteration ใน JavaScript และ Go เพื่อเปรียบเทียบแนวทางการเขียนโค้ดแบบ การเรียกซ้ำ (Recursion) และ การวนซ้ำ (Iteration) ว่าภาษาใดทำได้ดีกว่าในแง่ของ Performance และ Readability 🧠

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

• Golang The Series
• JS2GO
• 10 Ep ที่จะให้คุณเป็นมือโปร Tailwind CSS ในชั่วข้ามคืน

🔵 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/