Function ในภาษา PHP มาอยู่ 4 ชนิดคือ
1. ฟังก์ชั่นภายใน (invoking
a function)
2. ฟังก์ชั่นที่สร้างขึ้นมาเอง (creating
a function)
3. ฟังก์ชั่นซ้อนฟังก์ชั่น (nesting
function)
4. ฟังก์ชั่นเรียกตัวเอง (recursive
function)
1. ฟังก์ชั่นภายใน
เป็นฟังก์ชั่นพื้นฐานที่มากับ php
(ชื่อก็บอกอยู่แล้ว) มีราวๆ พันกว่าฟังก์ชั่น (ใครเคยนับบ้างเนี่ย)
ซึ่งจะครอบคลุมการทำงานพื้นฐานทั้งหมดของการเขียนโปรแกรม PHP จนบางครั้ง
เราสามารถเขียนโปรแกรมที่ทำงานได้จริงโดยไม่จำเป็นต้องเขียนฟังก์ชั่นเพิ่มเติมเลยแม้แต่ฟังก์ชั่นเดียว
เหมือนที่ผมเคยได้ยินมาว่า “คนที่เขียนโปรแกรมเก่ง
ไม่จำเป็นต้องเขียนโค๊ดได้ดี เพียงแค่รู้จักฟังก์ชั่น แล้วรู้จักใช้มันก็พอ”
ฟังก์ชั่นภายในทั้งหลาย สามารถดูได้จาก help
ของ PHP ได้ โดยโหลดได้ที่ http://www.php.net/docs.php
ตัวอย่างฟังก์ชั่นภายใน ผมขอยกตัวอย่างฟังก์ชั่น pow()
ถ้าหากเปิดดู help จะเขียนเป็นลักษณะนี้
number pow ( number $base, number $exp )
·
number คือ
ค่าที่ฟังก์ชั่นนี้ส่งกลับออกมา (return) ซึ่งเดี๋ยวเราค่อยมาอธิบายกัน
·
pow คือ ชื่อฟังก์ชั่น
·
(number $base, number $exp) คือ
ค่าที่ต้องส่งให้ฟังก์ชั่นนี้ โดย number หมายถึงชนิดของค่า
(datatype) ที่ต้องส่งไปให้
เพราะฉะนั้น ฟังก์ชั่น pow()
เราต้องส่งค่าให้จำนวน 2 ค่า
เมื่อฟังก์ขั่นทำงานเสร็จแล้วจะคืนค่ากลับมาเป็นชนิดตัวเลข
|
1
2
3
4
|
<?php
$value = pow(5,2); // เรียกฟังก์ชั่น pow() โดยส่งค่า 5 เป็นเลขฐาน และ 2 เป็นเลขชี้กำลัง
แล้วเก็บค่าไว้ที่ตัวแปร $value
echo $value; // พิมพ์ค่าจากตัวแปร $value
?>
|
ถ้าหากเราไม่ได้นำค่าที่ได้ไปทำการคำนวน
เราสามารถแสดงค่าออกมาได้เลย โดยไม่จำเป็นต้องเก็บค่าไว้ในตัวแปรใดๆ
ลองดูตัวอย่างกันครับ
|
1
2
3
4
5
|
<?php
echo pow(5,2); // พิมพ์ค่า
5 ยกกำลัง 2 ออกทางหน้าจอเลย
echo "<br />";
echo "ผลลัพท์ของ 5
ยกกำลัง 2 คือ " . pow(5,2);
?>
|
เห็นไหมครับ ไม่ยากเลย
แต่เราจะรู้ได้อย่างไรว่าฟังก์ชั่นไหน ใช้งานอย่างไร
หรือเราจะใช้ฟังก์ชั่นไหนทำงานให้เรา อันนี้ก็ต้องอยู่ที่แต่ละท่านล่ะครับ ถ้าหากเล่นบ่อยๆ
ก็จะพบกับฟังก์ชั่นที่เรายังไม่เคยใช้งานเองแหละครับ ถึงแม้ว่า PHP
จะมีฟังก์ชั่นมากกว่า 1000 ฟังก์ชั่น
แต่ที่ใช้งานทั่วๆ ไป จะมีไม่ถึง 200 ฟังก์ชั่นครับ
(ลดไปเยอะเลย)
2.ฟังก์ชั่นที่สร้างขึ้นมาเอง
เป็นฟังก์ชั่นที่สร้างขึ้นมาเอง เพื่อให้ทำงานนอกเหนือจากฟังก์ชั่นที่มีอยู่ใน
PHP หรือเราต้องการให้โปรแกรมทำงานตรงกับความต้องการของเรา
รูปแบบการเขียนฟังก์ชั่นเป็นดังนี้
|
1
2
3
4
5
|
<?php
function ชื่อฟังก์ชั่น
(ค่าที่ส่งให้) {
การทำงานของฟังก์ชั่น
}
?>
|
ลองดูตัวอย่างการสร้างฟังก์ชั่นชื่อ cmdevhub()
กันครับ
|
1
2
3
4
5
6
7
8
9
|
<?php
function cmdevhub() {
echo
"welcome to cmdevhub";
}
// เราสามารถเรียกฟังก์ชั่นได้โดยเรียกจากชื่อฟังก์ชั่น
cmdevhub(); // พิมพ์ welcome
to cmdevhub
?>
|
เห็นไหมครับ ไม่ยากเลย
ส่วนข้อกำหนดในการสร้างฟังก์ชั่นนั้นก็เหมือนกันการสร้างตัวแปรเลยครับ
ถ้าหากจำไม่ได้ก็ย้อนกลับไปดูได้เลย
หลังจากเราสร้างฟังก์ชั่นได้แล้ว
ฟังก์ชั่นของเราจะไม่มีประโยชน์อะไรเลยถ้าหากไม่สามารถรับค่าเพื่อใช้คำนวนตามที่เราต้องการได้
การส่งค่าให้ฟังก์ชั่นทำการคำนวนนั้นมี 2
รูปแบบคือ ส่งค่าไปตรงๆ เลย และ ส่งค่าอ้างอิงตำแหน่งของตัวแปร ส่วนวิธีการรับค่าของฟังก์ชั่นทำได้โดยใส่ตัวแปรเข้าไปใน ( )
มาดูตัวอย่างกัน
2.1 การส่งค่าโดยตรง
|
1
2
3
4
5
6
7
8
9
10
11
12
|
<?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
?>
|
เราสามารถส่งค่าไปให้ฟังก์ชั่นโดยใช้ค่าที่อยู่ในตัวแปรส่งไปได้ด้วย
|
1
2
3
4
5
6
7
8
9
|
<?php
function sArea($h, $w) {
echo $h * $w;
}
$width = 12;
$height = 3;
sArea($width, $height);
?>
|
ถ้าหากส่งค่าให้ฟังก์ชั่นมากเกินกว่าที่ฟังก์ชั่นรับไว้
ค่าที่เกินมา จะไม่ถูกนำไปใช้งาน แต่ถ้าหากส่งค่าไปไม่ครบจะเกิดข้อผิดพลาด Warning:
Missing argument ตรงนี้ก็ระวังกันด้วยนะครับ
2.2 การส่งค่าอ้างอิงตำแหน่งตัวแปร
โดยปกติการส่งค่าให้ฟังก์ชั่นจะทำการส่งค่าของตัวแปรนั้นๆ
เข้าไปยังฟังก์ชั่นเลย ถ้าหากต้องการผลลัพธ์ของการคำนวนก็ทำการคืนค่า (return)
กลับมา แต่เราสามารถเขียนให้ง่ายกว่านั้นได้อีก โดยการส่งตำแหน่ง (address)
ของตัวแปรนั้นเข้าไปยังฟังก์ชั่นแทน
ก็สามารถทำการคำนวนและเปลี่ยนค่าของตัวแปรที่เราต้องการได้โดยไม่ต้องทำการคืนค่ากลับออกมา
ตัวอย่างที่ผมใช้บ่อยและใช้ตลอดก็คือการคำนวนภาษี (ยังหาโปรแกรมอื่นๆ
ที่ใช้ฟังก์ชั่นแบบนี้ไม่ได้เลย) ลองดูตัวอย่างกันครับ
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
<?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
โดยไม่ต้องทำการคืนค่าในฟังก์ชั่นเลย จริงๆ แล้ว
ตัวอย่างด้านบนสามารถเขียนได้อีกแบบดังนี้
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
<?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% แต่ต้องการให้สามารถเปลี่ยนค่าได้โดยที่ไม่ต้องแก้ไขฟังก์ชั่นใหม่
ก็สามารถทำการกำหนดค่าเริ่มต้นขึ้นมาได้เลย ลองดูตัวอย่างกัน
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
<?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 ก็ได้ ลองดูตัวอย่างกันครับ
การคืนค่าหนึ่งค่า
|
1
2
3
4
5
6
7
8
9
10
11
12
|
<?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()
|
1
2
3
4
5
|
<?php
$color = array('red', 'green',' blue');
list($red, $green, $blue) = $color;
// ตัวแปร $red เก็บค่า red, $green เก็บค่า green, $blue เก็บค่า blue
?>
|
ตัวอย่างการใช้งานฟังก์ชั่นที่คืนค่าแบบ array
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
<?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
เราสามารถสร้างฟังก์ชั่นขึ้นมาภายในฟังก์ชั่นอีกทีได้ แบบตัวอย่าง
|
1
2
3
4
5
6
7
8
9
10
11
12
|
<?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
ตัวอย่างกัน
|
1
2
3
4
5
6
7
8
9
10
11
12
|
<?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
|
1
2
3
4
5
6
7
8
9
10
11
12
|
<?php
function fac($num) {
if ($num == 0 ||
$num == 1) {
return
1;
}
else {
return
fac($num - 1) * $num;
}
}
echo fac(5);
?>
|
ตัวอย่างที่สองเป็นตัวเลข Factorial หรือ n! การทำงานก็คล้ายๆ กับ fibonacci แต่ผลลัพธ์ที่ได้จะเป็นค่าของ n! เลย
จะเห็นว่า ถ้าหากเราเขียนโปรแกรมแบบปกติ
จะต้องมีการใช้คำสั่งวนรอบมาเกี่ยวข้อง แต่ถ้าใช้ฟังก์ชั่นเรียกตัวเองเราไม่ต้องใช้คำสั่งวนรอบเข้ามาเกี่ยวข้องกับการทำงานของฟังก์ชั่นเลย
แต่จะต้องมีเงื่อนไขในการจบฟังก์ชั่นที่แน่นอนด้วย
ก็จบกันไปอีกแล้วกับฟังก์ชั่นในภาษา PHP
บทนี้เขียนกันข้ามเดือนเลย เนื่องจากงานเยอะ (แต่มีเวลาเล่นเกม)
ก็ต้องขออภัยเพื่อนๆ ที่รอกันอยู่นะครับ ตอนนี้ก็ปิดเทอมแล้ว
ยังไงจะพยายามเขียนให้ได้มากที่สุดเท่าที่จะทำได้ แล้วเจอกันครับ
