CMDEVHUB

หลังจากเราเข้าใจการทำงานของคำสั่งวนรอบแล้ว ทีนี้ก็มาถึงวิธีการควบคุมการทำงานของคำสั่งวนรอบแล้ว ซึ่งก็มีเพียง 2 คำสั่งคือ

• break
• continue

สำหรับคำสั่งควบคุมนี้ ต้องใช้งานร่วมกับคำสั่งเงื่อนไขภายในลูปควบคุมการทำงาน

คำสั่ง break

จะทำให้ลูปที่กำลังทำงานนั้น หยุดลงทันที ใช้ร่วมกับ for, foreach, while, do while, switch โดยเฉพาะ switch นั้น ต้องใส่ break สำหรับแต่ละ case ด้วย ไม่เช่นนั้นจะทำงานไปเรื่อยๆ จนหมด switch ลองดูตัวอย่างกันเลยล่ะกันครับ

 <?php
	for ($i = 0; $i < 10; $i++ ) {
		if ($i == 5) {
			break;
		}
		echo $i;
	}
?> 

จากตัวอย่าง for ถูกให้ทำงานเป็นจำนวน 10 รอบ แต่ภายในลูปมีเงื่อนไขอยู่ ถ้าหากวนไปไ้ด้ถึง 5 รอบก็จะตรงกับเงื่อนไขที่ตั้งไว้ คำสั่ง break จะถูกเรียกใช้งาน ทำให้ for หยุดทำงาน ทำให้ผลลัพท์ที่ได้เป็น 01234

คำสั่ง continue

เหมือนกับ break ทุกๆ อย่างเลยครับ เพียงแต่จะหยุดทำงานในรอบนั้นๆ แล้วทำงานรอบต่อไปจนหมดลูปแทน จากโค๊ดข้างบน ถ้าเปลี่ยนจาก break เป็น continue โปรแกรมก็จะข้ามการทำงานเมื่อวนไปได้ถึงรอบที่ 5 ทำให้ผลลัพท์เป็น 012346789 แทน

 <?php
	for ($i = 0; $i < 10; $i++ ) {
		if ($i == 5) {
			continue;
		}
		echo $i;
	}
?> 

ต้องลองเล่นดูบ่อยๆ ครับ ถึงจะเห็นประโยชน์ของมัน

โจทย์ขำๆ ครับ ลองคิดกันเล่นๆ ดีกว่า

 <?php
	// พิมพ์ 1 - 100 ยกเว้นเลขที่หาร 2 หรือ 5 ลงตัว
	for ($i = 1; $i < 100; $i++ ) {
		if (($i % 2 == 0) || ($i % 3 == 0)) {
			continue;
		}
		echo $i . "<br />";
	}
?> 

มาลองคิดกันดูครับ ว่าจะได้ผลลัพท์อะไร

 <?php
	// อันนี้ไม่ยากเท่าไหร่ครับ
	$count = 0;
	for ($i = 6; $i > $count; $i--, ++$count ) {
		echo $count . "<br />";
	}
?> 

 <?php
	// ยากขึ้นมาอีกนิดนึง
	$x = 0;
	$y = 0;
	for ($z = 0; $z < 5; $z++ ) {
		if (( ++$x > 2) || (++$y > 2)) {
			$x++;
		}
	}
	echo "X = " . $x;
	echo "<br />";
	echo "Y = " . $y;
?> 

จริงๆ ทั้งสองคำสั่งนี้ มันไม่มีอะไรให้เล่นเลยอ่ะครับ อีกอย่าง ก็เผากันสุดๆ เลย (ไม่รู้จะเขียนยังไงเหมือนกัน) ก็ทำความเข้าใจกันไว้ครับ เพราะยังไงก็ได้ใช้งานแน่นอน แต่อาจจะไม่บ่อยเท่าไหร่

แล้วพบกันใหม่ โอกาสหน้าครับ

คำสั่งวนรอบ ใช้สำหรับทำงานซ้ำๆ กัน ในภาษา PHP มีคำสั่งวนรอบทั้งหมด 4 คำสั่งคือ

• for
• while
• do while
• foreach

ส่วนประกอบของคำสั่งวนรอบจะมี 3 ส่วนใหญ่ๆ คือ

1. ค่าเริ่มต้น (initialization)
2. เงื่อนไขในการทำงาน (condition)
3. คำสั่งเปลี่ยนค่า (update)

คำสั่งวนรอบ จะทำงานก็ต่อเมื่อเงื่อนไขยังคงเป็นจริง เพราะฉะนั้นเราต้องทำให้เงื่อนไขเป็นเท็จเพื่อให้จบการทำงานโดยการเปลี่ยนค่าไปเรื่อยๆ ถ้าหากไม่มีการจบเงื่อนไขโปรแกรมก็จะไม่จบการทำงาน ดังนั้นให้ระวังตรงนี้ด้วยนะครับ

for loop

เป็นเงื่อนไขที่เข้าใจได้ง่ายที่สุด เพราะมีการกำหนดค่า เงื่อนไข และเปลี่ยนแปลงค่า อยู่ภายในคำสั่งเดียวกันทั้งหมด มีรูปแบบการเขียน ดังนี้

 <?php
	for ( initialization; condition; update ) {
		statement;
	}
?> 

คำสั่ง for จะใช้มากในงานที่เรารู้จำนวนรอบการทำงานที่แน่นอน ตัวอย่างพิมพ์เลข 1 - 100

 <?php
 	for ($i = 1; $i <= 100; $i++ ) {
 		echo $i . "<br />";
 	}
?>  

ดูแล้ว เข้าใจไม่ยากเลยนะครับ ก็ถือว่าเป็นคำสั่งวนรอบที่ง่ายที่สุดแล้วล่ะครับ

while loop

เป็นเงื่อนไขที่เข้าใจยากขึ้นอีกนิด แต่ก็ใช้บ่อยมากพอสมควร while จะมีแต่การเช็คเงื่อนไขเพียงอย่างเดียว การกำหนดค่าเริ่มต้น จะทำก่อนที่จะเข้าเงื่อนไข และการอัพเดทค่าจะทำอยู่ภายในเงื่อนไข มีรูปแบบการเขียน ดังนี้

 <?php
	initialization;
	while (condition) {
		statement;
		update;
	}
?> 

จะเห็นว่า ส่วนประกอบ 3 ส่วนนั้นมีครบหมด while loop จะทำงานเมื่อเงื่อนไขยังเป็นจริง ถ้าหากเงื่อนไขเริ่มต้นเป็นเท็จแล้วก็จะไม่เข้าทำงานในส่วนของ while loop นี้เลย ลองดูตัวอย่างนะครับ

 <?php
	$a = $b = $c = 5;
	// พิมพ์เลข 5 - 10
	while ($a <= 10) {
		echo $a . "<br />";
		$a++;
	}
	// ไม่หลุดลูปเนื่องจากไม่มีการอัพเดทค่า
	while ($b <= 10) {
		echo $b . "<br />";
		// จะแสดงเลข 5 ออกมาเรื่อยๆ แต่โปรแกรมไม่หยุดทำงาน เนื่องจากเงื่อนไขยังคงเป็นจริง
	}
	// ไม่หลุดลูปเนื่องจากการอัพเดท ไม่ทำให้เงื่อนไขเป็นเท็จ
	while ($c <= 10) {
		echo $c . "<br />";
		$c--;
	}
	// จะไม่ทำงาน เนื่องจากเงื่อนไขเริ่มต้นเป็นเท็จ
	while ($a < 10) {
		echo $a . "<br />";
		$a++;
		// ไม่เข้ามาทำงาน เนื่องจากค่าของ $a = 11 จากลูปแรกแล้ว
	}
?> 

โค๊ดตัวอย่างข้างบน ถ้าหากนำไปรัน ก็เตรียม end task ตัว browser ได้เลยนะครับ เพราะมันจะทำงานไม่หยุดเลย

จากตัวอย่าง ลูปสุดท้าย จะไ่ม่ทำงานนะครับ เนื่องจากค่าของ $a เป็น 11 ไปแล้ว หลังจากทำงานลูปแรกสุดเสร็จแล้ว เพราะฉะนั้น การใช้งาน while loop เราจำเป็นต้องตรวจสอบเงื่อนไขให้ดีก่อน ไม่เช่นนั้น โปรแกรมใน while loop ของเรา จะไม่มีวันทำงานเลย

do while loop

จากปัญหาที่ว่า ถ้าเงื่อนไขเป็นเท็จก่อนที่จะเริ่มลูป คำสั่งในนั้นจะไม่ทำงานเลย ก็เลยมี do while ออกมาเพื่อทำให้โปรแกรมในส่วนนั้นทำงานอย่างน้อยที่สุด 1 ครั้ง ไม่ว่าเงื่อนไขจะเป็นจริง หรือเท็จก็ตาม ทำให้การตรวจสอบเงื่อนไข ถูกย้ายไปไว้ด้านล่างสุดของลูป มีรูปแบบการเขียน ดังนี้

 <?php
	initialization;
	do {
		statement;
		update
	} while (condition);
?> 

ดูๆ แล้ว คล้ายกับ while loop เลยใช่ไหมครับ เพียงย้าย while ไปไว้ด้านล่างและมี do มาอยู่แทนที่ while เท่านั้นเอง งั้นลองดูที่โปรแกรมกันครับ

 <?php
	$a = 10;
	// เงื่อนไขเป็นเท็จ ไม่ทำงานใน while
	while ($a < 10) {
		echo $a;
		$a++;
	}
	// เงื่อนไขเป็นเท็จ แต่ใช้ do while ซึ่งจะทำงานอย่างน้อย 1 ครั้ง
	do {
		echo $a;
		$a++;
	} while ($a < 10);
?> 

while กับ do while นั้น อาจจะเข้าใจยากนิดหนึ่ง แต่ก็ไม่น่าจะยากเกินไปนะครับ ถ้าหากไม่เข้าใจ ก็ลองพยายามเขียนบ่อยๆ เดี๋ยวก็จะเข้าใจเองครับ

แล้วในเมื่อ for ก็ทำงานได้เหมือนกัน จะมี while มาทำไม?

สำหรับ for นั้น จะใช้สำหรับการทำงานที่รู้จำนวนรอบที่แน่นอน แต่สำหรับ while แล้ว จะใช้ร่วมกับฟังก์ชั่นที่คืนค่าเป็นจริงหรือเท็จกลับมา เช่นคำสั่ง mysql_fetch_assoc(); หรือ feof(); เป็นต้น เพราะเราไม่รู้ว่าจำนวนแถวที่ select มาได้มีทั้งหมดกี่แถว (คำสั่ง mysql_fetch_assoc) หรือว่าไฟล์ที่เรา้เปิดมาอ่านนั้นหมดหรือยัง (คำสั่ง feof)

ลองดูตัวอย่าง โค๊ดอ่านข้อความที่อยู่ในไฟล์ แล้วพิมพ์ออกมาที่หน้าจอครับ

 <?php
	$fp = fopen("hello.txt", "r");
	while (!feof($fp)) {
		echo fgets($fp);
	}
	fclose($fp);
?> 

รูปผลลัพท์ที่ได้

จะเห็นได้ว่า เราไม่รู้ว่าไฟล์ของเรามีทั้งหมดกี่บรรทัด เราจึงใช้ while loop ทำการวนเพื่อให้นำข้อมูลออกมาทีละบรรทัดจนหมด ซึ่งการทำงานแบบนี้ ไม่สามารถใช้ for ได้ เพราะไฟล์ที่เปิดขึ้นมาแต่ละครั้ง อาจจะมีจำนวนบรรทัดที่ไม่เท่ากัน

สำหรับ do while บางภาษาอย่างเช่น Python ได้นำออกไปแล้ว เพราะไม่ค่อยได้ใช้งาน และหาโอกาสใช้งานจริงๆ จังๆ นั้น ยากมาก ส่วนตัวผม ก็ไม่เคยใช้งานจริงๆ เลยสักครั้งเดียว นอกจากเขียนให้ดูเป็นตัวอย่างนี่แหละครับ

foreach

ใช้ร่วมกับ Array สำหรับนำค่าออกมาได้เลย ซึ่งปกติในภาษาอื่นๆ (เช่นภาษา C) ถ้าหากต้องการเข้าถึงตัวแปร Array ต้องใช้คำสั่ง for แต่ในภาษา PHP และภาษาระดับสูงรุ่นใหม่ๆ จะมีคำสั่ง foreach สำหรับเข้าถึงค่าภายในตัวแปรได้เลย รูปแบบการเขียน foreach เขียนแบบนี้

 <?php
	foreach ( array as $value ) {
		statement;
	}
?> 

ลองมาดูตัวอย่าง และเปรียบเทียบกับคำสั่ง for เพื่อความเข้าใจที่มากขึ้นครับ

 <?php
	$a = array("www.cmdevhub.com", "www.blognone.com", "www.pc-cm.com", "www.pantip.com");

	// ใช้ for ในการเข้าถึงค่าในอาเรย์
	for ( $i = 0; $i < count($a); $i++ ) {
		echo $a[$i];
		echo "<br />";
	}
	echo "<hr />";
	// ใช้ foreach ในการเข้าถึงค่าในอาเรย์
	foreach ( $a as $value ) {
		echo $value;
		echo "<br />";
	}
?> 

จากตัวอย่าง ถ้าลองเอาไปรันดู จะเห็นว่า ผลลัพท์ที่ได้จะเหมือนกันเลย เพื่อนๆ อาจจะเห็นว่า ใช้ for แล้ว ง่ายกว่าอีก แค่กำหนดขอบเขตการวนรอบโดยใช้ count เท่านั้นเอง ซึ่งมันก็จริง แต่ถ้าเป็นอาเรย์แบบจับคู่ล่ะ (associative) เราจะเข้าถึงข้อมูลทั้งหมดโดยใช้ for ได้อย่างไร ในเมื่อ index ไม่ใช่ตัวเลขแล้ว ลองดูตัวอย่างกันครับ

 <?php
	$com = array("CPU" => "E8200", "RAM" => "2GB", "HDD" => "640GB", "VGA" => "9600GSO", "Monitor" => "Samsung 22\"");
	// Spec คอมที่เอาไว้เล่นเกมครับ
	// เราสามารถใช้ foreach ดึงข้อมูลออกมาได้แบบนี้ครับ
	foreach ( $com as $value ) {
		echo $value;
		echo "<br />";
	}
	echo "<hr />";
	// ถ้าต้องการนำ index ออกมาด้วย ก็เขียนรูปแบบนี้ครับ
	foreach ( $com as $key => $value ) {
		echo $key . " => " . $value;
		echo "<br />";
	}
?> 

เห็นไหมครับ แค่นี้ก็สามารถทราบข้อมูลทั้งหมดที่อยู่ภายใน Array แล้ว ทั้งแบบปกติ แล้วแบบจับคู่ แต่ถ้าแค่ต้องการรู้ค่าใน Array เฉยๆ ไม่ได้ไปวนลูปเพื่อเอาค่าไปใช้งาน ก็สามารถใช้คำสั่ง print_r() ก็ได้ครับ

 <?php
	$com = array("CPU" => "E8200", "RAM" => "2GB", "HDD" => "640GB", "VGA" => "9600GSO", "Monitor" => "Samsung 22\"");
	// Spec คอมที่เอาไว้เล่นเกมครับ
	print_r($com);
	echo "<hr />";
	echo "<pre>";
	print_r($com);
	echo "</pre>";
?> 

คำสั่ง print_r() ถ้าหากไม่ใส่ <pre> ครอบเข้าไป จะได้ข้อความที่ต่อกันเป็นแถวเดียว ดูยากครับ แต่ถ้าใส่แล้ว จะสวยงาม ดูง่ายมากๆ ว่ามีค่าอะไรอยู่ข้างใน

ก็จบกันไปแล้วกับคำสั่งวนรอบ จริงๆ แล้วเราไม่จำเป็นต้องใช้ทุกคำสั่ง โดยเฉพาะ do while ที่ผมก็ไม่เคยใช้งานจริงเหมือนกัน แต่ for และ while ขอให้เน้นให้มากๆ ครับ ส่วน foreach ถ้าหากไม่ได้จริงๆ ก็ใช้ for แทนก็ได้ครับ แต่ถ้าเข้าใจแล้ว การเข้าถึงตัวแปร Array จะง่ายขึ้นอีกเยอะเลยครับ

เจอกันใหม่ในบทหน้านะครับ

เงื่อนไขในการเขียนโปรแกรม เป็นการกำหนดเส้นทางการทำงานของโปรแกรมตามที่เราต้องการ เราสามารถกำหนดการทำงานได้จาก ผลลัพท์ของการเปรียบเทียบ หรือ การคืนค่าของฟังก์ชั่น

คำสั่งเงื่อนไขในภาษา PHP มี 2 คำสั่งคือ

if... elseif... else...
switch... case...

เงื่อนไข if... elseif... else... จะถูกแบ่งเป็น 3 แบบใหญ่ๆ คือ

• มีเงื่อนไขเดียว
• มีสองเงื่อนไข
• มีหลายเงื่อนไข

แบบเงื่อนไขเดียว จะทำงานก็ต่อเมื่อเงื่อนไขเป็นจริงเท่านั้น รูปแบบการเขียนคือ

 <?php
	if (เงื่อนไข) {
		// ทำงานในส่วนนี้เมื่อเงื่อนไขเป็นจริง
	}

	// ตัวอย่าง

	$a = 10;

	if ( 2 < 5 ) {
		echo "สองน้อยกว่าห้า";
	}

	if ($a + 5 < 20) {
		echo "สิบบวกห้าน้อยกว่ายี่สิบ";
	}
?> 

จะเห็นได้ว่า เราสามารถทำการคำนวนในเงื่อนไขได้ โปรแกรมจะทำการหาผลลัพท์จากการคำนวนก่อน จากนั้นจึงทำการเปรียบเทียบ ถ้าหากผลการเปรียบเทียบเป็นจริง จึุงจะทำงานในส่วนของเงื่อนไข แต่ถ้าหากเงื่อนไขเป็นเท็จ จะข้ามส่วนเงื่อนไขนี้ไป

แบบสองเงื่อนไข เมื่อเงื่อนไขเป็นจริง จะทำงานในส่วน if แ่ต่ถ้าเงื่อนไขเป็นเท็จจะทำงานในส่วน else

<?php
 	if (เงื่อนไข) {
 		// ทำงานเมื่อเงื่อนไขเป็นจริง
 	}
 	else {
 		// ทำงานเมื่อเงื่อนไขเป็นเท็จ
 	}

  	// ตัวอย่าง

  	$a = 10;
  	if ($a < 10) {
 		echo "เงื่อนไขเป็นจริง";
 	}
 	else {
 		echo "เงื่อนไขเป็นเท็จ";
 	}
?>  

ไม่ยากใช่ไหมครับ คล้ายๆ กับแบบเงื่อนไขเดียว คือจะทำงานก็ต่อเมื่อเงื่อนไขเป็นจริง แต่เพิ่มการทำงานเมื่อเงื่อนไขเป็นเท็จด้วย ทำให้การทำงานของโปรแกรมเพิ่มเป็น 2 ทาง

แบบหลายเงื่อนไข การทำงาน 2 แบบแรก จะมีการเปรียบเทียบเงื่อนไขเพียงเงื่อนไขเดียว แต่ถ้าหากเราต้องการเปรียบเทียบหลายๆ เงื่อนไข โดยแต่ละเงื่อนไขจะทำงานไม่เหมือนกัน สามารถเขียนได้ดังนี้

 <?php
	if (เงื่อนไข 1) {
		// ทำงานเมื่อเงื่อนไข 1 เป็นจริง
	}
	elseif (เงื่อนไข 2) {
		// ทำงานเมื่อเงื่อนไข 2 เป็นจริง
	}
	elseif (เงื่อนไข 3) {
		// ทำงานเมื่อเงื่อนไข 3 เป็นจริง
	}
	elseif (เงื่อนไข n) {
		// ทำงานเมื่อเงื่อนไข n เป็นจริง
	}
	else {
		// ทำงานเมื่อเงื่อไขข้างบนเป็นเท็จทั้งหมด
	}
?> 

ลองมาดูโปรแกรมตัดเกรดง่ายๆ กัน

 <?php
	$score = 79;

	if ($score > 80) {
		echo "Grade A";
	}
	elseif ($score > 70) {
		echo "Grade B";
	}
	elseif ($score > 60) {
		echo "Grade C";
	}
	elseif ($score > 50) {
		echo "Grade D";
	}
	else {
		echo "Grade F";
	}
?> 

ผลลัพท์ที่ได้คือ Grade B แล้วทำไมถึงเป็นแบบนี้ ในเมื่อเงื่อนไขอื่นๆ ก็เป็นจริงเหมือนกัน แต่ทำไมผลลัพท์ที่ได้ จึงเป็นแค่ Grade B เพราะการทำงานของ if..elseif.. เมื่อเจอเงื่อนไขที่เป็นจริงแล้ว จะทำงานที่เงื่อนไขนั้น และข้ามการทำงานของเงื่อนไขอื่นๆ ไป

นอกจากนั้น เรายังสามารถใช้เงื่อนไขซ้อนเงื่อนไขได้ด้วย ลองดูตัวอย่างครับ

 <?php
	$a = 25;
	if ($a < 100) {
		if ($a < 50) {
			echo "a น้อยกว่า 50";
		}
		else {
			echo "a มากกว่า 50";
		}
	}
?> 

จะเห็นว่า เราสามารถซ้อนเงื่อนไขกี่ชั้นก็ได้ ตามใจเรา (มากกว่านี้ก็ได้ครับ) แต่ในชีวิตจริงแล้ว สัก 3 - 4 ชั้น ก็เริ่มแย่แล้วล่ะครับ ตอนหา Jordan Matrix แทบแย่เลย

งั้นถ้าเราลองเขียนโดยไม่ใช่เครื่องหมายปีกกาล่ะ? ก็จะได้ตัวอย่างแบบนี้

  <?php
	if (expression1) if (expression2) statement1; else statement2;

	// ลองเขียนใหม่ เผื่อจะเข้าใจง่ายขึ้น	

	// แบบที่ 1

	if (expression1)
		if (expression2)
			statement1;
	else
		statement2;

	// แบบที่ 2

	if(expression1)
		if (expression2)
			statement1;
		else
			statement2;
?> 

จากตัวอย่างข้างบนเป็นปัญหาของโปรแกรมเกือบทุกภาษา ปัญหานี้เรียกว่า Dangling else ถ้ามองโจทย์เป็นแบบที่ 1 ก็จะมองได้ว่า else เป็นของ if ตัวนอก แต่ถ้าเป็นแบบที่ 2 จะมองได้ว่า else เป็นของ if ตัวข้างใน ซึ่งการเขียนทั้ง 2 แบบ ถูกต้องตามหลักไวยากรณ์ของ if..else.. ทุกอย่าง แล้วปัญหานี้ โปรแกรมจะแก้ไขอย่างไร?

บางภาษาเช่น Ada จะมีการจบ if ด้วย end if ทำให้ไม่มีปัญหานี้เกิดขึ้น แต่ภาษา php ไม่มีการจบ if โปรแกรมจะถือว่า else ตัวใดๆ จะ้เป็นของ if ตัวที่อยู่ใกล้ที่สุด จะทำให้โปรแกรมไม่มีทางสับสน แต่คนเขียนนี่แหละจะสับสนเอง...

ทางแก้ปัญหาที่ (ผมคิดว่า) ถูกต้องคือ ใส่ block ให้มันซะ ไม่ว่าคำสั่งที่ทำงานหลังจาก if จะมีแค่คำสั่งเดียวก็ตาม เพราะนอกจากโปรแกรมจะดูเป็นระเบียบแล้ว ถ้าหากเรากลับมาอ่านทีหลัง จะไม่สับสนเอง แล้วยังกำหนดการทำงานได้ตามต้องการด้วย

 <?php
	// ลองเขียนใหม่
	if (expression1) {
		if (expression2) {
			statement1;
		}
	}
	else {
		statement2;
	}
	// else เป็นของ if ตัวแรก ไม่ใช่ if ที่อยู่ใกล้ที่สุด

	if(expression1) {
		if (expression2) {
			statement1;
		}
		else {
			statement2;
		}
	}
	// else เป็นของ if ตัวที่สอง
?> 

ฝึกให้เป็นนิสัยเลยครับทุกๆ ครั้งที่เขียนเงื่อนไขให้ใส่ block ด้วย แม้ว่าจะทำงานแค่คำสั่งเดียวก็ตาม

เงื่อนไข switch... case...

switch... case... จะว่าไปมันก็ไม่เชิงเป็นเงื่อนไข เนื่องจากต้องมีการกำหนดค่าที่แน่นอนของตัวเลือก ไม่เหมือนกับ if ที่สามารถกำหนดเป็นช่วง หรือเป็นการคำนวนได้ ทำให้หลายๆ ภาษาอย่างเช่น Python ตัด switch... case... ออกไป รูปแบบการเขียนจะเป็นดังนี้

 <?php
	$web = "cmdevhub";
	switch ($web) {
		case: "cmdevhub" :
			echo "http://www.cmdevhub.com";
			break;
		case: "pantip";
			echo "http://www.pantip.com";
			break;
		default:
			echo "ไม่ได้เลือกเว๊ป";
			break;
	}
?> 

จะเห็นว่าทางเลือกของ switch... case... นั้น จะมีเพียงทางเดียว ซึ่งจะว่าไป ก็ไม่ค่อยจะมีประโยชน์สำหรับโปรแกรมระดับสูงเท่าไหร่ ผมจำได้ว่าครั้งสุดท้ายที่เขียนโปรแกรมแล้วใช้ switch... case... แบบจริงจัง ก็เขียนภาษา C บน Dos แล้วจับแป้นลูกศรทั้ง 4 ตัวล่ะครับ

แต่ถ้าหากเรารู้ค่าที่แน่นอนและเส้นทางที่แน่นอน การใช้ switch... case... จะเป็นทางเลือกที่ดีมากกว่า if เืนื่องจากเมื่อพบเปรียบเทียบแล้ว จะข้ามไปทำงานตามสิ่งที่ switch เจอเลยถ้าไม่พบ จะไปทำที่ default: แทน แต่ถ้าเป็น if จะทำการเปรียบเทียบไปเรื่อยๆ จนครบ ถ้าหากมีเงื่อนไขมากก็ต้องเปรียบเทียบจนครบ อันนี้ก็แล้วแต่ความเหมาะสมของโปรแกรมครับ

ตอนหน้าก็จะเป็นเรื่องคำสั่งวนรอบ (loop) ล่ะครับ

ในการเขียนโปรแกรมทุกๆ โปรแกรม ต้องมีการคำนวนเข้ามาเกี่ยวข้องด้วยเสมอ แล้วสิ่งที่ใช้คำนวนนั้นก็คือตัวดำเนินการทางคณิตศาสตร์ที่เรารู้จักกันนั่นเอง ตัวดำเนินการทางคณิตศาสตร์ในภาษา PHP ก็เหมือนกับภาษาอื่นๆ สำหรับท่านที่เขียนโปรแกรมได้แล้ว อาจจะข้ามตรงนี้ไปเลยก็ได้ครับ เพราะเหมือนเอาของเก่ามาเล่าใหม่ เล่ากี่ที กี่ที มันก็ไม่ต่างไปจากเดิมเท่าไหร่หรอกครับ แต่สำหรับท่านที่กำลังเริ่มเขียนโปรแกรมแล้ว จุดนี้ ถือเป็นสิ่งที่ต้องรู้และต้องเข้าใจด้วย ไม่เช่นนั้นแล้ว อาจจะเขียนโปรแกรมเพื่อที่จะใช้งานจริงๆ ไม่ได้เลย

ตัวดำเนินการกำหนดค่า

การกำหนดค่าให้ตัวแปร ใช้เครื่องหมาย = (เท่ากับ) ในการกำหนดค่า วิธีการจำง่ายๆ ก็คือ สิ่งที่ทำด้านขวา (เช่นการคำนวน หรือ ข้อความ) จะถูกส่งไปยังด้านซ้าย ตามตัวอย่าง

 <?php
	$a = "cmdevhub";	// $a เ้ก็บข้อความว่า cmdevhub
	$b = 1;	// $b เก็บตัวเลข 1
	$c = 1 + 2;	// $c เก็บผลลัพท์จากการคำนวนด้านขวา คือ 3
	$d = $c + 3;	// ผลลัพท์ $d เก็บค่า 6 เนื่องจาก $c เก็บค่า 3 ไว้อยู่แล้ว
?> 

ตรงนี้ไม่ค่อยยากเท่าไหร่ หวังว่าทุกๆ ท่านจะเข้าใจนะครับ ถ้าหากไม่เข้าใจ ก็ให้พยายามทำความเข้าใจให้ได้ครับ ไม่เช่นนั้นจะไปต่ออีกไม่ได้เลย

(จริงๆ แล้วคำสั่ง += , -= , *= , /= , %= ก็จัดอยู่ในหมวดนี้ แต่ผมขอแยกออกไปอยู่ในตัวดำเนินการเชิงคณิตศาสตร์ล่ะกันครับ)

ตัวดำเนินการเชิงคณิตศาสตร์

เป็นเครื่องหมายทางคณิตศาสตร์ทั่วๆ ไป ที่เราคุ้นเคยกันดีอยู่แล้ว คือ บวก (+) ลบ (-) คูณ (*) หาร (/) แต่จะมีตัวพิเศษเพิ่มขึ้นมาอีกตัวหนึ่งคือ หารเอาเศษ (%) ลองดูตัวอย่างกันครับ

 <?php
	$a = 5;
	$b = 2;

	$a + $b;	// ผลลัพธ์ 7
	$a - $b;	// ผลลัพธ์ 3
	$a * $b;	// ผลลัพธ์ 10
	$a / $b;	// ผลลัพธ์ 2
	$a % $b;	// ผลลัพธ์ 1
?> 

ตรง $a / $b นั้น เป็นแค่ทางทฤษฎีนะครับ แต่ในภาษา PHP นั้น เนื่องจากการประกาศตัวแปรไม่มีการบอกว่าเป็นชนิดไหน
จึงทำให้ผลลัพธ์จากการหารนั้น เป็นจำนวนทศนิยมไปด้วย
สำหรับการหารเอาเศษ ข้อสังเกตง่ายๆ ว่าผลลัพธ์ถูกหรือไม่คือ ค่าที่ได้ จะเป็นเลขตั้งแต่ 0 ไปจนถึงตัวหารลบด้วย 1
เช่น หารด้วย 8 เศษที่ได้จะมีตั้งแต่ 0 จนถึง 7 เท่านั้น

ตัวดำเนินการทางคณิตศาสตร์สามารถคำนวน และกำหนดค่าให้ตัวแปรได้เลย โปรแกรมจะทำการคำนวนผลลัพธ์ให้เสร็จเสียก่อน แล้วจึงกำหนดค่าให้กับตัวแปรนั้นๆ ลองดูตัวอย่างกันครับ

 <?php
	$a = 5;
	$b = 2;
	$c = 3 + 4;	// ทำการคำนวน 3 + 4 ก่อน และค่อยกำหนดค่าให้ $c
	$d = $a + $b;	// ทำการคำนวนก่อนเช่นกัน

	$a = $a + 5;	// นำค่าในตัวแปร $a ไปบวกกับ 5 และกำหนดค่าที่ได้ให้ตัวแปร $a
	$b = $b + $c;	// นำค่าในตัวแปร $b ไปบวกกับค่าของ $c และกำหนดค่าที่ได้ให้ตัวแปร $b
?> 

จากตัวอย่าง จะเห็นว่า เราสามารถทำการคำนวนและกำหนดค่าได้ในครั้งเดียว ลองสังเกตุตรงที่ การนำตัวแปรไปคำนวน และกำหนดค่าให้ตัวมันเอง เราสามารถเขียนย่อลงได้ เพื่อให้โปรแกรมสั้นลง และทำงานได้เร็วขึ้น ดังนี้

ทั้งสองแบบ ได้ผลลัพท์ที่เหมือนกัน เขียนโปรแกรมใหม่ๆ อาจจะ งง กันพอสมควรครับ แต่ถ้าทำไปนานๆ แล้วจะคล่องเอง อันนี้ก็ต้องพยายามกันเยอะๆ หน่อยนะครับ ที่สำคัญ การเขียนแบบย่อ โปรแกรมจะทำงานได้เร็วกว่าครับ เพราะทำการ get operand 1 ครั้ง get operator 2 ครั้ง แต่ถ้าหากเขียนแบบเต็มจะ get operand 2 ครั้ง get operator 3 ครั้ง ไว้เรามาเขียนโปรแกรมหาความแตกต่างในโอกาสต่อไปนะครับ (แน่นอน ต้องภาษา C เท่านั้น)

สำหรับความสำคัญของเครื่องหมาย ก็ต้องเอามาคิดด้วยครับ เพราะไม่เช่นนั้น ผลลัพท์ที่คำนวนมาได้ จะไม่ถูกต้องตามที่เราต้องการ ระดับความสำคัญของเครื่องหมายตามตารางนี้เลยครับ

การคำนวนต้องคำนึงถึงระดับความสำคัญของเครื่องหมาย เพื่ออะไร? งั้นลองดูตัวอย่างกันเลยครับ (ในบางภาษาเช่น Python จะมียกกำลังด้วย ความสำคัญจะสูงกว่า *, /, % นะครับ)

 <?php
	echo 2 + 3 * 5;
?> 

อ่า... คิดว่าผลลัพท์ที่ได้ จะเป็นอะไร? ระหว่าง 30 หรือ 17 คำตอบนั้น ลองไปรันเองเลยล่ะกันครับ แต่แล้ว ทำไมผลลัพท์ถึงเป็นแบบนี้ เพราะว่าลำดับความสำคัญของเครื่องหมาย * มีมากกว่า + จึงมีการคำนวนในเทอมของ * ก่อน เสร็จแล้วจึงมาทำการ + ซึ่งรูปแบบการคำนวนนี้ เหมือนกันทุกภาษาครับ ถ้าหากท่านใดเคยเรียน data structure มา คงจะเคยเล่น in fix กับ post fix กันอย่างสนุกสนานล่ะครับ

ลองมาคิดกันเล่นๆ ต่อครับ

 <?php
	echo 10 - 2 * 15 / 3 - 2;
	echo 10 - 2 * (15 / 3) - 2;
	echo 10 - 2 * 15 / (3 - 2);
	echo (10 - 2) * 15 / (3 - 2);
	echo (10 - 2) * 15 / 3 - 2;
	echo 10 - (2 * (15 / (3 - 2)));
?> 

จากผลลัพท์ที่ได้ จะสังเกตุได้ว่า ถ้าหากความสำคัญของเครื่องหมายมีเท่ากัน จะทำตามลำดับก่อนหลังของเครื่องหมาย ส่วนวงเล็บนั้น จะทำจากด้านในออกมาด้านนอกเสมอ แต่ถ้าหากวงเล็บอยู่ในระดับที่เท่ากัน จะทำตามลำดับก่อนหลัง

ตัวเพิ่มค่า (Increment) ลดค่า (Decrement)

ตัวเพิ่มค่า เขียนโดยใช้เครื่องหมาย บวกสองตัวต่อกัน (++) ใช้สำหรับเพิ่มค่าตัวแปรทีละ 1 ส่วนตัวลดค่า เขียนโดยใช้เครื่องหมายลบสองตัวต่อกัน (--) ใช้สำหรับลดค่าตัวแปรทีละ 1

 <?php
	// ตัวอย่างการเพิ่มค่าทีละ 1
	$a = 1;
	$a = $a + 1;
	$a += 1;
	// สามารถใช้คำสั่งเพิ่มค่าได้ดังนี้
	$a++;
?> 

จากตัวอย่าง จะเห็นว่า ผลลัพท์ของทั้ง 3 แบบ จะได้เหมือนกันหมด แล้วจะมีมาเพื่ออะไร?

ใน CPU ทุกตัว จะมีคำสั่ง ADD และ INC อยู่ด้วย ซึ่งคำสั่ง INC จะใช้ CPU Time น้อยกว่าคำสั่ง ADD อยู่แล้ว
สมมุติ... ใน CPU แบบ CISC (ตระกูล X86) แต่ละคำสั่ง จะใช้ CPU Time (Clock Cycle) ไม่เท่ากัน
ผมให้ INC = 1 clock ADD = 2 clock ถ้ามีการวนลูปสัก 1 ล้านรอบ ก็มีความต่างกันถึง 1 ล้าน Clock
อาจจะฟังดูน้อยเพราะ CPU ทำงานเร็วอยู่แล้ว แต่ถ้าเป็นเว๊ปใหญ่ๆ แล้วคนเ้ข้าเยอะๆ อันนี้มีผลแน่นอน
(ส่วน CPU ตระกูล RISC พวก Sparc ของ SUN ก็คิดอีกแบบ แต่ผลลัพท์ก็คล้ายๆ กันครับ)

ตัวเพิ่มค่า ละลดค่า สามารถเขียนได้ 2 ตำแหน่งคือ หน้าตัวแปร และ หลังตัวแปร

ถ้าหากเราวางเครื่องหมายไว้หน้าตัวแปร ก็จะทำการเพิ่มตัวแปรนั้นก่อน จึงจะทำคำสั่งอื่นๆ ที่อยู่ในบรรทัดนั้น แต่ถ้าหากวางเครื่องหมายไว้หลังตัวแปร จะทำคำสั่งอื่นๆ ให้หมดก่อน ลองดูตัวอย่างตามนี้นะครับ

 <?php
	$a = 1;
	echo $a++;	// ผลลัพท์ 1 เนื่องจากทำคำสั่ง echo ก่อน จึงทำการเพิ่มค่า
	$a = 1;
	echo ++$a;	// ผลลัพท์ 2 เนื่องจากทำการเพิ่มค่าก่อน แล้วจึงทำคำสั่ง echo
	$a = 1;
	echo 1 + $a++;	// ผลลัพท์ 2 เนื่องจากทำการบวก 1 และ echo ก่อนจึงทำการเพิ่มค่า
	$a = 1;
	echo 1 + ++$a;	// ผลลัพท์ 3 เนื่องจากทำการเพิ่มค่าก่อน และบวก 1 แล้วจึงทำคำสั่ง echo
?> 

จะ้เห็นว่า การวางเครื่องหมายด้านหน้า หรือด้านหลัง ให้ผลลัพท์ที่แตกต่างกันอย่างมาก หลายๆ ท่านที่ผมเคยคุยด้วย ก็เคยตกม้าตายเพราะตำแหน่งของเครื่องหมายนี่แหละครับ ดังนั้นก็ให้ระมัดระวังในการเขียนด้วยนะครับ

ตัวเชื่อมข้อความ

ในภาษา PHP การกำหนดตัวแปรเป็นข้อความ (String) สามารถทำได้ 2 แบบคือใช้เครื่องหมาย Singe Quote (') หรือ Double Quote (") ถ้าต้องการนำข้อความหลายๆ ข้อความมาต่อกัน สามารถใช้เครื่องหมายจุด (.) เพื่อทำให้ตัวแปรเชื่อมต่อกัน หรือจะใช้เครื่องหมายจุด เพื่อเชื่อมข้อความกับตัวแปรก็ได้ ลองดูตัวอย่างกันครับ

 <?php
	$a = "Hello" . "World";
	$b = "Hello";
	$b = $b . "World";
	$c = "http:/www.cmdevhub.com";
	$c.= "โปรแกรมที่ไม่มีบักคือโปรแกรมที่ยังไม่ได้เขียน";	// ท่องเอาไว้ครับ อิอิ

	$total = 100;
	echo "Total Price = " . $total;
?> 

การนำข้อความมาเชื่อมกับตัวแปรเดิม สามารถเขียนได้ 2 แบบ ตามตัวอย่างข้างบนนะครับ

การเชื่อมข้อความ ดูแล้วเหมือนไม่ยาก ถ้าหากใช้บ่อยๆ แล้วจะคล่องเองครับ

ตัวเปรียบเทียบ

ตัวเปรียบเทียบในทุกๆ ภาษา จะเปรียบเทียบตัวซ้าย เทียบกับตัวขวา และได้ผลลัพท์เป็น จริง (true) หรือ เท็จ (false) เท่านั้น ในภาษา PHP ก็มีวิธีการเปรียบเทียบเหมือนกับภาษาอื่นๆ เหมือนกัน ผลลัพท์ที่ได้ก็มีแต่ จริง และ เท็จ เท่านั้น เหมือนกัน ตัวเปรียบเทียบ จะใช้ในการกำหนดทิศทางของโปรแกรม

การเปรียบเทียบ === ทั้งค่าในตัวแปร และ ชนิดตัวแปร ต้องเหมือนกัน จึงจะไ้ด้ค่าจริงกลับมา แต่ == ค่าเท่ากัน แต่ตัวแปรเป็นคนละชนิด ก็ได้ค่าจริงกลับมาแล้ว จริงๆ แล้ว เครื่องหมาย === ไม่ค่อยได้ใช้เท่าไหร่หรอกครับ

 <?php
	$a = 1;
	$b = 2;
	$c = "1";

	$a < $b;	// true
	$a > $b;	// false
	$a <= $b;	// true
	$a <= $c;	// true
	$a >= $b;	// true
	$a >= $c;	// true
	$a == $b;	// false
	$a == $c; 	// true
	$a === $b;	// false
	$a === $c;	// false
?> 

เห็นไหมครับ ไม่ยากเลย กับการเปรียบเทียบตัวแปร ยังไงก็ระวังในการใช้งานได้นะครับ ถ้าหากกำหนดเงื่อนไขผิด โปรแกรมก็จะทำงานผิดไปเลย ระวังด้วย

ตัวดำเนินการทางตรรกศาสตร์

ในการเปรียบเทียบค่า เราสามารถเปรียบเทียบได้หลายๆ ค่าพร้อมกัน โดยใช้ตัวเปรียบเทียบทางตรรกศาสตร์มาช่วยหาคำตอบสุดท้ายของการเปรียบเทียบ ตัวเปรียบเทียบ จะมีเพียง 4 ตัวคือ and , or , not , xor

ถ้าเขียนเป็นตาราง จะได้ค่าตามนี้ (ผมให้ 0 = false และ 1 = true)

ดูจากตารางแล้ว ถ้าเคยเรียน Digital มาก่อน คงจะเข้าใจไม่ยาก แต่ถ้ายังไม่เข้าใจ ก็ลองท่องตรงนี้เอาครับ
and เป็นจริงเมื่อเป็นจริงทั้งหมด นอกนั้นเป็นเท็จ
or เป็นเท็จเมื่อเป็นเท็จทั้งหมด นอกนั้นเป็นจริง
xor เหมือนกันเป็นเท็จ ต่างกันเป็นจริง
not จริงเป็นเท็จ เท็จเป็นจริง
(ปล. สูตรใครสูตรมันนะครับ แต่ผมจับใจความมาได้แบบนี้อ่ะ)

ตัวเปรียบเทียบบิต

... เดี๋ยวค่อยมาต่อครับ ไม่ค่อยได้ใช้หรอกอ่ะ

พบกันอีกแล้วหลังจากหายไปซะสัปดาห์กว่าๆ ก็ไม่มีไรหรอกครับ แอบไปแข่งเกมมา ปีนี้ก็สนุกดีครับ แต่เสียดายคนน้อยไปหน่อย

เรามาเข้าเรื่องของเราเลยดีกว่า ตอนนี้ก็เป็นเรื่องของตัวแปร หลายๆ ท่านคงจะทราบแล้วว่าวีธีการประกาศตัวแปรใน PHP นั้น ง่ายแสนง่าย เพียงแต่ใส่เครื่องหมาย $ เข้าไปข้างหน้า ข้อความนั้นก็จะเป็นตัวแปรแล้ว แต่มีข้อแม้อยู่นิดนึงคือ

1. ห้ามมีช่องว่างในตัวอักษร
2. ห้ามขึ้นต้นด้วยตัวเลข
3. ห้ามมีเครื่องหมายพิเศษ (Control Charecter)
4. ตัวอักษรเล็ก-ใหญ่ ถือว่าเป็นคนละตัวกัน (Case sensitive)

การกำหนดค่าให้ตัวแปร

เราสามารถกำหนดค่าให้ตัวแปรตั้งแต่ตอนที่เราประกาศตัวแปรขึ้นมาได้เลย โดยใช้เครื่องหมาย = ในการกำหนดค่าให้กับตัวแปรนั้นๆ ลองดูตัวอย่างกันครับ

 <?php
	$color = "green";	// ตัวแปร color = string
	$num = 12;	// ตัวแปร num = integer
	$age = "13.5";	// ตัวแปร age = string
	$sum = 12 + "13";	// ผลลัพท์คือ 25 เป็น integer เนื่องจาก 13 ถูก cast เป็น Integer
	$total = $sum + $age;	// ผลลัพท์คือ 38.5 เป็น double เนื่องจาก age ถูก cast เป็น double -> double + integer = double
?> 

ในภาษา PHP นั้น ไม่ค่อยให้ความสำคัญในเรื่อง Datatype เท่าใด หลายๆ คนอาจจะมองว่าเ็ป็นข้อดีของมัน แต่ให้ระวัง ตอนไปเขียนภาษาอื่น โดยเฉพาะ Java ส่วนเรื่องการ casting ของตัวแปรนั้น ค่อยคุยกันในโอกาสต่อไปนะครับ

การใช้ตัวแปรอ้างอิงถึงกัน (Reference)

รูปแบบนี้ ไม่ค่อยได้ใช้กันเท่าไหร่หรอกครับ การทำงานของมันก็คือ เราสร้างตัวแปรขึ้นมาตัวหนึ่ง สมมุติชื่อ $a แล้วใช้ตัวแปรอีกตัว สมมุติชื่อ $b อ้างอิงตำแหน่งหน่วยความจำที่ $a ชี้อยู่ ดังนั้น ถ้าหากเราเปลี่ยนค่าที่ $b ค่าของ $a ก็จะเปลี่ยนไปด้วย เพราะชี้ตำแหน่งหน่วยความจำที่เดียวกัน (คนที่เคยเขียนภาษา C มาก่อนคงจะนึกภาพออกนะครับ) ลองดูตัวอย่างกันเลย

 <?php
	$a = "cmdevhub";
	$b = &$a;	// $b อ้างอิงหน่วยความจำที่ $a ชี้อยู่
	$b = "This is chiangmai dev hub";

	echo $a; // ผลลัพธ์ This is chiangmai dev hub
?>  

วิธีการก็คือ ใส่เครื่องหมาย & (ampersand) ข้างหน้าตัวแปรที่เราต้องการอ้างอิงหน่วยความจำเท่านั้น ก็คล้ายๆ ภาษา C แหละครับ จากการเขียน PHP มานานพอสมควร โอกาสใช้นั้น มีน้อยมากๆ เลย ครับ (แต่รู้ไว้ใช่ว่า จริงไหม)

ขอบเขตของตัวแปร (Variable Scope)

เมื่อเราสร้างตัวแปรมาสักตัวหนึ่ง ก็ใช่ว่าเราจะสามารถใช้งานตัวแปรนั้นๆ ได้ตลอดทั้งโปรแกรม ตัวแปรบางตัว สร้างไว้ในฟังก์ชั่น ก็จะสามารถใช้งานได้ภายในฟังก์ชั่นนั้นๆ เท่านั้น ถ้าหากเราไม่ทราบถึงขอบเขตของตัวแปรแล้ว อาจทำให้โปรแกรมของเราทำงานผิดพลาดได้ เพราะเราอาจจะกำหนดค่าไปซ้ำกับตัวแปรที่เราไม่ต้องการก็ได้ ขอบเขตของตัวแปร มีทั้งหมด 4 แบบดังนี้

1. Local variable
2. Function parameter
3. Global variable
4. Static variable

สำหรับคนที่้เคยเขียนโปรแกรมมาก่อน เรื่องนี้ อาจจะดูไม่ยาก แต่สำหรับคนที่เริ่มต้นใหม่แล้ว ถือเป็นเรื่องที่ชวนเวียนหัวมากๆ เลยครับ แต่ก็เอาใจช่วยนะครับ สู้ๆ

1.Local variable

เป็นตัวแปรที่ประกาศในฟังก์ชั่น และใช้งานได้แต่ภายในฟังก์ชั่นที่ประกาศไว้เท่านั้น (อันนี้ขอเน้นเลยล่ะครับ โดยเฉพาะ ถ้าเขียนเป็น OO เมื่อไหร่ สนุกสนานกันแน่นอน) ลองดูตัวอย่างกันครับ

 <?php
	$x = 10;
	function showx() {
		$x = 0;
		echo "x is " . $x;
	}
	// เริ่มทำงานตรงนี้
	showx();
	echo "<br />";
	echo "x is " . $x;
?> 

จากตัวอย่าง จะเห็นว่า เราประกาศตัวแปรชื่อเดียวกันคือ $x แต่ตัวหนึ่งอยู่ภายในฟังก์ชั่น showx() ส่วนอีกตัวอยู่ภายนอกฟังก์ชั่น เมื่อเราเรียกใช้ฟังก์ชั่น showx() คำสั่ง echo ในฟังก์ชั่น จะพิมพ์ค่า $x ที่อยู่ในฟังก์ชั่นออกมา แต่ถ้าหากเราทำการลบคำสั่ง $x = 0; ออกไป จะเกิด Notice: Undefined variable: x เนื่องจากตัวแปร $x ไม่ได้ถูกประกาศขึ้นมา และฟังก์ชั่น showx() ก็มองไม่เห็นตัวแปร $x ที่อยู่ข้างนอก ลองดูภาพได้ครับ

จากรูป ผมได้ทำการ comment คำสั่ง $x = 0; ออกไป ทำให้ในฟังก์ชั่น showx() ไม่มีตัวแปร $x อยู่ จึงเกิด error แบบนี้ขึ้น (ขึ้นอยู่กับการปรับระดับ error ในไฟล์ php.ini ด้วยนะครับ)

อ่า แล้วคำสั่ง global ล่ะ คำสั่งที่เอาไว้ใช้เรียกตัวแปรภายนอก เข้ามาภายในฟังก์ชั่น คำสั่งนี้ เมื่อประกาศแล้ว ตัวแปรนั้นๆ จะกลายเป็น global variable ไปโดยอัตโนมัติ คือ ไม่่ว่าจะทำการเรียกตัวแปรนี้ที่ไหน ก็จะถือว่าเป็นตัวแปรเดียวกันหมด ลองดูตัวอย่างนะครับ

สรุปง่ายๆ ก็คือ Local variable จะมองเห็น และใช้งานได้ภายในฟังก์ชั่นที่ประกาศตัวแปรนั้นๆ ขึ้นมาเท่านั้น แต่ถ้าหากเราใช้คำสั่ง global เมื่อไหร่ ตัวแปรนั้นจะกลายเป็น Global variable ไปทันที ซึ่งจะมองเห็นเป็นตัวแปรตัวเดียวกันทั้งโปรแกรม

2.Function parameter

ง่ายๆ ตรงๆ เลยครับ เป็นตัวแปรที่รับค่าในฟังก์ชั่น ซึ่งก็เหมือนกับ Local variable ที่จะมองเห็น และใช้งานได้ภายในฟังก์ชั่นนั้นๆ เท่านั้น เอาไว้เราค่อยมาต่อกันในเรื่องของฟังก์ชั่นล้วนๆ เลยล่ะกันครับ ตรงนี้ก็ติดไว้แค่นี้ก่อน ลองดูตัวอย่างนะครับ

 <?php
	function sqr($num) {
		$num = $num * $num;
		return $num;
	}
?> 

จากตัวอย่าง เป็นฟังก์ชั่นที่คำนวนเลขยกกำลังสองของค่าที่ส่งเข้ามา และคืนค่ากลับไป ตัวแปรแบบ Function parameter นี้จะถูกสร้างขึ้นตอนที่ฟังก์ชั่นนั้นถูกเรียก และจะถูกทำลายเมื่อฟังก์ชั่นนั้นทำงานเสร็จสิ้น

3.Global Variable

จากตัวอย่างใน Local variable ตัวอย่างสุดท้าย ผมได้ยกตัวอย่างตัวแปรแบบ global ไปแล้ว สรุปง่ายๆ ก็คือ ตัวแปรไหนที่ถูกประกาศเป็น global ตัวแปรนั้นจะสามารถถูกเรียกใช้งานจากที่ไหนก็ได้ในโปรแกรม โดยวิธีการประกาศตัวแปรให้เ็ป็น global ทำได้โดยใช้คำสั่ง GLOBAL ตามด้วยชื่อตัวแปรนั้นๆ ลองดูตัวอย่างอีกสักครั้งครับ

 <?php
	$value = 15;
	function plus() {
		GLOBAL $value;
		$value++;
		echo $value;
	}
	plus();	// ผลลัพธ์ 16
?> 

(จริงๆ แล้วมีอีกวิธีหนึ่ง คือนำตัวแปร $value ไปใส่ในตัวแปรแบบ super global ที่ชื่อ $_GLOBAL แต่วิธีนี้ เดี๋ยวเราค่อยมาคุยกันครับ)

4.Static variable

ปกติแล้ว ถ้าหากเราสร้างตัวแปรอะไรขึ้นมาสักตัวหนึ่งในฟังก์ชั่นเป็นแบบ Local variable ตัวแปรนั้นๆ จะถูกทำลายเมื่อฟังก์ชั่นนั้นทำงานเสร็จสิ้น แต่ตัวแปรแบบ Static จะยังคงอยู่ จนกว่าโปรแกรมนั้นจะทำงานเสร็จสิ้น วิธีการสร้างตัวแปร Static ก็เหมือนกับการสร้างตัวแปรทั่วๆ ไปแหละครับ แต่ให้เขียนคำสั่ง STATIC นำหน้าตัวแปรนั้นๆ ลองดูตัวอย่างกันครับ

 <?php
	function getNum() {
		STATIC $num = 0;
		$num++;
		echo $num;
		echo "<br />";
	}

	getNum();	// ผลลัพท์ 1
	getNum();	// ผลลัพท์ 2
	getNum();	// ผลลัพท์ 3
?> 

จะเห็นว่าตัวแปร $num ยังคงเก็บค่าเอาไว้ ถึงแม่ว่าฟังก์ชั่นนั้นจะทำงานเสร็จแล้วก็ตาม วิธีนี้ ใช้เขียนโปรแกรมนับจำนวนครั้งที่เรียกฟังก์ชั่นได้น่ะครับ จะได้ดูว่า โปรแกรมเรา Optimize ได้ดีหรือยัง หรือฟังก์ชั่นที่เรียกใช้บ่อยๆ สามารถเขียนให้สั้นลงกว่านี้ได้หรือไม่

ค่าคงที่ (Constant)

เป็นการกำหนดค่าที่ไม่สามารถเปลี่ยนได้ในโปรแกรมแล้ว และค่านั้นจะอยู่ไปจนจบโปรแกรม ใช้งานมากพอสมควร โดยเฉพาะการกำหนดค่าที่เรารู้แน่นอนอยู่แล้ว เช่น PI ค่าคงที่สามารถกำหนดได้โดยใช้คำสั่ง define() ลองดูตัวอย่างกันนะครับ

 <?php
	define("PI", 3.1415926);

	echo "ค่าพายคือ " . PI;	// พิมพ์ 3.1415926 ออกมา
	echo "<br />";
	$cur = 3 * 3 * PI;
	echo "พื้นที่วงกลมรัศมี 3 หน่วย คือ " . $cur; // ผลลัพท์ 28.274328
?> 

ก็จบกันไปอีกอันหนึ่งสำหรับเรื่องของตัวแปร แต่ก็ไม่จบหมดซะทีเดียว เพราะยังเหลือตัวแปรอีก 2 ชนิดคือ super global และ variable variable (ประมาณ $$a = $b; หรือ ${a}; ทำนองนี้) ก็ขอติดไว้ก่อนครับ ขออนุญาติไปเขียนตอนต่อๆ ไปก่อน เดี๋ยวจะไม่จบเอา อย่าลืมติดตามนะครับ