ปกติแล้วโปรแกรมทุกๆ โปรแกรม จะทำงานจากบนลงล่าง
และประมวลผลจากซ้ายไปขวา เมื่อทำงานเสร็จก็ถือว่าจบการทำงาน
ถ้าหากเราต้องการทำงานเดิม ก็ต้องเขียนโปรแกรมซ้ำอีก
ฟังก์ชั่นเลยเป็นที่รวบรวมส่วนที่เราจะเรียกใช้งานบ่อยๆ
ให้รวมเป็นกลุ่มก้อนเดียวกัน โดยเรียกเพียงชื่อฟังก์ชั่นเท่านั้น
ก็จะได้โปรแกรมที่ทำงานตามที่เราต้องการ และยังมีข้อดีคือ ถ้าหากต้องการแก้ไข
ก็แก้ไขเพียงแต่ในฟังก์ชั่นเท่านั้น
โปรแกรมทั้งหมดของเราก็จะทำงานตามการทำงานของฟังก์ชั่นที่แก้ไขเลย
Function ในภาษา PHP มาอยู่ 4
ชนิดคือ
1. ฟังก์ชั่นภายใน
เป็นฟังก์ชั่นพื้นฐานที่มากับ php (ชื่อก็บอกอยู่แล้ว) มีราวๆ
พันกว่าฟังก์ชั่น (ใครเคยนับบ้างเนี่ย)
ซึ่งจะครอบคลุมการทำงานพื้นฐา่นทั้งหมดของการเขียนโปรแกรม PHP จนบางครั้ง
เราสามารถเขียนโปรแกรมที่ทำงานได้จริงโดยไม่จำเป็นต้องเขียนฟังก์ชั่นเพิ่มเติมเลยแม้แต่ฟังก์ชั่นเดียว
ตัวอย่างฟังก์ชั่นภายใน ถ้าหากเปิดดู help จะเขียนเป็นลักษณะนี้
number pow ( number $base, number $exp )
·
number คือ ค่าที่ฟังก์ชั่นนี้ส่งกลับออกมา (return)
ซึ่งเดี๋ยวเราค่อยมาอธิบายกัน
·
pow คือ ชื่อฟังก์ชั่น
·
(number $base, number $exp) คือ
ค่าที่ต้องส่งให้ฟังก์ชั่นนี้ โดย number หมายถึงชนิดของค่า
(datatype) ที่ต้องส่งไปให้
เพราะฉะนั้น ฟังก์ชั่น pow() เราต้องส่งค่าให้จำนวน 2
ค่า เมื่อฟังก์ขั่นทำงานเสร็จแล้วจะคืนค่ากลับมาเป็นชนิดตัวเลข
ถ้าหากเราไม่ได้นำค่าที่ได้ไปทำการคำนวน
เราสามารถแสดงค่าออกมาได้เลย โดยไม่จำเป็นต้องเก็บค่าไว้ในตัวแปรใดๆ
2.ฟังก์ชั่นที่สร้างขึ้นมาเอง
เป็นฟังก์ชั่นที่สร้างขึ้นมาเอง
เพื่อให้ทำงานนอกเหนือจากฟังก์ชั่นที่มีอยู่ใน PHP หรือเราต้องการให้โปรแกรมทำงานตรงกับความต้องการของเรา
รูปแบบการเขียนฟังก์ชั่นเป็นดังนี้
1
2
3
4
5
|
<?php
function
ชื่อฟังก์ชั่น (ค่าที่ส่งให้) {
การทำงานของฟังก์ชั่น
}
?>
|
หลังจากเราสร้างฟังก์ชั่นได้แล้ว
ฟังก์ชั่นของเราจะไม่มีประโยชน์อะไรเลยถ้าหากไม่สามารถรับค่าเพื่อใช้คำนวนตามที่เราต้องการได้
การส่งค่าให้ฟังก์ชั่นทำการคำนวนนั้นมี 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
?>
|
ถ้าหากส่งค่าให้ฟังก์ชั่นมากเกินกว่าที่ฟังก์ชั่นรับไว้
ค่าที่เกินมา จะไม่ถูกนำไปใช้งาน แต่ถ้าหากส่งค่าไปไม่ครบจะเกิดข้อผิดพลาด 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() ในการรับค่าก็ได้
ตัวอย่างการใช้งานฟังก์ชั่นที่คืนค่าแบบ 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) ทำให้ไม่ว่าจะเขียนฟังก์ชั่นไว้ที่ไหน ก็สามารถเรียกใช้ได้
การเขียนแบบนี้ ไม่ค่อยได้ใช้ในชีวิตจริงเท่าไหร่
แต่ก็ให้รู้ไว้ว่าเราสามารถสร้างฟังก์ชั่นแบบนี้ได้
2.6 ฟังก์ชั่นเรียกตัวเอง (Recursive
Function)
ฟังก์ชั่นเรียกตัวเอง ใช้สำหรับทำงานซ้ำๆ
กันโดยที่เราไม่รู้จำนวนรอบในการทำงาน
โดยจะมีจุดสิ้นสุดการทำงานอยู่ในฟังก์ชั่นเองอยู่แล้ว
เพื่อให้ฟังก์ชั่นหยุดการทำงาน การเขียนฟังก์ชั่นแบบเรียกตัวเอง
จะลดระยะเวลาในการเขียนโปรแกรมไปได้อย่างมาก
แต่ปัญหาคือการออกแบบและเขียนได้ยากมาก
ทำให้ไม่ค่อยได้เห็นคนเขียนฟังก์ชั่นแบบนี้กันเท่าไหร่ เรามาดูตัวอย่างฟังก์ชั่นเรียกตัวเองที่เขียนกันบ่อยๆ
2 ตัวอย่างกัน
1
2
3
4
5
6
|
<?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
|
<?php
function
fac($num) {
if
($num == 0 || $num == 1) {return
1;}else
{return
fac($num - 1) * $num;}}echo
fac(5);?>
|
ตัวอย่างที่สองเป็นตัวเลข Factorial หรือ n!
การทำงานก็คล้ายๆ
กับ fibonacci
แต่ผลลัพธ์ที่ได้จะเป็นค่าของ n!
เลย
