PHP เป็นภาษาจำพวก scripting language คำสั่งต่างๆจะเก็บอยู่ในไฟล์ที่เรียกว่า สคริปต์ (script) และเวลาใช้งานต้องอาศัยตัวแปลชุดคำสั่ง ตัวอย่างของภาษาสคริปก็เช่น JavaScript, Perl เป็นต้น ลักษณะของ PHP ที่แตกต่างจากภาษาสคริปต์แบบอื่นๆ คือ PHP ได้รับการพัฒนาและออกแบบมา เพื่อใช้งานในการสร้างเอกสารแบบ HTML โดยสามารถสอดแทรกหรือแก้ไขเนื้อหาได้โดยอัตโนมัติ ดังนั้นจึงกล่าวว่า PHP เป็นภาษาที่เรียกว่า server-side หรือ HTML-embedded scripting language เป็นเครื่องมือที่สำคัญชนิดหนึ่งที่ช่วยให้เราสามารถสร้างเอกสารแบบ Dynamic HTML ได้อย่างมีประสิทธิภาพและมีลูกเล่นมากขึ้น
ถ้าใครรู้จัก Server Side Include (SSI) ก็จะสามารถเข้าใจการทำงานของ PHP ได้ไม่ยาก สมมุติว่า เราต้องการจะแสดงวันเวลาปัจจุบันที่ผู้เข้ามาเยี่ยมชมเว็บไซด์ในขณะนั้น ในตำแหน่งใดตำแหน่งหนึ่งภายในเอกสาร HTML ที่เราต้องการ อาจจะใช้คำสั่งในรูปแบบนี้ เช่น <!--#exec cgi="date.pl"--> ไว้ในเอกสาร HTML เมื่อ SSI ของ web server มาพบคำสั่งนี้ ก็จะกระทำคำสั่ง date.pl ซึ่งในกรณีนิ้ เป็นสคริปต์ที่เขียนด้วยภาษา perl สำหรับอ่านเวลาจากเครื่องคอมพิวเตอร์ แล้วใส่ค่าเวลาเป็นเอาพุท (output) และแทนที่คำสั่งดังกล่าว ลงในเอกสาร HTML โดยอัตโนมัติ ก่อนที่จะส่งไปยังผู้อ่านอีกทีหนึ่ง
อาจจะกล่าวได้ว่า PHP ได้รับการพัฒนาขึ้นมา เพื่อแทนที่ SSI รูปแบบเดิมๆ โดยให้มีความสามารถ และมีส่วนเชื่อมต่อกับเครื่องมือชนิดอื่นมากขึ้น เช่น ติดต่อกับคลังข้อมูลหรือ database เป็นต้น
PHP ได้รับการเผยแพร่เป็นครั้งแรกในปีค.ศ.1994 จากนั้นก็มีการพัฒนาต่อมาตามลำดับ เป็นเวอร์ชั่น 1 ในปี 1995 เวอร์ชั่น 2 (ตอนนั้นใช้ชื่อว่า PHP/FI) ในช่วงระหว่าง 1995-1997 และเวอร์ชั่น 3 ช่วง 1997 ถึง 1999 จนถึงเวอร์ชั่น 4 ในปัจจุบัน
PHP เป็นผลงานที่เติบโตมาจากกลุ่มของนักพัฒนาในเชิงเปิดเผยรหัสต้นฉบับ หรือ OpenSource ดังนั้น PHP จึงมีการพัฒนาไปอย่างรวดเร็ว และแพร่หลายโดยเฉพาะอย่างยิ่งเมื่อใช้ร่วมกับ Apache Webserver ระบบปฏิบัติอย่างเช่น Linux หรือ FreeBSD เป็นต้น ในปัจจุบัน PHP สามารถใช้ร่วมกับ Web Server หลายๆตัวบนระบบปฏิบัติการอย่างเช่น Windows 95/98/NT เป็นต้น
รายชื่อของนักพัฒนาภาษา PHP ที่เป็นแก่นสำคัญในปัจจุบันมีดังต่อไปนี้
ในกรณีของ Apache เราสามารถใช้ PHP ได้สองรูปแบบคือ ในลักษณะของ CGI และ Apache Module ความแตกต่างอยู่ตรงที่ว่า ถ้าใช้ PHP เป็นแบบโมดูล PHP จะเป็นส่วนหนึ่งของ Apache หรือเป็นส่วนขยายในการทำงานนั่นเอง ซึ่งจะทำงานได้เร็วกว่าแบบที่เป็น CGI เพราะว่า ถ้าเป็น CGI แล้ว ตัวแปลชุดคำสั่งของ PHP ถือว่าเป็นแค่โปรแกรมภายนอก ซึ่ง Apache จะต้องเรียกขึ้นมาทำงานทุกครั้ง ที่ต้องการใช้ PHP ดังนั้น ถ้ามองในเรื่องของประสิทธิภาพในการทำงาน การใช้ PHP แบบที่เป็นโมดูลหนึ่งของ Apache จะทำงานได้มีประสิทธิภาพมากกว่า
ต่อไปนี้เราจะมาทำความรู้จักกับภาษา PHP และทำความเข้าใจการทำงาน รวมถึงคำสั่งพื้นฐานต่างๆ ที่ใช้ในการเขียนสคริปต์ในภาษา PHP
เราสามารถวางคำสั่ง PHP ไว้ภายในเอกสาร HTML ตามที่ต้องการได้
อาจจะสลับกับ Tag ของภาษา HTML ก็ได้ ตัวอย่างเช่น
| <HTML>
<HEAD><TITLE> My Homepage </TITLE></HEAD> <BODY BGCOLOR=#FFFFFF> <H1><? echo "Hello World"; ?></H1> Your web browser is <? echo $HTTP_USER_AGENT; ?>. </BODY> </HTML> |
คำสั่งแรกที่ง่ายที่สุดสำหรับการเรียนรู้ ก็คือคำสั่ง
echo แล้วตามด้วยข้อความหรือสตริงค์ (string)
ข้อความในภาษา PHP จะเริ่มต้นและจบด้วย double quote (") เหมือนในภาษาซี
ตัวอย่าง แสดงข้อความลงในเอกสาร HTML
| <? echo "Hello World!"; ?> |
โปรดสังเกตว่า คำสั่งแต่ละคำสั่งในภาษา PHP จะจบท้ายคำสั่งด้วย semicolon (;) เหมือนในภาษาซี
คำสั่งหรือฟังก์ชันในภาษา PHP นั้นจะเขียนด้วยตัวพิมพ์เล็กหรือใหญ่ ก็ได้ (case-insensitive)
| $mystring = "Hello World!"; $myinteger = 1031; $myfloat = 3.14; |
ถ้าเราต้องการจะแสดงค่าของตัวแปร ก็อาจจะใช้คำสั่ง
echo ได้ ตัวอย่างเช่น
| echo "$mystring\n"; echo "$myinteger\n"; echo "$myfloat\n"; |
สัญลักษณ์ \n หมายถึงการขึ้นบรรทัดใหม่ เป็น escape
character ตัวหนึ่ง (สำหรับตัวอื่นๆ โปรดดูในตาราง) เมื่อพิมพ์ข้อความเป็นเอาพุต
และโปรดสังเกตว่า สำหรับการใช้งานภายในเอกสาร HTML การขึ้นบรรทัดใหม่โดยใช้ \n
จะแตกต่างจากการขึ้นบรรทัดโดยใช้ <BR> ใน HTML
| <? $mystring = "Hello World!"; $myinteger = 1031; $myfloat = 3.14; echo "$mystring<BR>\n"; |
Escaped characters
| \n | newline |
| \r | carriage |
| \t | horizontal tab |
| \\ | backslash |
| \$ | dollar sign |
| \" | double-quote |
| %% | percent |
ตัวแปรตัวหนึ่ง อาจจะมีข้อมูลหลายแบบในช่วงเวลาที่ต่างกัน
แต่การจะใช้งานบ้างครั้งจะต้องดูด้วยว่า เมื่อไหร่จะใช้เป็นตัวเลขเท่านั้น และไม่ใช้กับข้อความเป็นต้น
ตัวอย่างเช่น
| <?
$x = 10; ?> |
ในกรณีนี้ เรากำหนดในตอนแรกว่า $x ให้เก็บค่า 10 ซึ่งเป็นจำนวนเต็ม
ถ้าเรานำมาบวกกับ 15.5 ผลที่ได้ก็จะเป็น 25.5 ซึ่งกลายเป็นเลขทศนิยม แล้วเก็บไว้ในตัวแปร
$y ต่อมากำหนดให้ตัวแปร $x เก็บสตริงค์ที่เก็บข้อความ "abc" ถ้าเรานำมาบวกกับ 15.5
กรณีนี้ก็จะให้ผลที่ได้ไม่ถูกต้อง เนื่องจากไม่สามารถนำข้อความมาบวกกับตัวเลขได้
แต่ PHP อนุญาตให้เราทำเช่นนั้นได้ในบางกรณี สมมุติว่า สตริงค์มีเฉพาะตัวเลขและสามารถเปลี่ยนเป็น
เลขจำนวนเต็ม หรือจำนวนจริงได้โดยอัตโนมัติ เราก็นำสตริงค์นี้มาบวกลบคูณหรือหารกับตัวแปรที่เก็บเป็นตัวเลขได้
ค่าคงที่สำหรับเลขจำนวนเต็ม อาจจะอยู่ในรูปของเลขฐานแปดหรือสิบหกก็ได้
ถ้าเป็นเลขฐานแปดจะมีเลขศูนย์นำ ถ้าเป็นเลขฐานสิบหกจะมี 0x นำหน้า
| <?
$x = ((double)"100.1") + 0.3e+3; $x= ceil(13.45); /* get integer part */ ?> |
| <?
echo gettype(0),"\n"; $var="abc"; ?> |
เราอาจจะไม่ใช้ gettype() ก็ได้ แต่เลือกใช้ฟังก์ชัน
is_long() สำหรับเช็คค่าที่เป็นเลขจำนวนเต็ม, is_string() สำหรับเช็คค่าที่เป็นสตริงค์,
is_double() สำหรับค่าที่เป็นเลขทศนิยม, is_array() สำหรับค่าที่เป็นอาร์เรย์ หรือ
is_object() สำหรับค่าที่เป็นออปเจคจากคลาสแทน ซึ่งจะให้ค่าเท่ากับ true (1) ถ้าตัวแปรมีแบบข้อมูล
ตรงตามที่กำหนด
| <?
unset($a); unset($a); if (is_array($a) == true) { ?> |
โปรดสังเกตว่า เราใช้คำสั่ง unset() เพื่อลบค่าที่ตัวแปรเก็บอยู่ในขณะนั้น ในกรณีนี้ เรากำหนดให้ $a เป็นสตริงค์ในตอนแรก ถ้าเราจะต้องการใช้ตัวแปรตัวเดียวกันนี้ เป็นค่าใหม่แต่เป็นอาร์เรย์ ก็จะใช้คำสั่ง unset() ก่อน
| <? $a=1; echo "\$a=$a <BR>\n"; $test = "test"; $a = 1; |
สำหรับข้อความในภาษา PHP เราอาจจะใช้ single qoute
แทน double quote ได้ แต่เวลาใช้งานร่วมกับ echo หรือ print() จะให้ผลต่างกัน ซึ่งสังเกตได้จากตัวอย่างต่อไปนี้
| <? $a = "aaa"; $b = 'bbb'; echo "$a $b<BR>\n"; echo '$a $b<BR>\n'; ?> |
ตัวแปลคำสั่งจะมองข้ามชื่อตัวแปรและรวมถึงพวก escape sequence ต่างๆด้วยที่อยู่ในข้อความที่ใช้ single quote
| <? # comment $a = 41; // set $a to 41. $b =10; // set $b to 10. $b += $a; /* add $a to $b */ echo $b," \n"; ?> |
กำหนดให้ $x มีค่าเท่ากับ 7 และ $y มีค่าเท่ากับ 4
| $x + $y | 11 |
| $x - $y | 3 |
| $x * $y | 28 |
| $x / $y | 1.75 |
| $x % $y | 3 |
กำหนดให้ $x มีค่าเท่ากับ 2.5 และ $y มีค่าเท่ากับ 4
| $x + $y | 6.5 |
| $x - $y | -1.5 |
| $x * $y | 1.0 |
| $x / $y | 0.615 |
| $x % $y | 2 |
โปรดลองทำตามตัวอย่างแล้วสังเกตผลลัพธ์ที่ได้ในแต่ละกรณี
| <? $x=3; echo $x++,"<BR>\n"; echo $x,"<BR>\n"; $x=3; $x=3; $x=3; |
| $x=0; $x += 1; // the same as $x = $x + 1; $x--; // the same as $x = $x - 1; $x *= 3; // the same as $x = $x * 3; $x /= 2; // the same as $x = $x / 2; $x %= 4; // the same as $x = $x % 4; $x=""; |
จากตัวอย่างข้างบน ในกรณีของการต่อสตริงค์ เราจะใช้จุด (.) เป็นโอเปอร์เรเตอร์
| <?
$a = "var1"; ?> |
จากตัวอย่างข้างบน เรากำหนดให้ตัวแปร $a เก็บสตริงค์ "var1" และจะใช้เป็นชื่อของตัวแปรอีกตัวหนึ่ง โดยทางอ้อม $$a เป็นการอ้างถึงตัวแปรที่มีชื่อเดียวกับค่าของตัวแปร $a (ในกรณีนี้คือ var1) ดังนั้นถ้าเราเขียนว่า $$a หรือ $var1 ก็หมายถึงตัวแปรตัวเดียวกัน ถ้าต้องการแสดงค่าของ $$a โดยใช้คำสั่ง echo โดยอยู่ในสตริงค์ (ระหว่าง double quotations) เราจะต้องเขียน ${$a} ไม่ใช่ $$a เพราะว่า ถ้าเขียนตามแบบหลัง ตัวแปลคำสั่งจะอ่านค่า $a ก่อนแล้วแทนที่ลงในข้อความ ซึ่งจะได้ $var1แทนที่จะเป็นการอ่านค่าของ $var1
เทคนิคนี้ยังสามารถใช้ได้กับฟังก์ชัน ตัวอย่างเช่น
| <? function foobar() { echo "foobar<BR>\n"; } function callFunc ($f) { callFunc("foobar"); ?> |
ตัวอย่างข้างบนอาจจะทำให้เกิดปัญหาถ้าสมมุติว่า $f
เป็นชื่อของฟังก์ชันที่ไม่มีอยู่จริง วิธีตรวจสอบคือ การใช้ฟังก์ชัน function_exists()
ดังต่อไปนี้
| <? function MyFunc() { print ("ok..<BR>\n"); } $f="myFunc"; ?> |
| <?
define(PI, 3.141592654); echo (PI/3),"<BR>\n"; ?> |
นอกจากสัญลักษณ์ที่ผู้ใช้นิยามขึ้นมาได้เองแล้วยังมีสัญลักษณ์กลุ่มหนึ่งที่ได้มีการนิยามไว้ก่อนแล้วในภาษา
PHP ตัวอย่างเช่น
| __FILE__ | เก็บชื่อของไฟล์สคริปต์ |
| __LINE__ | เก็บเลขบรรทัดภายในสคริปต์ในตอนที่ใช้ |
| TRUE | มีค่าเป็นจริง |
| FALSE | มีค่าเป็นเท็จ |
| PHP_VERSION | เก็บเวอร์ชั่นของ PHP |
| PHP_OS | เก็บชื่อระบบปฏิบัติการที่ใช้ เช่น Linux |
| <?
$x = 1; ?> |
เริ่มต้นด้วยการกำหนดตัวแปร $x ให้มีค่าเป็นหนึ่ง ซึ่งในกรณีนี้ เราใช้เป็นเลขฐาน ในการคำนวณเลขยกกำลังสอง เมื่อเข้าสู่การวนลูปแบบ while-do จะมีการตรวจดูเงื่อนไข ของการวนลูปในแต่ละครั้งว่า เงื่อนไขเป็นจริงอยู่หรือไม่ ในกรณีนี้ เรากำหนดเงื่อนไขในการวนลูปไว้ว่า ถ้าค่าของ $x มีค่าน้อยกว่าหรือเท่ากับ 10 ก็ให้ทำคำสั่งที่อยู่ภายในลูป ซึ่งก็คือ echo $x*$x,"\n"; โดยจะพิมพ์ค่าของผลคูณซึ่งหมายถึงเลขยกกำลังสองนั่นเอง หลังจากนั้น ก็ให้เพิ่มค่าของ $x ทีละหนึ่งในการวนลูปแต่ละครั้ง ค่าของ $x จะเพิ่มขึ้นเรื่อยๆจนมีค่ามากกว่า 10 เมื่อถึงเวลานั้น ก็จะเป็นการจบการวนลูป เพราะว่า เราจะได้ว่า เงื่อนไข ($x <= 10) มีค่าเป็นเท็จ
สมมุติว่า ถ้าเปลี่ยนจาก $x++ เป็น $x-- ปัญหาก็จะเกิดตามมาเวลาใช้งาน คือ แทนที่จะวนลูปแค่สิบครั้ง ก็กลับกลายเป็นว่า เป็นการวนลูปนับครั้งไม่ถ้วน เพราะว่า ค่าของ $x จะลดลงเรื่อยๆในการวนลูปแต่ละครั้ง คือเป็นลบ และค่าเป็นลบจะน้อยกว่า 10 เสมอ (ยกเว้นแต่ว่า เมื่อถึงจุดเวลาหนึ่งค่าเป็นลบมากๆ จะกระโดดกลับเป็นบวก)
ตัวอย่างการใช้ do-while loop เพื่อคำนวณค่าเลขยกกำลังสอง
ซึ่งมีเลขฐานตั้งแต่ 1 ถึง 10
| <?
$x = 1; ?> |
โปรดสังเกตความแตกต่างระหว่างการใช้ while-do และ do-while โดยเฉพาะตรงเงื่อนไข ในการจบการวนลูป ในกรณีของ do-while เราจะกระทำขั้นตอนในลูปก่อนหนึ่งครั้ง แล้วค่อยตรวจดูว่า เงื่อนไขในการวนลูปเป็นจริงหรือไม่ ความแตกต่างนี้ เราสามารถจำได้ง่ายๆ คือว่า ถ้าใช้ do-while จะต้องมีการทำคำสั่ง ภายในลูปหนึ่งครั้งเสมอ แม้ว่าเงื่อนไขโดยเริ่มต้นจะเป็นเท็จก็ตาม ซึ่งแตกต่างจาก while-do ถ้าเงื่อนไขเป็นเท็จตั้งแต่เริ่ม ก็จะไม่มีการทำคำสั่งที่อยู่ในลูป
อีกแบบหนึ่งสำหรับการวนลูปคือใช้ for-loop ทำได้ตามตัวอย่างต่อไปนี้
| <?
for ($x = 1; $x <=10; $x++) { ?> |
ในบรรทัดที่เริ่มต้นด้วย for ระหว่างวงเล็บเปิดและปิด จะถูกแบ่งเป็นสามส่วนโดยเครื่องหมาย semicolon (;) ในส่วนแรกเราสามารถใส่คำสั่งที่ต้องการจะกระทำก่อนเข้าลูป ส่วนแรกนี้จะมีหรือไม่มีก็ได้ ในส่วนที่สองจะเป็นเงื่อนไขสำหรับการทำ loop และในส่วนที่สามจะคำสั่งที่จะต้องทำเป็นการจบท้ายลูปในแต่ละครั้ง หลักการทำงานของ for-loop จะคล้ายกับ while-do-loop
การใช้งาน for-loop และวางตำแหน่งส่วนต่างๆ อาจจะไม่จำเป็นต้องทำเหมือนกันแต่ให้ผลเหมือนกัน
เช่น
| <?
$x=1; $x=1; ?> |
จากตัวอย่างข้างบนที่ผ่านๆมา เป็นการวนลูปจะใช้การนับเลขเพิ่มขึ้นทีละหนึ่ง
เรายังสามารถเขียนใหม่โดยเป็นการนับเลขลดลง ยกตัวอย่างเช่น เราต้องการจะพิมพ์ตัวเลขเรียงลำดับจาก
10,9,8...,1 ก็อาจจะเขียนคำสั่งได้ดังนี้
| <?
for ($x=10 ; $x >0; $x--) { ?> |
การใช้งาน for-loop ก็จะเหมือนกับเวลาใช้ในภาษาซี
ในหลายๆเรื่อง เช่น เราสามารถใส่คำสั่งได้ มากกว่าหนึ่งโดยใช้เครื่องหมาย (,) เป็นตัวแยก
ตัวอย่างเช่น
| <?
for ($x=1, $y=0 ; $x < 10; $x++, $y--) { ?> |
| <?
if ($x == 0) ?> |
จากตัวอย่าง ถ้า $x มีค่าเป็นศูนย์ตามเงื่อนไข ก็จะทำคำสั่ง echo $x," is zero<BR>\n"; ถ้าเงื่อนไขแรกเป็นเท็จ ก็จะเงื่อนไขที่สองว่า $x มีค่ามากกว่าศูนย์หรือไม่ ถ้าใช้ ก็ทำคำสั่ง echo $x," is positive<BR>\n"; ถ้าเงื่อนที่สองเป็นเท็จอีก ก็ให้ทำคำสั่งในกรณีสุดท้ายคือ $x จะต้องมีค่าเป็นลบ
ถ้าในแต่ละกรณีต้องมีการทำคำสั่งมากกว่าหนึ่ง คือ
เป็นกลุ่มคำสั่ง จะต้องใช้ { } มากำหนดขอบเขต (scope) เช่น
| <?
if ($x == 0) { ?> |
โปรดสังเกตว่า { } ไม่ต้องมีเครื่องหมาย ; ต่อท้าย
ในภาษา PHP มีการกำหนด elseif (เงื่อนไข) ขึ้นมาใช้ ซึ่งไม่มีอะไรแตกต่างจาก else if (เงื่อนไข)
โครงสร้างแบบ (เงื่อนไข) ? นิพจน์ : นิพจน์ แบบที่ใช้กันในภาษาซีนั้น
ก็ใช้ได้เช่นกัน ตัวอย่างเช่น
| <?
$x= -0.1035; ?> |
| <?
unset($a); $i=0; ?> |
คำสั่ง continue บังคับให้ไปเริ่มต้นทำขั้นตอนในการวนลูปครั้งต่อไป ส่วน break นั้นส่งผลให้หยุดการทำงานของลูป
| switch ($day) { case 1 : echo "Monday<BR>\n"; break; case 2 : echo "Tuesday<BR>\n"; break; case 3 : echo "Wednesday<BR>\n"; break; case 4 : echo "Thurday<BR>\n"; break; case 5 : echo "Friday<BR>\n"; break; case 6: echo "Saturday<BR>\n"; break; case 7 : echo "Sunday<BR>\n"; break; default : echo "error<BR>\n"; } |
ถ้าตัวแปร $day มีค่าที่อยู่ระหว่าง 1 ถึง 7 ก็จะพิมพ์ชื่อวันเป็นภาษาอังกฤษ
ถ้าตัวแปรมีค่านอกเหนือจากนั้น ซึ่งในกรณีจะเป็น default ในโครงสร้างแบบ switch-case
ก็จะพิมพ์คำว่า error เพื่อให้ผู้ใช้ทราบ
โปรดสังเกตว่า ในแต่ละกรณี จะต้องจบด้วยคำสั่ง break; ยกเว้นแต่ของ default
ซึ่งจะมีหรือไม่ก็ได้ ถ้าเราไม่ได้ใส่คำสั่ง break; เอาไว้ โปรแกรมก็จะกระทำคำสั่งทุกคำสั่งในกรณีที่อยู่ถัดมา
การจำแนกกรณีไม่จำเป็นต้องอาศัยเฉพาะตัวแปรที่เก็บค่าจำนวนเต็มเท่านั้น
ข้อมูลแบบอื่นก็ใช้ได้ เช่น ใช้ข้อความเป็นตัวจำแนกกรณี เช่น
| switch ($answer) { case "yes" : echo "The user said 'yes'.\n"; break; case "no" : echo "The user said 'no'.\n"; break; default: echo "The user said neither 'yes' nor 'no'.\n"; } |
โปรดสังเกตว่า การจำแนกโดยใช้ข้อความนี้ จะดูความแตกต่างระหว่างตัวพิมพ์เล็กหรือใหญ่ด้วย
ในบางครั้งเราอาจจะไม่จำเป็นต้องใส่ break; ก็ได้
ตัวอย่างเช่น
| switch ($answer) { case "yes" : case "no" : echo "The user said '",$answer,"'.\n"; break; default: echo "The user said neither 'yes' nor 'no'.\n"; } |
| == | เท่ากับ |
| > | มากกว่า |
| >= | มากกว่าหรือเท่ากับ |
| < | น้อยกว่า |
| <= | น้อยกว่าหรือเท่ากับ |
| != | ไม่เท่ากับ |
เราสามารถสร้างเงื่อนไขจากการเปรียบเทียบมากกว่าน้อยกว่านี้ได้ซับซ้อนมากขึ้นโดยใช้
"และ" "หรือ" "ไม่" มาประกอบ ตัวอย่างเช่น
| ($x == -1) || ($x==1) | ถ้า $x มีค่าเท่ากับ -1 หรือ 1 จะได้เงื่อนไขเป็นจริง นอกเหนือจากนั้นเป็นเท็จ |
| ($x < 10) && ($x >1) | ถ้า $x มีค่าน้อยกว่า 10 และ มากกว่า 1 ก็จะได้เงื่อนไขที่เป็นจริง นอกเหนือจากนั้นเป็นเท็จ |
| ! ($x==0) | ถ้า $x ไม่เท่ากับศูนย์ ก็ได้เงื่อนไขเป็นจริง นอกเหนือจากนั้นเป็นเท็จ |
การใช้ || และ && มีลักษณะการทำงานเหมือนในภาษาซี อย่างกรณีของ ($x || $y) ถ้า $x เป็นจริงจะไม่มีการพิจารณา $y และสำหรับ ($x && $y) ถ้า $x เป็นเท็จแล้วจะไม่มีการพิจารณา $y ต่อ
| $x & $y | AND |
| $x | $y | OR |
| $x ^ $y | XOR |
| ~ $x | NOT |
| $x << $y | SHIFT LEFT |
| $x >> $y | SHIFT RIGHT |
| $myarray[]=3; $myarray[]=1.1; $myarray[]="abc"; |
แต่เมื่อใช้อาร์เรย์ไป ขนาดของมันจะปรับเปลี่ยนได้ คือขยายจำนวนข้อมูลที่เก็บอยู่ภายในอาร์เรย์ ตามจำนวนข้อมูลที่เราใส่เพิ่มเข้าไป จากตัวอย่างข้างบน ในกรณีที่เรามิได้กำหนดเลขดัชนี (index) ก็หมายความว่า จะมีการขยายขนาดของอาร์เรย์เพิ่มขึ้นอีกหนึ่งโดยอัตโนมัติ ทุกครั้งที่เราใส่ข้อมูลที่อยู่ทางขวา และค่าที่เรากำหนดจากทางขวามือ และจะเก็บไว้ในที่ใหม่ของอาร์เรย์ เราไม่ต้องคำนึงถึงเรื่องการจอง หรือ ปลดปล่อยหน่วยความจำของอาร์เรย์ เหมือนอย่างในกรณีของอาร์เรย์ แบบไดนามิกในภาษาซี
นอกจากนั้นข้อมูลแต่ละตัวในอาร์เรย์ไม่จำเป็น ต้องเป็นข้อมูลชนิดเดียวกัน
เช่น อาจจะมีทั้งจำนวนเต็ม เลขทศนิยม และข้อความ ปะปนกันไป ตัวอย่างเช่น
| <?
$myarray[0] = 1; $myarray[1] = "abc"; $myarray[2] = 1.3; $myarray[]= 13+10; // the same as $myarray[3]= 13+10;
for ($i=0; $i < 4; $i++) { ?> |
ถ้าเราต้องการจะทราบจำนวนของข้อมูลที่มีอยู่ในอาร์เรย์เราจะใช้คำสั่ง count()
เทคนิคหนึ่งที่ใช้ในการสร้างอาร์เรย์ที่เก็บหลายๆข้อความหรือสตริงค์
คือ แทนที่เราจะกำหนดค่าของสมาชิก ในอาร์เรย์ทีละตัว เราจะสร้างได้โดยอัตโนมัติ
โดยเก็บสตริงค์เหล่านั้นไว้ในสตริงค์เพียงอันเดียวโดยมีสัญลักษณ์ | เป็นตัวแยก
และก็แล้วใช้ฟังก์ชันเป็นตัวแบ่งเพื่อสร้างอาร์เรย์อีกที ตามตัวอย่าง
| <? // create empty array $a=array(); // define string containing color names separated by | (pipe)
// create array from string |
ลองดูอีกตัวอย่างหนึ่งที่ใช้ฟังก์ชัน explode() สร้างอาร์เรย์โดยอัตโนมัตสำหรับใส่ไว้ใน
FORM ในส่วนของ SELECT เป็นเมนูให้เลือก
| <? // create selection list from a given string function str2select($str, $delim) { $options = explode($delim,$str); $num = count($options); for( $i=0; $i < $num;$i++) { echo "<option> $options[$i]</option>\n"; } } $select_str="10 บาท|20 บาท|30 บาท|40 บาท|50 บาท|100 บาท|200 บาท|500 บาท|1000 บาท"; ?> <FORM> |
| <?
$dim = 3; ?> |
สังเกตว่า สำหรับการใช้งานตัวแปรที่เป็นอาร์เรย์ เราไม่จำเป็นต้องแจ้งใช้ตัวแปรที่เป็นอาร์เรย์ พร้อมกำหนดขนาดก่อนการใช้งาน
การเก็บข้อมูลในอาร์เรย์แบบนี้จะใช้กับข้อมูลที่จัดเก็บเป็นคู่ๆไป
ซึ่งแตกต่างจากอาร์เรย์แบบแรกที่เราได้ทำความรู้จัก ตัวอย่างเช่น ใช้ทำ lookup
table เช่น สมมุติว่า "red" ให้แทนค่า 0xff0000 "green" ให้แทนค่า 0x00ff00
และ "blue" 0x0000ff โดยเก็บไว้ในอาร์เรย์ชื่อ $color_table ตามตัวอย่างต่อไปนี้
| $color_table["red"] = 0xff0000; $color_table["green"] = 0x00ff00; $color_table["blue"] = 0x0000ff; $color_name= "red"; |
หรืออีกรูปแบบหนึ่งที่เขียนสร้างอาร์เรย์ดังกล่าวได้
โดยใช้คำสั่ง array ()
| $color_table = array( "red" => 0xff0000, "green" => 0x00ff00, "blue" => 0x0000ff ); |
เราอาจจะสร้างอาร์เรย์เป็นสองมิติก็ได้ เช่น
| <? $countries = array ( "thailand" => array ( "zone" => "Asia", "D_NAME" => ".th"), "malasia" => array ( "zone" => "Asia", "D_NAME" => ".my"), "india" => array ( "zone" => "Asia", "D_NAME" => ".in"), "holland" => array ( "zone" => "Europe", "D_NAME" => ".nl"), "france" => array ( "zone" => "Europe", "D_NAME" => ".fr") ); echo "domain name=".$countries[ "thailand"]["D_NAME"]."<BR>\n";
|
| <? unset($a); $a = array( "a" => 10, "b" => 20, "c" => 30 ); while (list($key,$value) = each($a)) { |
ฟังก์ชัน each() จะอ่านข้อมูลทีละคู่จากอาร์เรย์แบบเชื่อมโยงมาแล้วส่งไปยังฟังก์ชัน
list() ซึ่งจะทำหน้าที่แยกเก็บ ซึ่งในกรณีก็คือ เก็บไว้ในตัวแปร $key และ $value
หลังจากนั้น เราก็สามารถนำค่าของตัวแปร ไปใช้งานตามที่ต้องการได้
การสร้างฟังก์ชันขึ้นใช้เองทำได้โดย ใช้โครงสร้าง
function function_name ($arg1, $arg2, .., $argN)
{
....
}
และฟังก์ชันจะให้ค่ากลับคืนหรือไม่ก็ได้ ถ้าต้องการให้ค่ากลับคืนจากการทำงานของฟังก์ชัน ก็จะใช้คำสั่ง return นอกจากนั้น PHP ยังสนับสนุน default parameter ด้วย
ตัวอย่างเช่น การหาค่าสัมบรูณ์ของตัวเลข
| <?
function myabs ($x) { echo myabs(-6),"<BR>\n"; ?> |
การหาค่าดังกล่าวของตัวเลขใดๆ เราสามารถใช้ฟังก์ชัน abs() หรือเราเขียนขึ้นเองก็ได้ตามตัวอย่างข้างบน
| <?
function minmax (&$a,&$b) { $x=10; ?> |
ฟังก์ชัน minmax() เป็นตัวอย่างของฟังก์ชันที่ใช้หลักการของ call-by-reference โปรดสังเกตที่เครื่องหมาย & ที่วางอยู่หน้าตัวแปรที่เป็นอาร์กิวเมนต์ของฟังก์ชัน การเรียกใช้ฟังก์ชันแบบ call-by-reference ช่วยให้เราสามารถผ่านตัวแปรไปยังฟังก์ชัน และให้ฟังก์ชันสามารถเปลี่ยนแปลงแก้ไขค่าของตัวแปรนั้นได้
| <?
function swap(&$a, &$b) { $x=10; ?> |
ตัวอย่างข้างบน ก็แสดงให้เห็นวิธีการใช้ call-by-reference อีกเช่นกัน
มีข้อสังเกตอยู่ว่า การใช้ call-by-reference ไม่จำเป็นต้องทำตอนนิยามฟังก์ชันเท่านั้น
แต่อาจจะทำตอนผ่านตัวแปรเมื่อเรียกใช้งานจริง ตัวอย่างเช่น
| <?
function swap($a, $b) { $x=10; ?> |
จากตัวอย่างนี้ เราแก้ไขฟังก์ชัน swap() ทำให้ไม่สนับสนุน
call-by-reference ดังนั้นเพื่อจะใช้งานได้อย่างถูกต้อง เราก็จะต้องใช้ reference
ของตัวแปรเป็นอาร์กิวเมนต์ของฟังก์ชัน ในเวลาที่เรียกใช้ ซึ่งก็คือ swap(&$x,&$y)
ถ้าเราไม่ทำอย่างนี้ เช่น เขียนว่า swap($x,$y) ก็จะไม่มีการสลับค่าของตัวแปรทั้งสอง
เนื่องจากว่า เมื่ออยู่ภายในฟังก์ชัน swap() แล้ว เราไม่สามารถเปลี่ยนแปลงค่าของตัวแปรเหล่านั้นได้
คืออ่านได้ แต่ไม่สามารถกำหนดค่าใหม่ได้
ตัวอย่างการใช้งาน
| <?
srand( date("s") ); ?> |
คำสั่งนี้จะสร้างตัวเลขโดยการสุ่มเลือกเป็นจำนวน 10 ตัวเลข และพิมพ์ออกทางเอาพุต
ตัวอย่างการใช้งานเพิ่มเติมในรูปของฟังก์ชัน
| <?
function randInt($low,$high) { ?> |
ตัวอย่างนี้จะสร้างตัวเลขโดยสุ่มที่อยู่ระหว่างเลขจำนวนเต็มสองค่า และเงื่อนไขของการใช้ฟังก์ชันนี้คือ $low จะต้องมีค่าน้อยกว่า $high และทั้งสองต้องเป็นเลขจำนวนเต็ม
ตัวอย่างการใช้งานเพิ่มเติมในรูปของฟังก์ชันเพิ่มเติม
| <? function randStr($len) { srand ( date("s") ); for ($i=0; $i < $len; $i++) { $ret_str .= chr( (rand() % 26)+97 ); } return $ret_str; } echo randStr(40); ?> |
ตัวอย่างนี้จะสร้างสตริงค์แบบสุ่มที่มีความยาวตามที่กำหนดและสร้างขึ้นจากตัวอักขระภาษาอังกฤษ
| <? function factorial ($n) { if ( ($n == 0) || ($n == 1) ) return 1; else return $n*factorial($n-1); } echo factorial(4); ?> |
เงื่อนไขก็ใช้ฟังก์ชัน factorial() จากตัวอย่างข้างบน คือ $n จะต้องเป็นตัวแปรที่เก็บค่าที่เป็นเลขจำนวนเต็ม และไม่เป็นลบ ถ้าเราต้องการจะเขียนฟังก์ชันให้มีความปลอดภัยในการใช้งาน เราก็อาจจะเพิ่มเงื่อนไข เพื่อตรวจเช็คดูก่อนว่า ผู้ใช้ผ่านค่าของตัวแปรที่ตรงตามต้องการหรือไม่ เช่น ไม่ผ่านค่าที่เป็นสตริงค์ หรือเป็นเลขทศนิยม หรือค่าที่เป็นลบ เป็นต้น
ตัวอย่าง การค้นหาข้อมูลแบบ Binary Search ในอาร์เรย์ที่มีการเรียงข้อมูลจากน้อยไปมาก
| <?
function binSearch(&$key,&$array, $left, $right) if ($left > $right) $num=100; echo binSearch(13, $sorted_array, 0, $num); ?> |
ตัวอย่าง การสร้างสตริงค์แบบสุ่มอีกแบบหนึ่งซึ่งอาจจะนำไปใช้ในการสร้าง
one-time password ( OTP)
| <?
function randomToken($len) { echo randomToken(13)," "; ?> |
หมายเหตุ: การกำหนดค่า seed สำหรับฟังก์ชัน srand() นอกจะใช้ date("s") เป็นตัวกำหนดค่าแล้ว เราอาจจะใช้ฟังก์ชันอื่นก็ได้ เช่น srand((double)microtime()*1000000);
การใช้ตัวแปรแบบ global ภายในฟังก์ชัน
บางครั้งเราไม่ต้องการที่จะผ่านตัวแปรเป็นอาร์กิวเมนต์ของฟังก์ชัน
เพื่อนำไปใช้ภายในฟังก์ชันเหล่านั้น ก็จะทำได้โดยการแจ้งใช้ตัวแปรที่มีชื่อเหมือนตัวแปรภายนอกที่เราต้องการใช้
ให้เป็น global หรือใช้ผ่านตัวแปรที่เป็นอาร์เรย์ของ PHP ที่มีชื่อว่า $GLOBALS
ดังตัวอย่างต่อไปนี้
| <? $a = 10; $b = 20; function getMin ( ) { if ($a < $b) function getMin2 () { echo getMin()."<BR>\n"; |
ในกรณีนี้เราต้องการจะใช้ตัวแปร $a และ $b ซึ่งอยู่นอกฟังก์ชัน getMin() เพื่อเช็คดูว่า ค่าของตัวแปรใดมีค่าน้อยกว่ากัน ถ้าเราไม่แจ้งใช้ global $a, $b; ตามตัวอย่างแล้ว $a และ $b จะกลายเป็นตัวแปรภายในแม้ว่าจะชื่อเหมือนกันตัวแปรภายนอกที่มีอยู่แล้วก็ตาม ทำให้ได้ผลการทำงานไม่ถูกต้องตามที่ต้องการ
ฟังก์ชัน getMin() อีกรูปแบบหนึ่ง โดยไม่ใช้ตัวแปรแบบ
global ภายในฟังก์ชัน และใช้วิธีผ่านค่าแทน
| <? $a = 10; $b = 20; function getMin ($a, $b) { echo getMin($a, $b)."<BR>\n"; |
| function MyFunc() { static $num_func_calls = 0; echo "my function\n"; return ++$num_func_calls; } |
ทุกครั้งที่มีการเรียกใช้ฟังก์ชันดังกล่าว ตัวแปรชื่อ
$num_func_calls ซึ่งมีค่าเริ่มต้นเป็นศูนย์ในตอนแรก จะเพิ่มค่าที่เก็บขึ้นทีละหนึ่ง
| <? function foobar() { return array ("foo", "bar", 0xff); } list ($foo, $bar, $num) = foobar(); |
จากตัวอย่าง ฟังก์ชัน foobar() จะให้ค่ากลับคืนเป็น array ประกอบด้วยสามสมาชิก ค่าที่ได้จากฟังก์ชันนี้ก็จะส่งไปยังฟังก์ชัน list() เพื่อให้เก็บแยกลงในตัวแปรตามชื่อที่กำหนดคือ $foo, $bar และ $num ตามลำดับ
| <form action="login.php3" method="post"> <table> <tr><td>login:</td> <td><input type="text" name="login"></td> </tr><br> <tr><td>password:</td> <td><input type="text" name="password"></td> </tr><br> </table> <p><input type="submit"> </form> |
ภายในสคริปต์ login.php3 เราสามารถอ่านข้อมูลที่ส่งมาได้ ในกรณีนี้ ที่เราสนใจคือ ค่าจาก login และ password ที่อยูในฟอร์ม และสามารถจะอ่านข้อมูลเหล่านั้นได้ เพราะ PHP จะเก็บข้อมูลไว้ในตัวแปรชื่อ $login และ $password ตามลำดับ ตัวอย่างเช่น login.php3 อาจจะเป็นสคริปต์ง่ายๆดังนี้
ตัวอย่างไฟล์ login.php3
| <HTML> <HEAD><TITLE> Result </TITLE></HEAD> <BODY> <P> Your login = <? echo "$login" ?> <BR> Your password = <? echo "$password"; ?> </BODY> </HTML> |
เราสามารถอ่านข้อมูลที่ได้จากการส่งแบบ GET ได้เช่นกัน
ตัวอย่างเช่น
| <a href="print.php3?ID=103543564&mode=plaintext"> click </a> |
เมื่อผู้ใช้คลิ้กที่ link ก็จะติดต่อกับสคริปต์ที่ชื่อว่า
print.php3 โดยผ่านข้อมูลสองตัวคือ ID และ mode
ภายในสคริปต์ เราก็ใช้ $ID และ $mode สำหรับอ่านค่าของข้อมูลที่ส่งมา ในตัวอย่างนี้
$ID จะได้ค่าเป็น "103543564" และ $mode ได้ค่า "plaintext"
| <? function getBrowserName() { global $HTTP_USER_AGENT; $browser=strtoupper($HTTP_USER_AGENT); if (strstr($browser,"MSIE.")) return "MS Internet Explorer"; else if (strstr($browser,"MOZILLA")) return "Netscape"; else return ""; } $name = getBrowserName(); ?> |
จากตัวอย่าง เราสามารถใช้ตัวแปรดังกล่าวในการตรวจดูว่า
ผู้ใช้ได้ใช้ web browser ตัวไหน เช่น ระหว่าง IE (Microsoft Explorer) หรือ Mozilla
(Netscape)
คลาสคือโครงสร้างที่ประกอบด้วยสมาชิก (class members) หรือคุณสมบัติ (properties) ตามแต่จะเรียก และ ฟังก์ชันสมาชิก (member functions) การนิยามคลาสขึ้นมาใช้งานจะเริ่มด้วย class { ... } โดยข้างในจะมีส่วนของตัวแปรสมาชิก และฟังก์ชันสมาชิกตามลำดับ ฟังก์ชันที่มีชื่อเดียวกับคลาสจะเรียกว่า class constructor ทุกครั้งที่มีการสร้างออปเจคจากคลาสโดยใช้คำสั่ง new ฟังก์ชันที่ทำหน้าที่เป็น class constructor ก็จะถูกเรียกมาทำงานก่อนทุกครั้ง ประโยชน์ของการใช้งานก็เช่น ใช้กำหนดค่าเริ่มต้น หรือเตรียมพร้อมก่อนที่จะเริ่มใช้ออปเจค
ลองดูตัวอย่าง การเขียนคลาสสำหรับแบบข้อมูลเชิงนามธรรม
(Abstract Data Type) ที่เรียกว่า stack การทำงานของ stack ก็เป็นดังนี้ ถ้าเราใส่ข้อมูลเข้าไป
ข้อมูลเหล่านั้นก็จะถูกเก็บไว้เสมือนกับว่า วางซ้อนกันจากข้างล่างขึ้นข้างบน ถ้าเราจะดึงข้อมูลออกมาใช้ก็จะได้ข้อมูลที่อยู่ข้างบนสุด
ซึ่งก็คือข้อมูลที่เราใส่เข้าไปครั้งล่าสุดนั่นเอง หน้าที่ของ stack ที่สำคัญก็มีเช่น
| push() | ใส่ข้อมูลไว้ใน stack |
| pop() | ดึงข้อมูลออกมา |
| is_empty() | ตรวจดูว่า stack มีข้อมูลอยู่อีกหรือไม่ |
| get_size() | หาจำนวนของข้อมูลที่ถูกเก็บไว้ใน stack |
ตัวอย่างการสร้างคลาส stack ในภาษา PHP ทำได้ดังตัวอย่างต่อไปนี้
| <?
class stack { function stack() { // class constructor function push($elem) { // put an element on stack
function get_size() { // get number of elements
stored function is_empty() { // is stack empty ? function pop() { // retrieve an element from the top
of stack $inst = new stack; // create an object from stack class for ($i=0; $i < 10; $i++) { while (! $inst->is_empty() ) { echo "stack is ".($inst->is_empty() ? "empty." : "not empty.")."<BR>\n"; $inst = 0; // unuse this instance of class stack |
โปรดสังเกตว่า ตัวแปร $this ที่ปรากฎอยู่ในคลาสจะเหมือน this ที่เราใช้ในภาษาซีพลัสพลัส และการนิยามและสร้างฟังก์ชันสมาชิกจะทำภายในคลาสทั้งหมด (เหมือนในภาษาจาวา)
PHP ยังสนับสนุนการสืบทอดคุณสมบัติของคลาส (inheritance)
ทำให้เราสามารถสร้างคลาสขึ้นมาใหม่ โดยใช้คลาสที่มีอยู่เดิมและเพื่อส่วนขยายเข้าไป
การสืบสอดคุณสมบัติจากคลาสหนึ่งไปยังอีกคลาสหนึ่ง จะใช้คำสั่ง extends คล้ายกับของภาษาจาวา
ตามตัวอย่างดังนี้
| <?
class stack { function stack() { function push($elem) { function get_size() { function is_empty() { function pop() { // class LimitedStack is derived from class stack. class LimitedStack extends stack { function LimitedStack ($capacity = 10) {
function is_full() { function push($elem) { $inst = new LimitedStack(5); |
คลาส LimitedStack นี้มีคุณสมบัติที่ได้รับมาจากคลาส stack แต่แตกต่างตรงที่ว่า เราได้กำหนดความจุ ของ LimitedStack เอาไว้ โดยตัวแปร $max_size ผู้ใช้จะต้องกำหนดขนาดความจุของออปเจคจากคลาส LimitedStack ก่อนใช้ ถ้าไม่กำหนดก็จะใช้ค่า 10 เป็นค่าความจุโดยอัตโนมัติตามตัวอย่าง (เป็น default parameter)
เมื่อมีการกำหนดความจุก็จะต้องมีการเขียนฟังก์ชันสมาชิกเพิ่มขึ้นอีก ชื่อ is_full() เพื่อตรวจสอบดูว่า จำนวนของข้อมูลใน stack เท่ากับความจุที่กำหนดไว้แล้วหรือไม่
โปรดสังเกตว่า PHP สนับสนุนการนิยามฟังก์ชันทับฟังก์ชันเดิมของคลาสที่ได้รับคุณสมบัติมา และสิ่งที่จะลืมไม่ได้คือ constructor จากคลาสลูก (child class) จะไม่เรียกใช้ constructor จากคลาสแม่ (parent class) จะต้องมีการเรียกใช้อย่างเจาะจง
ในกรณีที่เราสร้างอาร์เรย์สำหรับเก็บออปเจค เวลาจะใช้ออปเจคแต่ละตัว
จะต้องใช้ตัวแปรช่วยตามตัวอย่างต่อไปนี้
| <? // array of objects class MyObj { function MyObj( $set_id) { function show() { // can create the array of objects // To access each object we must use help variable like follows:
?> |
จากตัวอย่างเราใช้ตัวแปร $tmp ในการเข้าถึงออปเจคแต่ละตัวในถูกเก็บไว้ในอาร์เรย์
$obj_array เนื่องจากเราไม่สามารถเรียกใช้ฟังก์ชันของออปเจคได้โดยตรงถ้าออปเจคอยู่ในอาร์เรย์
เช่น $obj_array[0]->show();
| <? $today = date("Y-m-d"); print "<CENTER>Today is: $today.</CENTER>"; ?> |
"Y-m-d" หมายถึงสตริงค์ที่กำหนดรูปแบบ (formatted string) ของการแสดงวันที่ ในกรณีนี้คือ ปีค.ศ.-เดือน-วัน ตามลำดับ จริงๆแล้วฟังก์ชัน date() จะต้องการอาร์กิวเมนต์สองตัวคือ สตริงค์ที่กำหนดรูปแบบ เช่น "Y-m-d" และค่าของ TimeStamp (integer) ในหน่วยเป็นวินาที นับตั้งแต่ 1 มกราคม 1970 ในกรณีที่เราไม่ได้กำหนด TimeStamp ก็จะหมายถึง TimeStamp เวลาในปัจจุบัน
ถ้าเราต้องการแสดงทั้งเวลาและวันเดือนปี ก็ต้องกำหนดรูปแบบของสตริงค์ใหม่
เช่น "D d F Y h:i:s"
ซึ่งตัวอักษรแต่ละตัวจะมีความหมายและเป็นตัวบ่งบอกหน้าที่ เช่น d ใช้แทนที่วันในหนึ่งเดือน
D ใช้แทนชื่อวันแบบย่อในเจ็ดวัน F ใช้แทนชื่อเดือนในทั้งหมด 12 เดือน Y แทนที่ปีค.ศ.
เป็นเลขสี่หลัก
h i s ใช้แทนชั่วโมง นาที และวินาทีตามลำดับ
| <? $today = date("D d F Y h:i:s"); print "<CENTER>Today is: $today.</CENTER>"; ?> |
สำหรับรายอื่นเพิ่มเติมเกี่ยวกับฟังก์ชัน date() สามารถดูได้จาก
PHP manual
| <? $answer = "Yes"; if ($answer == "yes") echo "yes...\n"; else echo "error!\n"; $answer = strtolower("Yes"); $answer = strtoupper("Yes"); |
ประโยชน์ของฟังก์ชันทั้งสองที่เห็นได้ชัด คือ เอาไว้ใช้แปลงข้อความให้เป็นตัวพิมพ์ใหญ่หรือเล็กทั้งหมด ก่อนที่เราจะใช้ในการเปรียบเทียบข้อความ เช่น ผู้ใช้อาจจะใส่ข้อความไว้ใน $answer ว่า "Yes" "YeS" "yES" หรือ "YES" เป็นต้น แต่เราอยากรู้ว่า ผู้ใช้ใส่คำว่า yes หรือไม่ โดยไม่สนใจว่าจะเป็น ตัวพิมพ์ใหญ่หรือเล็ก ในกรณีนี้ เราก็แปลงให้เป็นตัวพิมพ์เล็กก่อน แล้วก็นำมาเปรียบเทียบ
สมมุติว่า มีสตริงค์หรือข้อความอยู่แล้วต้องการจะแยกออกเป็นส่วนย่อยๆโดยใช้ตัวอักขระ
หรือสตริงค์ที่มีอยู่ข้างในเป็นตัวแยก เราจะใช้ฟังก์ชัน explode() ตามตัวอย่างต่อไปนี้
| <? $str = "ohh:users:bash"; list($user,$group,$shell) = explode(":",$str); echo "$user $group $shell"; ?> |
จากตัวอย่างข้างบนเราใช้ ":" เป็นตัวแยกส่วนของข้อความว่า
"ohh:users:/bash" และค่าที่ได้จากฟังก์ชัน explode() จะเป็น array ดังนั้น เราก็สามารถใช้ฟังก์ชัน
list() เก็บส่วนของข้อความที่ถูกแยกแล้วได้
ในกรณีนี้มีสามส่วนและถูกแยกเก็บไว้ในตัวแปร $user $group และ $shell ตามลำดับ
ฟังก์ชันที่ทำงานตรงกันข้ามกับฟังก์ชัน explode()
คือฟังก์ชัน join ตัวอย่างการใช้งานมีดังนี้
| <? unset($a); $a[]="aaa"; $a[]="bbb"; $a[]="ccc"; echo join(":",$a)."<BR>\n"; ?> |
| <? // convert \n to <br> $br=nl2br("\n\n"); echo $br."hello".$br; ?> |
| <? $filename[]="file1.inc"; $filename[]="file2.inc"; for ($i = 0; $i < 2; $i++) { include $filename[$i]; } ?> |
ไฟล์ file1.inc
| Hello world 1<BR> |
ไฟล์ file2.inc
| Hello world 2<BR> |
ตัวอย่างการแทรกไฟล์ที่มีคำสั่งสคริปต์
| <? include ("script.inc"); ?> |
ไฟล์ script.inc:
| <P><CENTER><BLINK><? echo "Hi, How are you!" ?></BLINK></CENTER> |
การแทรกไฟล์ภายในโครงสร้างของ if-else หรือ for-loop
เป็นต้น มีข้อควรระวังเวลาใช้ คือ จะต้องใส่ { } เอาไว้ เพื่อให้อยู่ในบล็อกของโครงสร้าง
| if ($version < 1.0) { include ($DOCUMENT_ROOT."/old.inc"); } else { include ( $DOCUMENT_ROOT."/new.inc") ; } |
ดังนั้นควรจะระมัดระวัง การแทรกไฟล์โดยใช้ include
หรือ require ในตำแหน่งๆต่าง โดยเฉพาะอย่างยิ่งในกรณีที่ แทรกไฟล์ที่มีคำสั่ง PHP
อยู่ด้วย
เราใช้สัญลักษณ์ [ ] (square brackets) เพื่อกำหนดขอบเขตของกลุ่มตัวอักขระหลายตัวที่ใช้เป็นตัวเลือก
เช่น สมมุติว่า เราต้องการจะเขียนรูปแบบที่ใช้แทนตัวอักขระหนึ่งตัว อะไรก็ได้จาก
{a,e,i,o,u} เราก็จะเขียนว่า [aeiou] โดยจะเรียงลำดับก่อนหลังอย่างไรก็ได้ เช่น
[eioua] ให้ผลเหมือนกับ [aeoui] หรือ ถ้าเราต้องการเขียน รูปแบบเพื่อใช้แทนตัวขระหนึ่งตัวที่เป็นตัวเลขตัวใดตัวหนึ่งจาก
0 ถึง 9 เราก็เขียนว่า [0123456789] หรือจะเขียนแบบสั้นๆใหม่ได้เป็น [0-9] หรืออีกตัวอย่างหนึ่ง
ถ้าเราต้องการจะเขียนนิพจน์แบบ regex ขึ้นมา เพื่อใช้แทนอักขระตัวใดตัวหนึ่งที่เป็นได้ทั้งตัวพิมพ์ใหญ่หรือเล็กในภาษาอังกฤษหรือตัวเลขระหว่าง
0 ถึง 9 เราก็เขียนว่า [A-Za-z0-9]
| [aeiou] | ตัวอักขระตัวหนึ่งจาก {a,e,i,o,u} ตัวไหนก็ได้ |
| [0-9] | ตัวอักขระตัวหนึ่งจาก {0,1,...,9} ตัวไหนก็ได้ |
| [A-Za-z0-9] | ตัวอักขระตัวหนึ่งจาก {A,B,..,Z, a, b, ... , z, 0, 1, ... 9} ตัวไหนก็ได้ |
ถ้าเรามีข้อความแล้วเราต้องการจะค้นหาอักขระหรือลำดับของอักขระ
(หรือ pattern) ในข้อความเรานั้น เราเรียกขั้นตอนในการค้นหาตามรูปแบบนี้ว่า pattern
matching ในภาษา PHP จะมีฟังก์ชันที่เราใช้ในการค้นหาลำดับของตัวอักขระตามแบบที่ต้องการคือ
ereg() และ eregi()
และต่างกันตรงที่ว่า ฟังก์ชัน eregi() จะเปรียบเทียบโดยไม่คำนึงถึงเรื่องตัวพิมพ์เล็กหรือใหญ่
ตัวอย่างเช่น สมมุติว่า เรามีข้อความอยู่ในอาร์เรย์เป็นข้อความที่มีแค่ตัวอักขระตัวเดียว
แล้วเราต้องการจะหาว่า ตัวไหนบ้างที่เป็นตัวเลข 0 ถึง 9 บ้างและตัวไหนบ้างที่เป็นตัวพิมพ์ภาษาอังกฤษ
a, b, หรือ c เราก็เขียนสคริปต์โดยใช้ฟังก์ชัน ereg() ได้ดังนี้
| <? $a=array("0","1","2","3","5","7","a","b","c"); for ($i=0; $i < count($a); $i++) { // print only digit if ( ereg("[0-9]",$a[$i]) ) { print ("$a[$i] <BR>\n"); } } ?> <HR> <? for ($i=0; $i < count($a); $i++) { // print only a, b or c if ( ereg("[a-c]",$a[$i]) ) { print ("$a[$i] <BR>\n"); } } ?> |
ข้อความที่เราใช้ในตัวอย่างข้างบนมีแค่ตัวอักขระเพียงหนึ่งตัว
แต่อันที่จริงแล้วฟังก์ชัน ereg() จะให้ค่าเป็นจริง ถ้าพบว่า ข้อความที่มีความยาวมากกว่าหนึ่งตัวอักขระและมีตัวอักขระอย่างน้อยหนึ่งตัวที่ตรงตามรูปแบบที่กำหนด
ฟังก์ชันก็จะให้ค่าเป็นจริงด้วย ตัวอย่างเช่น
| <? $a=array("f","mn", "eU","+5","Y","17","a4","%m","cdef"); for($i=0; $i < count($a); $i++) { if ( ereg("[a-z]",$a[$i]) ) { print ("$a[$i] <BR>\n"); } } ?> |
ผลจากการทำงานของสคริปตในตัวอย่างนี้จะได้ว่า ข้อความที่ตรงตามรูปแบบ [a-z] โดยใช้ฟังก์ชัน ereg() ในการเปรียบเทียบ คือ "f", "mn", "eU", "a4", "%m" และ "cdef" เพราะว่าข้อความเหล่านี้ มีตัวอักขระอย่างน้อยหนึ่งตัวที่อยู่ระหว่าง a ถึง z ดังนั้นจึงจะเห็นได้ว่า ข้อความที่เหลือคือ "+5", "Y" และ "17" ไม่ตรงตามรูปแบบ
จากตัวอย่างข้างบน สมมุติว่า เราต้องการจะหาข้อความที่มีสองตัวอักขระและมีแค่สองตัวเท่านั้น เป็นตัวใดก็ได้ระหว่าง a ถึง z เราก็จะต้องกำหนดรูปแบบให้การค้นหาให้เป็น ^[a-z]{2}$ โดยที่สัญลักษณ์ ^ หมายถึงการเริ่มต้น และ $ หมายถึงการลงท้าย และเราจะอ่านว่า ให้ค้นหาข้อความที่เริ่มต้นด้วยตัวภาษาอังกฤษพิมพ์เล็ก และจบด้วยตัวภาษาอังกฤษพิมพ์เล็ก และมีอยู่สองตัวเท่านั้น จากตัวอย่างข้างบน ถ้าเราใช้รูปแบบใหม่นี้ในการค้นหา เราจะได้ "en" เป็นข้อความเดียวเท่านั้นที่ตรงตามรูปแบบ
สมมุติว่า เราต้องการค้นหาคำที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่ภาษาอังกฤษและตามด้วยสระ
{a,e,i,o,u} ถ้าข้อความมีมากกว่าสองตัวอักขระแล้วตัวที่ตามมาจะเป็นอะไรก็ได้ เราก็เขียนรูปแบบในการค้นหาได้
เป็น ^[A-Z][aeiou] ลองตัวดูอย่างต่อไปนี้
| <? $a=array("f","Monday", "eU","755","Pu","English","Tuesday","for", "Bee"); for($i=0; $i < count($a); $i++) { if ( ereg("^[A-Z][aeiou]",$a[$i]) ) { print ("$a[$i] <BR>\n"); } } ?> |
ตัวอย่างนี้จะได้ว่า "Monday", "Pu" ,"Tuesday" และ "Bee" คือข้อความที่ตรงตามรูปแบบที่กำหนด
ถ้าต้องการจะหาข้อความที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่แล้วตามด้วยสระเป็นตัวพิมพ์เล็กอย่างน้อยหนึ่งตัว เราก็เขียนว่า ^[A-Z][aeiou]+$ ซึ่งเครื่องหมายบวกที่อยู่ข้างหลัง [aeiou] หมายความว่า มีได้อย่างน้อยที่สุดหนึ่งตัว จากตัวอย่างข้างบน ถ้าเราใช้รูปแบบใหม่นี้ในการค้นหา ก็จะได้ข้อความ "Pu" และ "Bee" เท่านั้นที่ตรงตามรูปแบบ
ถ้าจะหาข้อความที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่แต่ตามด้วยตัวพิมพ์เล็กใดๆก็ได้ที่ไม่ใช่สระ {a,e,i,o,u} เราก็เขียนใหม่ได้เป็น ^[A-Z][^aeiou] โปรดสังเกตว่า เราใส่สัญลักษณ์ ^ ไว้ระหว่าง [ ] และอยู่ข้างหน้าสุด เพื่อใช้กำหนดกรณีตรงข้าม และจากตัวอย่างข้างบน เราจะได้ข้อความ "English" เท่านั้นที่ตรงตามรูปแบบใหม่นี้
อีกตัวอย่างหนึ่งที่น่าสนใจ คือ สมมุติว่า เรามีรายชื่อไฟล์อยู่หลายๆชื่อ
ต้องการจะตรวจดูว่า ชื่อไหนลงท้ายด้วย .gif .jpeg .jpg หรือ .png บ้าง โดยใช้ eregi()
ในการค้นหา เราจะต้องกำหนดรูปแบบของ regex ขึ้นมาก่อน ซึ่งทำได้ดังนี้ (\.gif|\.jpg|\.jpeg|\.png)$
ในกรณีนี้เราไม่ได้ใช้ [ ] แต่ใช้วงเล็บคู่ ( ) แทน และสัญลักษณ์ \. เป็น escape
sequence ที่เราใช้แทนจุด (.) ถ้าเขียนอยู่ในระหว่างวงเล็บคู่ เนื่องจากว่าถ้าใช้จุดโดยไม่มี
backslash (\) นำหน้าก็จะหมายถึง ตัวอักขระใดๆก็ได้ ถ้าเราใช้จุดระหว่าง [ ] ก็จะหมายถึงจุด
โดยไม่ต้องใส่ \ ไว้เพื่อกำหนดให้เป็น escape sequence
| <? $files=array("bird.gif","Linux.JPG", "unknown.xbm","icon.Png"); for($i=0; $i < count($files); $i++) { |
ความแตกต่างของการใช้ ( ) และ [ ] อยู่ที่ว่า ถ้าเขียน (abc) หมายถึงข้อความที่เริ่มด้วย a ตามด้วย b และ c ตามลำดับ ในขณะที่ [abc] หมายถึง a หรือ b หรือ c ซึ่ง [abc] จะให้ผลเหมือนกับ (a|b|c) และเครื่องหมาย | ที่ใช้ภายในวงเล็บคู่ ( ) จะหมายถึง "หรือ" ดังนั้นจากตัวอย่างข้างบน จากรูปแบบเดิม (\.gif|\.jpg|\.jpeg|\.png)$ เราอาจจะเขียนใหม่ได้เป็น [(\.gif|\.png)(\.jpg|\.jpeg)]$ ก็จะให้ผลเหมือนกัน
จากที่ได้อธิบายมาก็เป็นเพียงการใช้งานส่วนหนึ่งของ Regular Expression ซึ่งยังมีลักษณะและการใช้งานที่นอกเหนือจากที่กล่าวไป
สัญลักษณ์พื้นฐานที่ใช้ในการเขียน Regular Expression
| . | ตัวอักขระใดๆก็ได้ |
| [ ... ] | ตัวอักขระตัวใดๆก็ได้ที่อยู่ในกลุ่มของตัวอักขระที่เป็นตัวเลือก |
| [^... ] | ตัวอักขระตัวใดๆก็ได้ที่ไม่ได้อยู่ในกลุ่มของตัวอักขระที่เป็นตัวเลือก |
| ^ | ตำแหน่งเริ่มต้นของข้อความ |
| $ | ตำแหน่งท้ายสุดของข้อความ |
| \< | ตำแหน่งเริ่มต้นของคำ |
| \> | ตำแหน่งท้ายสุดของคำ |
| | | สัญลักษณ์ที่ใช้แยกตัวเลือกระหว่าง ( ... ) |
| (...) | ใช้แทนกลุ่มของตัวเลือก |
Repetition Quantifiers
| ? | ถ้ามีก็ไม่เกินหนึ่งตัวหรือไม่มีก็ได้ |
| * | มีหนึ่งตัวหรือมากกว่าหนึ่งหรือไม่มีเลยก็ได้ |
| + | มีหนึ่งตัวหรือมากกว่าหนึ่งก็ได้ แต่ต้องมีอย่างน้อยหนึ่งตัว |
| {min,max} | ใช้กำหนดจำนวนน้อยที่สุดและมากที่สุดที่จะมีได้ |
ตัวอย่างของการใช้ regular expressions
| ^be | ข้อความที่ขึ้นต้นด้วย b และถัดจาก b ตามด้วย e |
| ^[be] | ข้อความที่ขึ้นต้นด้วย b หรือ e |
| [^be] | ข้อความที่ไม่ได้ขึ้นต้นด้วย b และ e |
| ion$ | ข้อความที่ลงท้ายด้วยหรือจบท้ายด้วย ion |
| [ion]$ | ข้อความที่ลงท้ายหรือจบท้ายด้วย i หรือ o หรือ n |
| \n$ | ข้อความที่มีสัญลักษณ์ \n (new line) อยู่ท้าย |
| <H[1-6]> | ข้อความที่มี <H1> <H2> <H3> <H4> <H5> หรือ <H6> อยู่ด้วย |
| <H[^4-6]> | ข้อความที่ไม่มี <H4> <H5> และ <H6> อยู่ด้วย |
| [0-9.] | ข้อความที่มีตัวเลขใดๆระหว่าง 0 ถึง 9 หรือ จุด อยู่ด้วย |
| ^Subject$ | ข้อความที่มีคำว่า Subject เท่านั้น |
| ^(From|Subject|Date): | ข้อความที่มีคำว่า From: หรือ Subject: หรือ Date: ขึ้นต้น |
| ^[0-9]+$ | ข้อความที่มีตัวเลขเท่านั้นและอย่างน้อยหนึ่งตัว |
| ([0-9]+(\.[0-9]+){3}) | ข้อความที่ตรงตามรูปแบบของหมายเลข IP เช่น 127.0.0.1 |
| ^[-+]?[0-9]+(\.[0-9]*)?$ | ข้อความที่ตรงตามรูปแบบของตัวเลขทศนิยม เช่น -12.345 |
การใช้งาน regular expression อย่างจริงจังนั้นไม่ใช่เป็นเรื่องง่าย ต้องทำความเข้าใจอย่างจริงจัง และในเอกสารนี้ก็ทำได้แค่นำเสนอเนื้อหาพื้นฐานสำหรับการใช้งานเท่านั้น ถ้าใครสนใจการใช้งานอย่างจริงจัง ในเรื่องของ regular expression ก็สามารถหาหนังสือ สำหรับเรื่องนี้โดยเฉพาะมาอ่านได้