คำสั่งใช้ใหม่
(reuse code) นำไปสู่ความตรงกัน ความน่าเชื่อถือ การบำรุงรักษาได้สะดวก
โดยเริ่มจากเทคนิคแบบโมดูลและคำสั่งใช้ใหม่
เริ่มต้นการใช้ require () และ include () เพื่อใช้คำสั่งเดียวกันบนมากกว่าหนึ่งเพจ นี่เป็นคำอธิบายความเหนือกว่าของ
server side include
คำสั่งใช้ใหม่
เป้าหมายหนึ่งของวิศวกรซอฟต์แวร์คือ
การใช้คำสั่งใช้ใหม่ แทนที่การเขียนคำสั่งใหม่ เนื่องจากคำสั่งใช้ใหม่ ลดต้นทุน
เพิ่มความน่าเชื่อถือ และปรับปรุงความตรงกันได้สะดวก ในทางทฤษฏี
โครงงานใหม่ได้รับการสร้างขึ้นมาโดยการรวมส่วนชุดคำสั่งที่มีอยู่มาใช้ใหม่
และด้วยการพัฒนาน้อยที่สุด
การจัดกลุ่มคำสั่งเข้าสู่ไฟล์
ขั้นตอนแรกในการใช้คำสั่งใหม่คือ
กำหนดปัจจัยในพิจารณาเลือกสิ่งที่ควรรวมและแยก มีข้อพิจารณาจัดกลุ่มการทำงานร่วม การเขียนโปรแกรมจะแบ่งการทำหน้าที่ออกเป็นฟังก์ชันให้ทำงานคนละหน้าที่
จากนั้นจึงรวมฟังก์ชันที่ทำงานสัมพันธ์กันให้อยู่ในไฟล์เดียวกันเพื่อความสะดวกในการค้นหา
เช่น ฟังก์ชันแสดงส่วนหัวของเพจ ส่วนล่างของเพจ และเมนู
สามารถรวมเข้าในไฟล์สำหรับการแสดงผลเพจ
รวมทั้งไม่ต้องกลัวว่าในไฟล์มีฟังก์ชันไม่มาก ทำให้การอินเตอร์เฟซแน่นอน
การเขียนคำสั่งกับการทำงานประเภทคล้ายกันควรเขียนคำสั่งแบบเดียวกัน เช่น
การคำนวณเกี่ยวกับสี่เหลี่ยม
<?php
function
rectangular_compute_area($side)
{
return
$side['width'] * $side['length'];
}
function
rectangular_modify_side(&$side, $diffwidth, $difflegth, $add=FALSE)
{
if
($add = TRUE)
{
$side['width']
+= $diffwidth;
$side['length']
+= $difflegth;
}
else
{
$side['width']
-= $diffwidth;
$side['length']
-= $difflegth;
}
}
?>
การเลือกชื่อไฟล์และตำแหน่ง
เมื่อจัดการแบ่งคำสั่งออกเป็นไฟล์ต่างหากแล้ว
ต้องมีการเลือกชื่อและตำแหน่ง
การตั้งชื่อไฟล์สคริปต์ไลบรารีนี้สามารถตั้งชื่อด้วยนามสกุล .php แต่อาจจะนำไปสู่ความเข้าใจผิดเล็กน้อย
ประการแรกไม่สามารถสื่อถึงการใช้เป็นไลบรารีของคำสั่งสำหรับสคริปต์ PHP ประการต่อมาไม่มีสิ่งใดป้องกันบุคคลอื่นจากความพยายามที่เรียกใช้สคริปต์ใน
browserดังนั้น
ควรเลือกนามสกุล เช่น .inc
หรือ .lib การใช้นามสกุล .inc ไม่มีข้อเสียเปรียบ เนื่องจาก browser ไม่ทราบว่าไฟล์นามสกุลนี้เป็นสคริปต์
PHP แต่ถ้าผู้ใช้เปิดดูจะคำสั่งภายในสคริปต์ตามภาพ 1.6.1
ภาพ
1.6.1 การเปิดดูไฟล์นามสกุล .inc บน browser
กลไกการป้องกันเข้าถึงไฟล์ไลบรารีเหล่านี้มี
2 แบบ
กลไกแรกทำให้มั่นใจว่าไม่อนุญาตให้บุคคลทั่วไปเข้ามาดูและโหลดไฟล์ในไดเรคทอรีภายในโครงสร้างเอกสารเหล่านั้น
กลไกที่ 2 ป้องกันโดยวางคำสั่งไลบรารีนอกโครงสร้างเอกสาร
และอ้างอิงเชิงประจักษ์ไปยังไดเรคทอรีนั้นหรือบอกให้ PHP มองหาใน Microsoft
Internet Information (IIS) มีโครสร้างเอกสารเป็น
C:\WebApplications\WWW
หรือใน Unix ( Linux, FreeBSD, Solaris และอื่นๆ)
เรียกใช้ httpd ใน
/home/www ไฟล์ไลบรารีสามารถใน C:\WebApplications\Lib
หรือ /home/lib ไดเรคทอรีเหล่านี้ผู้ใช้ทั่วไปไม่สามารถเข้าถึงและไม่ต้องกังวลกับการดูไฟล์จากบุคคลอื่น
การรวมไฟล์ไลบรารีในสคริปต์
PHP
มีวิธีการหลักในการรวมไฟล์ในสคริปต์การใช้ require () และ include ()
PHP
ให้ 2 วิธีอย่างง่าย เป็นประโยคคำสั่งที่ยอมใช้คำสั่งใหม่คือ ประโยคคำสั่ง
require () หรือ include () ทำให้สามารถโหลดไฟล์เข้าสู่สคริปต์
PHP ไฟล์นั้นสามารถเก็บทุกอย่างที่พิมพ์อย่างปกติในสคริปต์
รวมถึงประโยคคำสั่ง PHP ข้อความ HTML tag ฟังก์ชัน PHP และ PHP class
ประโยคคำสั่งเหล่านี้ทำงานคล้ายกับ
Server Side
Include ที่มีให้โดยแม่ข่ายเว็บส่วนมากและประโยคคำสั่ง #include
ใน C หรือ C++
การใช้
require ()
คำสั่งต่อไปนี้เก็บอยู่ในไฟล์
welcome.inc
<p
align="center">
<?php
echo
"<h1>Welcome to web development with PHP</h1>";
?>
</p>
คำสั่งต่อไปนี้เก็บอยู่ในไฟล์
main.php
<html>
<head>
<title>File
Include Sample</title>
<meta
http-equiv="Content-Type" content="text/html; charset=iso-8859-11">
</head>
<body>
<?php
echo
"<b> นี่เป็นหน้าหลัก </b><br/>";
require("welcome.inc");
echo
"<b> จบสคริปต์ </b><br/>";
?>
</body>
</html>
ถ้าโหลด reuse.php แล้วจะไม่แปลกใจ เมื่อปรากฏ “
นี่คือประโยคคำสั่ง PHP อย่างง่าย ” บน browser ถ้าโหลด main.php
ไฟล์ต้องใช้ประโยคคำสั่ง
require () ในตัวอย่างก่อนกำลังใช้ไฟล์ชื่อ welcome.inc จะเขียนดังนี้
require("welcome.inc");
PHP
ไม่ได้มองนามสกุลไฟล์บนไฟล์ที่รวม หมายความว่า
สามารถตั้งชื่อไฟล์ตามต้องการตราบเท่าที่ยังไม่ได้เรียก เมื่อใช้ require
() โหลดไฟล์ จะมีผลเป็นส่วนหนึ่งของไฟล์ PHP และได้รับการประมวลผลด้วย
ตามปกติ
ประโยคคำสั่ง PHP
จะไม่ประมวลผลถ้าอยู่ในไฟล์ที่เรียก เช่น page.html โดย PHP จะเรียกเฉพาะการกระจายไฟล์ด้วยการกำหนดนามสกุลเช่น
.php อย่างไรก็ตามถ้าโหลด page_html ผ่านประโยคคำสั่ง
require () แล้ว PHP ภายในจะได้รับการประมวลผล
ดังนั้นสามารถใช้นามสกุลตามต้องการสำหรับไฟล์ที่รวม แต่ความคิดที่ดีคือ
พยายามเข้มงวดกับแบบแผน เช่น .inc ตามที่ได้กล่าวไปแล้ว
ภาพ
1.6.2 ผลลัพธ์การเรียกใช้สคริปต์ main.php ที่รวมไฟล์ welcome.inc
การ
ใช้ include
()
ประโยคคำสั่ง
require () และ include () คล้ายกันมาก
แต่มีความแตกต่างสำคัญบางสิ่งตามการทำงาน ประโยคคำสั่ง
include () ได้รับการประเมินแต่ละครั้งเมื่อประโยคคำสั่งได้รับการประมวลผลและไม่มีการประเมิน
ถ้าประโยคคำสั่งไม่มีการประมวลผล ประโยคคำสั่ง require () ได้รับการประมวลผลครั้งแรก
เมื่อประโยคคำสั่งได้รับการกระจาย
แต่กลุ่มคำสั่งที่มีประโยคคำสั่งที่เก็บอยู่จะได้รับการประมวลผล
<?php
include("welcome.inc");
?>
การระบุตำแหน่งไฟล์รวม
การอ้างอิงไฟล์ไลบรารีใน
PHP สามารถกำหนดแบบสัมพัทธ์และแบบสัมบูรณ์
- สำหรับ Unix
require("../../lib/db_fns.inc");
require("home/httpd/lib/output/heder.inc");
- สำหรับ Windows
require("..\..\Libs\Database\connections.inc");
require("D:WebApps\Libs\MathFunctions\area.inc");
ถ้าไม่ได้ระบุพาร์ทเชิงประจักษ์ PHP
จะมองหาในไดเรคทอรีปัจจุบัน ตามด้วยรายการไดเรคทอรีจากการตั้งค่า include_path
ในไฟล์ php.ini ภายใต้ Unix ตัวอักษรแบ่งคือ colon (:) สำหรับ Windows ตัวอักษรแบ่งคือ semicolon (;)
ตัวอย่างการตั้งค่าภายใต้ระบบ
Unix
include_path=".:/usr/local/lib/php:/home/httpd/globalincs"
-
ภายใต้ Windows การตั้งค่าคือ
include_path=".;C\PHP\include;D:\WebApps\Libs
"
การรวมไฟล์และ
Scope ของฟังก์ชัน
เมื่อมีการรวมไฟล์แล้ว
การเรียกฟังก์ชันในไฟล์ที่รวมต้องอยู่หลังประโยคคำสั่ง include หรือ require
ถ้าเรียกฟังก์ชันก่อนประโยคคำสั่งนี้จะเกิดความผิดพลาด
<?php
include("reverse_word.inc");
$strword
= "Hello world";
word_reverse_r($strword);
echo
"<br>";
?>
ปัญหาการใช้ไฟล์ร่วม
ในการใช้การรวมไฟล์ด้วยคำสั่ง
require() และ include() ถ้าการอ้างอิงของสคริปต์ตั้งแต่ 2
ไฟล์ขึ้นไปอ้างถึงไฟล์ไลบรารีเดียวกัน การกระจายของ PHP จะทำซ้ำกัน
จึงเกิดปัญหาที่ PHP เข้าใจว่ามีการประกาศฟังก์ชันซ้ำกัน
ตามตัวอย่าง
compute_area.php
รวมไฟล์ mathmetics.inc และ contruction.inc
ซึ่งไฟล์คู่นี้รวมไฟล์ rectangular.inc
<?php
require("construction.inc");
require("mathmetics.inc");
?>
เมื่อเรียกใช้
compute_area.php
จะปรากฎผลลัพธ์ความผิดพลาด
Fatal
error : Cannot redeclare rectangular_compute_area() (previously declared in
C:\AppServ\www\phptrain\chapter06\rectangular.inc:3) in C:\AppServ\www\phptrain\chapter06\rectangular.inc
on line 6
การหลีกเลี่ยงปัญหานี้ให้ใช้
require_once() และ include_once()
require_once("mathmetics.inc");
include_once("mathmetics.inc");
การสร้างต้นแบบ
ถ้าเว็บไซต์มีเพจจำนวนมาก
ในแต่ละหน้าจะมีส่วนหัวและส่วนล่างเหมือนกัน
ในกรณีนี้สามารถใช้การรวมไฟล์เพื่อเรียกไฟล์ไลบรารีต้นแบบมาสร้างส่วนที่ใช้งานร่วมกัน
ตัวอย่าง เว็บต้อนรับของ widebase.net
ประกอบด้วยส่วนหัว เนื้อความ และส่วนล่าง
ส่วนหัวและส่วนล่างเหมือนกันในทุกเพจ ดังนั้น จึงสร้างไฟล์ html_hrader.inc
สำหรับส่วนหัว และไฟล์ html_footer.inc สำหรับส่วนล่าง
ถ้าสร้างเพจใหม่สามารถรวมไฟล์ html_header.inc สำหรับส่วนหัว
และไฟล์ html_footer.inc สำหรับส่วนล่างทำหน้าที่เป็นส่วนหัวและส่วนล่างของเพจ
ฟังก์ชันใน
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
() เป็นฟังก์ชันเดียวกัน
การหยุดประมวลผลภายในฟังก์ชัน
คีย์เวิร์ด
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 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
Scope
เมื่อต้องการใช้ตัวแปรภายในไฟล์ที่รวม
ต้องมีการประกาศตัวแปรเหล่านั้นก่อนประโยคคำสั่ง require () หรือ include
() แต่เมื่อใช้ฟังก์ชันจะเป็นการส่งผ่านตัวแปรเชิงประจักษ์เหล่านั้นไปยังฟังก์ชัน
บางส่วนเป็นเพราะไม่มีกลไกส่งผ่านตัวแปรเชิงประจักษ์ไปยังไฟล์ที่รวม
และบางส่วนเป็นเพราะ scope ของตัวแปรของฟังก์ชันแตกต่างกัน
การควบคุม
scope ของตัวแปรเป็นการทำให้ตัวแปรมองเห็นได้ ใน PHP มีกฎตั้งค่า
scope ดังนี้
การประกาศตัวแปรภายในฟังก์ชันอยู่ใน scope จากประโยคคำสั่งซึ่งตัวแปรให้รับการประกาศภายในวงเล็บปีกกา
สิ่งนี้เรียกว่า function scope ตัวแปรเรียกว่า local
variable
การประกาศตัวแปรภายนอกฟังก์ชันอยู่ใน
scope จากประโยคคำสั่งซึ่งตัวแปรได้รับการประกาศที่สิ้นสุดแต่ไม่ใช้ภายในฟังก์ชัน
สิ่งนี้เรียกว่า global scope ตัวแปรเรียกว่า global
variable
การใช้ประโยคคำสั่ง
require () และ include () ไม่มีผลกับ scope ถ้าประโยคคำสั่งได้รับการใช้ภายในฟังก์ชัน ประยุกต์ด้วย function
scope ถ้าไม่ได้อยู่ภายในฟังก์ชัน ประยุกต์ด้วย global scope
คีย์เวิร์ด
global สามารถระบุได้เองเพื่อกำหนดหรือใช้ตัวแปรภายในฟังก์ชันให้มี scope เป็น global
ตัวแปร
สามารถลบโดยการเรียก unset
($variable_name) และตัวแปรที่ unset จะไม่มี scope
ตัวแปรระดับ
superglobal สามารถเข้าถึงได้ทุกส่วนในสคริปต์
ตัวแปรระดับฟังก์ชัน
ตัวแปรระดับฟังก์ชันหรือ local
variable เป็นการประกาศเพื่อใช้เฉพาะภายในฟังก์ชัน
ไม่สามารถเรียกจากภายนอกฟังก์ชันได้
<?php
$newline
= <<<NLSTRING
<br/>\n
NLSTRING;
$var_global
= 10 ;
function
show_value()
{
global
$newline;
$var_local=
75 ;
echo
"\$var_local 1: $var_local";
echo
$newline;
}
show_value();
echo
"\$var_global : $var_global";
echo
$newline;
echo
"\$var_local 2: $var_local";
echo
$newline;
?>
ผลลัพธ์
$var_global
1 :
$var_local
1: 75
$var_global
2: 10
$var_local
2:
ตามตัวอย่างนี้ ตัวแปรระดับฟังก์ชัน $var_local ไม่สามารถแสดงผลในการพิมพ์ภายนอกฟังก์ชัน
show_value() และ $var_global ที่เป็นตัวแปรระดับ
global ไม่สามารถแสดงผลภายใน show_value() เพราะมี scope ต่างกัน
ตัวแปรระดับ
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
ไปถึงตัวอักษรสุดท้าย
การเรียกฟังก์ชันแต่ละครั้งจะทำสำเนาใหม่ของคำสั่งในหน่วยความจำของแม่ข่าย
แต่ด้วยพารามิเตอร์ต่างกัน ดังนั้นจึงเหมือนกับการเรียกคนละฟังก์ชัน
ไม่มีความคิดเห็น:
แสดงความคิดเห็น