ฟังก์ชั่นที่สร้างขึ้นมาเอง

เป็นฟังก์ชั่นที่สร้างขึ้นมาเอง เพื่อให้ทำงานนอกเหนือจากฟังก์ชั่นที่มีอยู่ใน PHP หรือเราต้องการให้โปรแกรมทำงานตรงกับความต้องการของเรา รูปแบบการเขียนฟังก์ชั่นเป็นดังนี้

<?php     function ชื่อฟังก์ชั่น (ค่าที่ส่งให้) {         การทำงานของฟังก์ชั่น     } ?>

ลองดูตัวอย่างการสร้างฟังก์ชั่นชื่อ cmdevhub() กันครับ

<?php     function cmdevhub() {         echo "welcome to cmdevhub";     }     // เราสามารถเรียกฟังก์ชั่นได้โดยเรียกจากชื่อฟังก์ชั่น     cmdevhub(); // พิมพ์ welcome to cmdevhub ?>

เห็นไหมครับ ไม่ยากเลย ส่วนข้อกำหนดในการสร้างฟังก์ชั่นนั้นก็เหมือนกันการสร้างตัวแปรเลยครับ ถ้าหากจำไม่ได้ก็ย้อนกลับไปดูได้เลย

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

2.1 การส่งค่าโดยตรง

<?php     function cArea($r) {    // ฟังก์ชั่นหาพื้นที่วงกลม         echo $r * 22 / 7;     }     function sArea($h, $w) {    // ฟังก์ชั่นหาพื้นที่สี่เหลี่ยม         echo $h * $w;     }     cArea(15);  // ผลลัพท์ 47.1428571429     echo "<br />";     sArea(3, 15); // ผลลัพธ์ 45 ?>

เราสามารถส่งค่าไปให้ฟังก์ชั่นโดยใช้ค่าที่อยู่ในตัวแปรส่งไปได้ด้วย

<?php     function sArea($h, $w) {         echo $h * $w;     }     $width = 12;     $height = 3;     sArea($width, $height); ?>

ถ้าหากส่งค่าให้ฟังก์ชั่นมากเกินกว่าที่ฟังก์ชั่นรับไว้ ค่าที่เกินมา จะไม่ถูกนำไปใช้งาน แต่ถ้าหากส่งค่าไปไม่ครบจะเกิดข้อผิดพลาด Warning: Missing argument ตรงนี้ก็ระวังกันด้วยนะครับ

2.2 การส่งค่าอ้างอิงตำแหน่งตัวแปร

โดยปกติการส่งค่าให้ฟังก์ชั่นจะทำการส่งค่าของตัวแปรนั้นๆ เข้าไปยังฟังก์ชั่นเลย ถ้าหากต้องการผลลัพธ์ของการคำนวนก็ทำการคืนค่า (return) กลับมา แต่เราสามารถเขียนให้ง่ายกว่านั้นได้อีก โดยการส่งตำแหน่ง (address) ของตัวแปรนั้นเข้าไปยังฟังก์ชั่นแทน ก็สามารถทำการคำนวนและเปลี่ยนค่าของตัวแปรที่เราต้องการได้โดยไม่ต้องทำการคืนค่ากลับออกมา ตัวอย่างที่ผมใช้บ่อยและใช้ตลอดก็คือการคำนวนภาษี (ยังหาโปรแกรมอื่นๆ ที่ใช้ฟังก์ชั่นแบบนี้ไม่ได้เลย) ลองดูตัวอย่างกันครับ

<?php     function cal_tax(&$cost, $tax) {         $cost += $cost * $tax;     }     $cost = 200;     $tax = 0.07;     echo "จำนวนเงินก่อนคำนวนภาษี " . $cost; // ผลลัพธ์ 200     echo "<br />";     cal_tax($cost, $tax);     echo "จำนวนเงินหลังคำนวนภาษี " . $cost; // ผลลัพธ์ 214 ?>

จะเ้ห็นว่า เราสามารถเปลี่ยนตัวแปร $cost โดยไม่ต้องทำการคืนค่าในฟังก์ชั่นเลย จริงๆ แล้ว ตัวอย่างด้านบนสามารถเขียนได้อีกแบบดังนี้

<?php     function cal_tax($cost, $tax) {         $cost += $cost * $tax;         return $cost;     }     $cost = 200;     $tax = 0.07;     echo "จำนวนเงินก่อนคำนวนภาษี " . $cost;     echo "<br />";     $cost = cal_tax($cost, $tax);     echo "จำนวนเงินหลังคำนวนภาษี " . $cost; ?>

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

2.3 การกำหนดค่าเริ่มต้นให้ฟังก์ชั่น

ในการสร้างฟังก์ชั่นที่ทำการรับค่านั้น เราจำเป็นที่จะต้องส่งค่าให้กับฟังก์ชั่นนั้นๆ จนครบตามจำนวนที่กำหนดไว้ ถ้าหากส่งค่าไม่ครบจะเกิดข้อผิด Warning: Missing argument ขึ้น หรือ ถ้าเราต้องการสร้างฟังก์ชั่นที่เรารู้ค่าที่ใช้คำนวณอยู่แล้ว เช่นฟังก์ชั่นที่คิดภาษีที่เรารู้อยู่แล้วว่าต้องคิดที่ 7% แต่ต้องการให้สามารถเปลี่ยนค่าได้โดยที่ไม่ต้องแก้ไขฟังก์ชั่นใหม่ ก็สามารถทำการกำหนดค่าเริ่มต้นขึ้นมาได้เลย ลองดูตัวอย่างกัน

<?php     function cal_tax(&$cost, $tax = 0.07) {         $cost += $cost * $tax;     }     $cost = $cost1 = 200;     echo "จำนวนเงินก่อนคำนวนภาษี " . $cost;     echo "<br />";     cal_tax($cost);     echo "จำนวนเงินหลังคำนวณภาษี " . $cost;     echo "<hr />";     echo "คิดภาษีที่ 10%";     echo "<br />";     echo "จำนวนเงินก่อนคำนวณภาษี " . $cost1;     echo "<br />";     cal_tax($cost1, 0.1);     echo "จำนวนเงินหลังคำนวณภาษี " . $cost1;     echo "<br />"; ?>

จากตัวอย่าง ทำการผสมผสานกันระหว่างการเรียกฟังก์ชั่นโดยใช้อ้างอิงตำแหน่งตัวแปร กับการกำหนดค่าเริ่มต้นให้ฟังก์ชั่น จะเห็นได้ว่า เราเรียกฟังก์ชั่นครั้งแรกโดยไม่ส่งค่าไปแค่ตัวเดียวคือตำแหน่งของตัวแปร $cost เราได้ทำการกำหนดค่าเริ่มต้นให้ตัวแปร $tax แล้วทำให้ตัวแปร $tax มีค่า 0.07 ตามที่เรากำหนดไว้ แต่พอเรียกครั้งที่สองเราได้ส่งค่า 0.1 ให้กับตัวแปร $tax ด้วย ทำให้ค่าของตัวแปร $tax ถูกเปลี่ยนจาก 0.07 เป็น 0.1 แทน

2.4 การคืนค่าของฟังก์ชั่น

ในการสร้างฟังก์ชั่นขึ้นมาใช้งานนั้น ถ้าหากไม่มีการส่งค่ากลับคืนมาเมื่อทำงานเสร็จ ฟังก์ชั้นนั้นก็แทบจะไม่มีประโยชน์อะไรเลย เนื่องจากไม่สามารถนำค่าที่ฟังก์ชั่นคำนวนได้กลับมาใช้งาน การคืนค่าของฟังก์ชั่น สามารถทำได้โดยใช้คำสั่ง return โดยสามารถคืนค่าจากผลลัพธ์การคำนวณได้หนึ่งค่า หรือถ้าต้องการคืนหลายๆ ค่าพร้อมกัน สามารถใช้ตัวแปรแบบ array หรือ list ก็ได้ ลองดูตัวอย่างกันครับ

การคืนค่าหนึ่งค่า

<?php     function cal_tax($cost, $tax = 0.07) {         $cost += $cost * $tax;         return $cost;     }     $cost = 200;     echo "ค่าก่อนคำนวนภาษี " . $cost;     $cost = cal_tax($cost);     echo "<br />";     echo "ค่าหลังคำนวนภาษี " . $cost; ?>

การเรียกใช้งานฟังก์ชั่นที่มีการคืนค่านั้น จำเป็นต้องมีตัวแปร หรือคำสั่งใดๆ รองรับการคืนค่านั้นๆ ไม่เช่นนั้นแล้ว ค่าที่คืนกลับมา ก็ไม่สามารถนำไปใช้งานใดๆ ได้เลย

การคืนค่าหลายค่า

การคืนค่าหลายๆ นั้น ต้องทำให้ตัวแปรนั้นเป็น array ก่อน โดยจะสร้างให้ตัวแปรนั้นเป็น array หรือใช้คำสั่ง list() ในการรับค่าก็ได้ ตัวอย่างการใช้ฟังก์ชั่น list()

<?php     $color = array('red', 'green',' blue');     list($red, $green, $blue) = $color;     // ตัวแปร $red เก็บค่า red, $green เก็บค่า green, $blue เก็บค่า blue ?>

ตัวอย่างการใช้งานฟังก์ชั่นที่คืนค่าแบบ array

<?php     function user() {         $name[] = "POP EYE";         $name[] = "shikimasan[a]gmail[dot]com";         $name[] = "www.cmdevhub.com";         return $name;     }     // รับค่าโดยใช้ฟังก์ชั่น list ต้องทำการสร้างตัวแปรรับค่าให้ตรงกับค่าที่คืนกลับมา     list($name, $email, $web) = user();     // รับค่าโดยใช้ตัวแปร ทำให้ตัวแปรนั้นถูกเปลี่ยนเป็นแบบ array โดยอัตโนมัติ     $name = user();     // การอ้างอิงค่าต้องทำการอ้างอิงจาก index ของ array โดยตรง     echo $name[0];     echo $name[1]; ?>

จากตัวอย่างจะเห็นได้ว่าเราสามารถรับค่าจากฟังก์ชั่นที่คืนค่าเป็น array ได้ทั้ง 2 แบบ แต่ในการใช้งานจริงๆ จะใช้ฟังก์ชั่น list() รับค่ามากกว่า เพราะต้องกำหนดตัวแปรให้กับค่าที่คืนมาแต่ละค่า ซึ่งจะสื่อความหมายมากกว่ารับค่าโดยใช้ตัวแปรและอ้างอิงโดยใช้หมายเลข index อ้างอิง

2.5 ฟังก์ชั่นซ้อนฟังก์ชั้น (Nesting Function)

ในภาษา PHP เราสามารถสร้างฟังก์ชั่นขึ้นมาภายในฟังก์ชั่นอีกทีได้ แบบตัวอย่าง

<?php     function cal_tax ($price, $tax) {         function cal_vat ($total) {             return $total * 0.07;         }         $price += $price * $tax;         echo "จำนวนเงินทั้งหมดหลังรวมภาษี " . $price . " หลังรวมภาษีมูลค่าเพิ่ม " . ($price + cal_vat($price));     }     cal_tax(1500, 0.1); // ผลลัพธ์ 1650 , 1765.5     echo "<br />";     echo cal_vat(100);  // ผลลัพธ์ 7 ?>

Nesting Function ของภาษา PHP ไม่มีการกำหนดระดับของการเข้าถึง (scope) ทำให้ไม่ว่าจะเขียนฟังก์ชั่นไว้ที่ไหน ก็สามารถเรียกใช้ได้ การเขียนแบบนี้ ไม่ค่อยได้ใช้ในชีวิตจริงเท่าไหร่ แต่ก็ให้รู้ไว้ว่าเราสามารถสร้างฟังก์ชั่นแบบนี้ได้ เผื่อเอาไปสอบ CERT นะครับ

2.6 ฟังก์ชั่นเรียกตัวเอง (Recursive Function)

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

<?php     function fibo($num) {         if ($num == 1 || $num == 2) {             return 1;         }         else {             return fibo($num - 1) + fibo($num - 2);         }     }     echo fibo(20); ?>

ตัวอย่างแรกเป็นตัวเลข Fibonacci การใช้งานคือ เรียกฟังก์ชั่น fibo() แล้วใส่ตัวเลขตำแหน่งหลักที่ต้องการเข้าไปเช่น fibo(20) หมายถึงตัวเลข fibonacci ในตำแหน่งที่ 20

<?php     function fac($num) {         if ($num == 0 || $num == 1) {             return 1;         }         else {             return fac($num - 1) * $num;         }     }     echo fac(5); ?>

ตัวอย่างที่สองเป็นตัวเลข Factorial หรือ n! การทำงานก็คล้ายๆ กับ fibonacci แต่ผลลัพธ์ที่ได้จะเป็นค่าของ n! เลย

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