ฟังก์ชันใน PHP
ฟังก์ชันในโปรแกรมส่วนใหญ่ได้รับการเรียกคำสั่งเพื่อทำงานอย่างเดียว
สิ่งนี้ทำให้คำสั่งอ่านได้ง่ายและยอมให้ใช้คำสั่งใหม่แต่ละครั้งเมื่อต้องการทำงานเดียวกัน
ฟังก์ชันเป็นโมดูลเก็บคำสั่งที่กำหนดการเรียกอินเตอร์เฟซ
ทำงานเดียวกัน และตัวเลือกส่งออกค่าจากการเรียกฟังก์ชัน
คำสั่งต่อไปเป็นการเรียกฟังก์ชันอย่างง่าย
my_function ();
คำสั่งเรียกฟังก์ชันชื่อ my_function ที่ไม่ต้องการพารามิเตอร์
และไม่สนใจค่าที่อาจจะส่งออกโดยฟังก์ชันนี้
ฟังก์ชันจำนวนมากได้รับการเรียกด้วยวิธีนี้
เช่น ฟังก์ชัน phpinfo
() สำหรับแสดงเวอร์ชันติดตั้งของ PHP สารสนเทศเกี่ยวกับ
PHP การตั้งค่าแม่ข่ายเว็บ ค่าต่างๆ ของ PHP และตัวแปร ฟังก์ชันนี้ไม่ใช้พารามิเตอร์และโดยทั่วไปไม่สนใจค่าส่งออก
ดังนั้นการเรียก phpinfo () จะประกอบขึ้นดังนี้ phpinfo ();
การกำหนดฟังก์ชันและการเรียกฟังก์ชัน
การประกาศฟังก์ชันเริ่มต้นด้วยคีย์เวิร์ด
function กำหนดชื่อฟังก์ชัน
พารามิเตอร์ที่ต้องการ และเก็บคำสั่งที่จะประมวลผลแต่ละครั้งเมื่อเรียกฟังก์ชันนี้
<?php
function
function_name(parameter1,…)
{
ชุดคำสั่ง …
}
?>
ชุดคำสั่งต้องเริ่มต้นและสิ้นสุดในวงเล็บปีกกา
({ }) ตัวอย่างฟังก์ชัน
my_function
<?php
function my_function()
{
$mystring =<<<BODYSTRING
my
function ได้รับการเรียก
BODYSTRING;
echo $mystring;
}
?>
การประกาศฟังก์ชันนี้
เริ่มต้นด้วย function
ดังนั้นผู้อ่านและตัวกระจาย
PHP ทราบว่าต่อไปเป็นฟังก์ชันกำหนดเอง
ชื่อฟังก์ชันคือ my_function การเรียกฟังก์ชันนี้ใช้ประโยคคำสั่งนี้
my_function ();
การเรียกฟังก์ชันนี้จะให้ผลลัพธ์เป็นข้อความ
"my function ได้รับการเรียก
" บน browser
การตั้งชื่อฟังก์ชัน
สิ่งสำคัญมากในการพิจารณาเมื่อตั้งชื่อฟังก์ชันคือชื่อต้องสั้นแต่มีความหมาย
ถ้าฟังก์ชันสร้างส่วนตัวของเพจควรตั้งชื่อเป็น pageheader () หรือ page_header ()
ข้อจำกัดในการตั้งชื่อคือ
ฟังก์ชันไม่สามารถมีชื่อเดียวกับฟังก์ชันที่มีอยู่
-
ชื่อฟังก์ชันสามารถมีได้เพียงตัวอักษรตัวเลข
และ underscore
-
ชื่อฟังก์ชันไม่สามารถเริ่มต้นด้วยตัวเลข
หลายภาษายอมให้ใช้ชื่อฟังก์ชันได้อีก
ส่วนการทำงานนี้เรียกว่า function overload อย่างไรก็ตาม PHP ไม่สนับสนุน function overload ดังนั้นฟังก์ชันไม่สามารถมีชื่อเดียวกันกับฟังก์ชันภายใน
หรือฟังก์ชันกำหนดเองที่มีอยู่
หมายเหตุ
ถึงแม้ว่าทุกสคริปต์ PHP รู้จักฟังก์ชันภายในทั้งหมด
ฟังก์ชันกำหนดเองอยู่เฉพาะในสคริปต์ที่ประกาศสิ่งนี้หมายความว่า
ชื่อฟังก์ชันสามารถใช้ในคนละไฟล์แต่อาจจะไปสู่ความสับสน และควรหลีกเลียง
ชื่อฟังก์ชันต่อไปนี้ถูกต้อง
name ()
name2 ()
name_three ()
_namefour ()
ชื่อไม่ถูกต้อง
5name ()
Name-six ()
fopen ()
การเรียกฟังก์ชันไม่มีผลจากชนิดตัวพิมพ์
ดังนั้นการเรียก function_name (), Function_Name() หรือ FUNCTION_NAME() สามารถทำได้และมีผลลัพธ์เหมือนกัน
แต่แบบแผนการกำหนดชื่อฟังก์ชันใน PHP ให้ใช้ตัวพิมพ์เล็ก
ชื่อฟังก์ชันแตกต่างจากชื่อตัวแปร
โดยชื่อตัวแปรเป็นชนิดตัวพิมพ์มีผล ดังนั้น $Name และ $name เป็น 2 ตัวแปร แต่ Name () และ name () เป็นฟังก์ชันเดียวกัน
การเรียกฟังก์ชันไม่มีผลจากชนิดตัวพิมพ์
ดังนั้นการเรียก function_name (), Function_Name() หรือ FUNCTION_NAME() สามารถทำได้และมีผลลัพธ์เหมือนกัน
แต่แบบแผนการกำหนดชื่อฟังก์ชันใน PHP ให้ใช้ตัวพิมพ์เล็ก
ชื่อฟังก์ชันแตกต่างจากชื่อตัวแปร
โดยชื่อตัวแปรเป็นชนิดตัวพิมพ์มีผล ดังนั้น $Name และ $name เป็น 2 ตัวแปร แต่ Name () และ name () เป็นฟังก์ชันเดียวกัน
การหยุดประมวลผลภายในฟังก์ชัน
คีย์เวิร์ด return หยุดการประมวลผลฟังก์ชัน
ฟังก์ชันสิ้นสุดได้เพราะประโยคคำสั่งทั้งหมดได้รับการประมวลผล หรือ ใช้คีย์เวิร์ด return การประมวลผลกลับไปยังประโยคคำสั่งต่อจากการเรียกฟังก์ชัน
<?php
function division($x, $y)
{
if ($y == 0 || !isset($y))
{
echo " ตัวหาร y ต้องไม่เป็นศูนย์หรือไม่มีค่า"
;
return;
}
$result = $x / $y;
echo $result;
}
?>
ถ้าประโยคคำสั่ง
return ได้รับการประมวลผล
บรรทัดคำสั่งต่อไปในฟังก์ชันจะถูกข้ามไป และกลับไปยังผู้เรียกฟังก์ชันนี้
ในฟังก์ชันนี้ ถ้า y เป็น 0 จะหยุดการประมวลผล ถ้า y ไม่เท่ากับ 0 จะคำนวณผลหาร
สมมติป้อนค่าเป็น
x = 4, y = 0
x = 4
x = 4, y = 2
ผลลัพธ์ของคำสั่ง
คือ
x = 4, y = 0 ผลลัพธ์
ตัวหาร y ต้องไม่เป็นศูนย์หรือไม่มีค่า
x = 4, y = ผลลัพธ์ ตัวหาร
y ต้องไม่เป็นศูนย์หรือไม่มีค่า
x = 4, y = 2 ผลลัพธ์ 2
การเรียกฟังก์ชัน
เมื่อฟังก์ชันได้รับการประกาศหรือสร้างขึ้นแล้ว
การเรียกฟังก์ชันสามารถเรียกมาจากที่ใดๆ ภายในสคริปต์ หรือ
จากไฟล์ที่มีการรวมด้วยประโยคคำสั่ง include() หรือ require()
ตัวอย่าง
ฟังก์ชัน show_message()
เก็บอยู่ในไฟล์
fn_ 03 _keeper.php ส่วนผู้เรียกอยู่ในสคริปต์
fn_ 03 _caller.php
<?php
include("fn_ 03
_keeper.php");
show_message();
?>
พารามิเตอร์
ตามปกติฟังก์ชันส่วนใหญ่ต้องการรับสารสนเทศจากผู้เรียกสำหรับการประมวลผล
โดยทั่วไปเรียกว่า พารามิเตอร์
ไวยากรณ์พื้นฐาน
การกำหนดฟังก์ให้รับพารามิเตอร์ส่งผ่านโดยการวางข้อมูล
ชื่อตัวแปรที่เก็บข้อมูลภายในวงเล็บหลังชื่อฟังก์ชัน
การเรียกฟังก์ชันที่ประกอบด้วยพารามิเตอร์เขียนดังนี้
<?php
function show_parameter($param1,
$param2, $param3)
{
echo <<<PARAM
รายการพารามิเตอร์
<br/>
param1: $param1 <br/>
param2: $param2 <br/>
param3: $param3 <br/>
PARAM;
}
?>
พารามิเตอร์ที่ส่งไปยังฟังก์ชันแยกกันเครื่องหมายจุลภาคภายในวงเล็บ
โดยสามารถส่งเป็นนิพจน์สำหรับแต่ละพารามิเตอร์ด้วย ตัวแปร ค่าคงที่
ผลลัพธ์จากการคำนวณ รวมถึงการเรียกฟังก์ชัน
scope ของพารามิเตอร์จำกัดภายในฟังก์ชัน
ถ้าชื่อตัวแปรเหมือนกับตัวแปรใน scope ระดับอื่น พารามิเตอร์นี้ "ระบุ"
เป็นตัวแปรภายในที่ไม่มีผลกับตัวแปรภายนอกฟังก์ชัน
การส่งผ่านโดยค่า(By Value)
ตามปกติการส่งผ่านพารามิเตอร์ไปยังฟังก์ชันเป็นการส่งผ่านค่า
การเปลี่ยนแปลงจะจำกัดภายในเฉพาะภายในฟังก์ชัน
ตัวอย่างฟังก์ชัน
new_value () ที่ยอมให้เพิ่มค่า
อาจจะเขียนคำสั่งดังนี้
<?php
function new_value($value,
$increment= 1)
{
$value = $value + $increment;
}
$value = 10 ;
new_value($value);
echo
"$value<br/>\n";
?>
คำสั่งนี้ใช้ไม่ได้
ผลลัพธ์จะเป็น "10" ค่าใหม่ของ $value ไม่มีการเปลี่ยนแปลง
สิ่งนี้เป็นเพราะกฎ
scope คำสั่งนี้สร้างตัวแปรเรียกว่า
$value เป็น 10 เมื่อเรียกฟังก์ชัน
new_value () ตัวแปร $value ในฟังก์ชันได้รับการสร้างเมื่อเรียกฟังก์ชัน
ค่า 1 ได้รับการเพิ่มให้กับตัวแปร
ดังนั้นค่าของ $value
คือ 11 ภายในฟังก์ชัน
จนกระทั่งสิ้นสุดฟังก์ชัน แล้วกลับไปยังคำสั่งที่เรียกภายในคำสั่งนี้ ตัวแปร $value เป็นอีกตัวแปร global scope และไม่มีการเปลี่ยนแปลง
การส่งผ่านโดยค่า(By Value)
ตามปกติการส่งผ่านพารามิเตอร์ไปยังฟังก์ชันเป็นการส่งผ่านค่า
การเปลี่ยนแปลงจะจำกัดภายในเฉพาะภายในฟังก์ชัน
ตัวอย่างฟังก์ชัน
new_value () ที่ยอมให้เพิ่มค่า
อาจจะเขียนคำสั่งดังนี้
<?php
function new_value($value,
$increment= 1)
{
$value = $value + $increment;
}
$value = 10 ;
new_value($value);
echo
"$value<br/>\n";
?>
คำสั่งนี้ใช้ไม่ได้
ผลลัพธ์จะเป็น "10" ค่าใหม่ของ $value ไม่มีการเปลี่ยนแปลง
สิ่งนี้เป็นเพราะกฎ
scope คำสั่งนี้สร้างตัวแปรเรียกว่า
$value เป็น 10 เมื่อเรียกฟังก์ชัน
new_value () ตัวแปร $value ในฟังก์ชันได้รับการสร้างเมื่อเรียกฟังก์ชัน
ค่า 1 ได้รับการเพิ่มให้กับตัวแปร
ดังนั้นค่าของ $value
คือ 11 ภายในฟังก์ชัน
จนกระทั่งสิ้นสุดฟังก์ชัน แล้วกลับไปยังคำสั่งที่เรียกภายในคำสั่งนี้ ตัวแปร $value เป็นอีกตัวแปร global scope และไม่มีการเปลี่ยนแปลง
การส่งผ่านโดยการอ้างอิง
(By Reference)
ตามตัวอย่างฟังก์ชัน
new_value ถ้าต้องการให้ฟังก์ชันเปลี่ยนแปลงค่าได้
มีวิธีหนึ่งในการแก้ไขคือ ประกาศ $value ในฟังก์ชันเป็น global แต่หมายความว่าในการใช้ฟังก์ชันนี้
ตัวแปรที่ต้องการเพิ่มค่าต้องตั้งชื่อเป็น $value แต่มีวิธีดีกว่าคือ
ใช้การส่งผ่านโดยการอ้างอิง
การอ้างอิงไปตัวแปรต้นทางแทนที่มีค่าของตัวเอง
การปรับปรุงไปยังการอ้างอิงจะมีผลกับตัวแปรต้นทางด้วย
การระบุพารามิเตอร์ที่ใช้การส่งผ่านโดยการอ้างอิงให้วาง
ampersand (&) หน้าชื่อพารามิเตอร์ในข้อกำหนดฟังก์ชัน
ตัวอย่าง new_value () ได้รับปรับปรุงให้มี
1 พารามิเตอร์ส่งผ่านโดยการอ้างอิงและทำงานได้อย่างถูกต้อง
<?php
function new_value(&$value,
$increment=1)
{
$value = $value + $increment;
}
?>
คำสั่งทดสอบฟังก์ชัน
ให้พิมพ์ 10 ก่อนการเรียก increment () และ 11 ภายหลัง
ในการส่งค่าโดยการอ้างอิงต้องส่งเป็นตัวแปรไม่สามารถกำหนดค่าคงที่โดยตรง
จำนวนตัวแปรของพารามิเตอร์
การส่งผ่านพารามิเตอร์ไปยังฟังก์ชันนั้น
การควบคุมของ PHP
ได้กำหนดฟังก์ชันจำนวนหนึ่งให้ยอมรับจำนวนตัวแปรของพารามิเตอร์
ได้แก่ func_num_args, func_get_arg และ func_get_args
func_num_args() บอกจำนวนพารามิเตอร์ไปยังฟังก์ชันที่เรียก
func_get_arg() แสดงค่าของพารามิเตอร์ตามดัชนี
และ func_get_args() ส่งออก array ของพารามิเตอร์
<?php
function show_pass_value()
{
$idx = count(func_get_args());
echo " จำนวนพารามิเตอร์
$idx <br/>\n";
if ($idx > 0)
echo ">> ใช้ฟังก์ชัน func_get_arg<br/>\n";
for ($i = 0 ; $i < $idx; $i++)
{
echo " พารามิเตอร์ที่
$i ค่า: ". func_get_arg($i)."<br/>\n";
}
if ($idx > 0)
echo ">> ใช้ฟังก์ชัน func_get_args<br/>\n";
$params = func_get_args();
foreach ($params as $index =>
$val)
{
echo " พารามิเตอร์ที่
$index ค่า: $val<br/>\n";
}
echo "
*********<br/>\n";
}
$x = 4 ;
show_pass_value("one",
"two", 3 , $x, " ห้า" , " หก") ;
show_pass_value();
?>
ผลลัพธ์
จำนวนพารามิเตอร์
6
>> ใช้ฟังก์ชัน func_get_arg
พารามิเตอร์ที่
0 ค่า: one
พารามิเตอร์ที่
1 ค่า: two
พารามิเตอร์ที่
2 ค่า: 3
พารามิเตอร์ที่
3 ค่า: 4
พารามิเตอร์ที่
4 ค่า: ห้า
พารามิเตอร์ที่
5 ค่า: หก
>> ใช้ฟังก์ชัน func_get_args
พารามิเตอร์ที่
0 ค่า: one
พารามิเตอร์ที่
1 ค่า: two
พารามิเตอร์ที่
2 ค่า: 3
พารามิเตอร์ที่
3 ค่า: 4
พารามิเตอร์ที่
4 ค่า: ห้า
พารามิเตอร์ที่
5 ค่า: หก
*********
จำนวนพารามิเตอร์
0
*********
ตัวแปรระดับ global
ถ้าต้องการนำตัวแปรระดับ
global มาใช้ภายในฟังก์ชันต้องประกาศด้วยคีย์เวิร์ด
global ก่อนประโยคคำสั่งที่ใช้ตัวแปรนั้น
ตัวอย่าง ฟังก์ชัน show_value() ใช้ $newline จากภายนอกฟังก์ชัน
global $newline;
ตัวแปรสถิตย์
การประกาศตัวแปรสถิตย์ใช้
คีย์เวิร์ด static
เมื่อมีการเรียกใช้ฟังก์ชัน
โปรแกรมจะกำหนดค่าตัวแปรตามที่ระบุเพียงครั้งเดียว
ถ้าเรียกซ้ำอย่างต่อเนื่องค่านี้จะเปลี่ยนแปลงตามการคำนวณ
<?php
function increment()
{
static
$increase = 5 ;
$increase++;
echo
$increase."<br/>\n";
}
$end = 5 ;
for ($i = 1 ; $i < $end; $i++)
increment();
?>
ผลลัพธ์
6 7 8 9
ค่าของตัวแปรสถิตย์ได้รับการตั้งทุกครั้งเมื่อเรียกใช้ในครั้งต่อไป
การส่งออกค่าจากฟังก์ชัน
การส่งค่าออกจากฟังก์ชันใช้คีย์เวิร์ด
return เช่นเดียวกับการออกจากฟังก์ชันได้
ถ้าไม่มีการระบุส่งออกฟังก์ชันจะส่งค่า NULL
ตัวอย่าง
ฟังก์ชัน get_larger
() สาธิตการส่งออกค่า
<?
function get_larger($x=NULL,
$y=NULL)
{
if (!isset($x) || !isset($y))
return " ไม่มีการส่งค่า" ;
if ($x > $y)
return $x;
else if ($x < $y)
return $y;
else
return " ค่าเท่ากัน" ;
}
$sends = array();
$sends[0] = array('x' =>5);
$sends[1] = array('x' =>9,
'y'=>3);
$sends[2] = array('x' =>5,
'y'=>8);
$sends[3] = array('x' =>4,
'y'=>4);
foreach ($sends as $send)
{
echo "x =
".$send['x']." y = ".$send['y']." : ค่า - > "
.get_larger($send['x'],
$send['y']);
echo "<br/>\n";
}
?>
ผลลัพธ์
x = 5 y = : ค่า - > ไม่มีการส่งค่า
x = 9 y = 3 : ค่า - > 9
x = 5 y = 8 : ค่า - > 8
x = 4 y = 4 : ค่า - > ค่าเท่ากัน
ฟังก์ชันที่ทำงานอาจเดียว
แต่ไม่จำเป็นต้องส่งออกค่า มักจะส่งออก TRUE หรือ FALSE เพื่อระบุความสำเร็จหรือล้มเหลว ค่า TRUE หรือ FALSE สามารถได้รับการแสดงแทนด้วย
1 หรือ 0
Recursion
recursion
ได้รับการสนับสนุนใน
PHP ฟังก์ชันชนิดนี้เป็นการเรียกตัวเองและเป็นประโยชน์กับการบังคับโครงสร้างข้อมูลไดนามิคส์
เช่น รายการเชื่อมโยงและโครงสร้างต้นไม้ (tree)
โปรแกรมประยุกต์เว็บจำนวนไม่มากต้องการโครงสร้างข้อมูลซับซ้อนมากและจำกัดการใช้
เนื่องจาก recursion
ช้ากว่าและใช้หน่วยความจำมากกว่าการทำงานวนรอบ
ดังนั้นควรเลือกการทำงานแบบวนรอบปกติ ถ้าเป็นไปได้
ตัวอย่างการประยุกต์แบบย้อนกลับตัวอักษร
<?php
function word_reverse_r($str)
{
if (strlen($str)>0)
word_reverse_r(substr($str, 1));
echo substr($str, 0, 1);
return;
}
function word_reverse_i($str)
{
for ($i=1; $i<=strlen($str);
$i++)
{
echo substr($str, -$i, 1);
}
return;
}
?>
รายการคำสั่งของ
2
ฟังก์ชันนี้จะพิมพ์ข้อความย้อนกลับ ฟังก์ชัน word_reverse_r เป็น recursion ฟังก์ชัน word_reverse_i เป็นการวนรอบ
ฟังก์ชัน word_reverse_r ใช้ข้อความเป็นพารามิเตอร์
เมื่อมีการเรียกฟังก์ชันนี้ จะเกิดการเรียกตัวเองแต่ละครั้งส่งผ่านตัวอักษรที่ 2
ไปถึงตัวอักษรสุดท้าย
การเรียกฟังก์ชันแต่ละครั้งจะทำสำเนาใหม่ของคำสั่งในหน่วยความจำของแม่ข่าย
แต่ด้วยพารามิเตอร์ต่างกัน ดังนั้นจึงเหมือนกับการเรียกคนละฟังก์ชัน
