recursive function คืออะไร การใช้งาน recursive function ในภาษา JavaScript แบบง่ายๆ พร้อมตัวอย่าง

บทความ: ความงดงามของ Recursive Function และการต่อยอดความรู้ด้วยภาษา JavaScript

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

Recursive Function คืออะไร

Recursive Function หรือฟังก์ชันเรียกใช้ตัวเองนั้น เป็นฟังก์ชันที่สามารถเรียกใช้ตัวเองได้จากภายในโค้ดของมันเอง นี่คือหัวใจหลักของความคิดวิธีการแบบ recursion ในการเขียนโปรแกรม ซึ่งแทนที่จะมีการใช้ลูป (loops) เช่น for หรือ while เพื่อทำซ้ำการคำนวณหรือการจัดการข้อมูล เราสามารถเรียกฟังก์ชันเดียวกันเพื่อทำงานคล้ายกันจนกว่าจะถึงเงื่อนไขหยุด (base case) ซึ่งจะทำให้โปรแกรมหยุดการเรียกฟังก์ชันเพิ่มเติม วิธีนี้สามารถช่วยให้โค้ดที่ซับซ้อนกลายเป็นสิ่งที่เข้าใจและจัดการได้ง่ายขึ้น

การใช้งาน Recursive Function ในภาษา JavaScript

เพื่อให้เห็นภาพชัดขึ้น มาดูตัวอย่างของฟังก์ชันที่ทำการคำนวณ factorial กันดีกว่า:

function factorial(n) {
  if (n === 0) { // เงื่อนไขหยุด (base case)
    return 1;
  } else {
    return n * factorial(n - 1); // เรียกใช้ตัวเอง
  }
}

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

ในโค้ดข้างต้น เราเห็นว่า `factorial(5)` จะเรียกใช้ `factorial(4)` เพื่อคำนวณ 5 * 4 และไปเรียกใช้ `factorial(3)`, `factorial(2)`, `factorial(1)` และสุดท้ายคือ `factorial(0)` ซึ่งทำหน้าที่เป็นเงื่อนไขหยุด คืนค่า 1 กลับไป

Usecase ในโลกจริงของ Recursive Function

Usecase 1: จัดการ Structure แบบ Hierarchical

หนึ่งในเคสที่มักใช้ recursion คือการจัดการกับข้อมูลที่มีโครงสร้างแบบลำดับชั้น (hierarchical) เช่น เมนูที่มีหลายระดับของเว็บไซต์ หรือจัดการกับ DOM ที่มี element ซ้อนกันหลายชั้น

function walkDOM(node, func) {
  func(node);
  node = node.firstElementChild;
  while (node) {
    walkDOM(node, func);
    node = node.nextElementSibling;
  }
}

walkDOM(document.body, function(node) {
  console.log(node);
});

Usecase 2: การค้นหาทางลัดในเกมหรือกราฟ

การใช้ recursive function ในการค้นหาทางลัดในเกมหรือกราฟ (path finding) เป็นเรื่องธรรมดา เพราะเราสามารถค้นหาหนทางทุกสายจนกว่าจะถึงจุดหมาย หรือเจอทางตัน

function findPath(maze, x, y, path) {
  if (x < 0 || y < 0 || x >= maze.length || y >= maze[x].length) {
    return false; // ไม่สามารถเดินได้
  }
  if (maze[x][y] === 'GOAL') {
    path.push([x, y]);
    return true; // เจอปลายทาง
  }
  if (maze[x][y] !== 'OPEN') {
    return false; // ไม่สามารถเดินไปต่อได้
  }

  // ทำเครื่องหมายว่าเป็นทางที่ได้เดินผ่านแล้ว
  maze[x][y] = 'VISITED';
  path.push([x, y]);

  // เดินทางต่อไปในทุกทิศทาง
  if (findPath(maze, x-1, y, path) || // ไปทางซ้าย
      findPath(maze, x+1, y, path) || // ไปทางขวา
      findPath(maze, x, y-1, path) || // ไปทางบน
      findPath(maze, x, y+1, path)) { // ไปทางล่าง
    return true;
  }

  // ถ้าไม่เจอทางไปย้อนกลับไปยัง path ก่อนหน้า
  path.pop();
  maze[x][y] = 'OPEN';
  return false;
}

การเรียนรู้เกี่ยวกับ recursive function เปิดประตูสู่โลกที่มีความเข้าใจในการจัดการปัญหาที่ซับซ้อนและการเลือกใช้วิธีแก้ไขที่เหมาะสม ที่ EPT เราเต็มใจและพร้อมที่จะนำทุกท่านเข้าสู่โลกแห่งการเรียนรู้การเขียนโปรแกรมด้วยมุมมองที่ไม่เคยมีมาก่อน ทักทายเข้ามาสิคะ เราจะก้าวไปด้วยกัน 🙂

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

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