การแยกคำสั่ง

คำแนะนำจะถูกแยกออกในลักษณะเดียวกับใน C หรือ Perl - แต่ละนิพจน์จะลงท้ายด้วยเครื่องหมายอัฒภาค

แท็กปิด (?>) ยังหมายถึงส่วนท้ายของคำสั่งด้วย ดังนั้นข้อมูลโค้ดสองรายการต่อไปนี้จึงเทียบเท่ากัน:

echo "นี่คือการทดสอบ" ;
?>

ความคิดเห็นในสคริปต์ PHP

การเขียนสคริปต์เกือบทุกอย่างจะไม่สมบูรณ์หากไม่มีความคิดเห็น

PHP รองรับความคิดเห็นเชลล์ C, C++ และ Unix ตัวอย่างเช่น:

echo "นี่คือการทดสอบ" ; // นี่เป็นความคิดเห็นบรรทัดเดียวในรูปแบบ C++
/* นี่เป็นความคิดเห็นแบบหลายบรรทัด
แสดงความคิดเห็นอีกหนึ่งบรรทัด */
เสียงสะท้อน “นี่คือการทดสอบอีกครั้ง”;
echo "การทดสอบครั้งสุดท้าย" ; # นี่คือความคิดเห็นสไตล์เชลล์ Unix
?>

ความคิดเห็นแบบบรรทัดเดียวจะไปที่ท้ายบรรทัดหรือบล็อกปัจจุบันของโค้ด PHP เท่านั้น ขึ้นอยู่กับว่ากรณีใดจะเกิดขึ้นก่อน

นี้ ตัวอย่าง.

ชื่อด้านบนจะระบุว่า "นี่คือตัวอย่าง"

โปรดใช้ความระมัดระวังเพื่อหลีกเลี่ยงความคิดเห็น "C" ที่ซ้อนกัน เนื่องจากอาจปรากฏขึ้นเมื่อแสดงความคิดเห็นในบล็อกขนาดใหญ่:

/*
echo "นี่คือการทดสอบ"; /* ความคิดเห็นนี้จะทำให้เกิดปัญหา */
*/
?>

ความคิดเห็นแบบบรรทัดเดียวจะไปที่ท้ายบรรทัดหรือบล็อกปัจจุบันของโค้ด PHP เท่านั้น ขึ้นอยู่กับว่ากรณีใดจะเกิดขึ้นก่อน ซึ่งหมายความว่าโค้ด HTML หลังจาก // ?> จะถูกพิมพ์: ?> ออกจากโหมด PHP และกลับสู่โหมด HTML แต่ // ไม่อนุญาตให้สิ่งนี้เกิดขึ้น

ตัวแปรใน PHP

ชื่อตัวแปรถูกระบุโดย $ - สามารถรับข้อความ "สวัสดี ฉันเป็นสคริปต์ PHP!" ได้ดังนี้:

$ข้อความ= "สวัสดี ฉันชื่อสคริปต์ PHP!";
สะท้อน $ข้อความ;
?>

ประเภทข้อมูลใน PHP

PHP รองรับประเภทข้อมูลอย่างง่ายแปดประเภท:

สเกลาร์สี่ประเภท:

บูลีน (ข้อมูลไบนารี)
- จำนวนเต็ม (จำนวนเต็ม)
- ลอย (ตัวเลขจุดลอยตัวหรือ "สองเท่า")
- สตริง (สตริง)

สองประเภทผสม:

อาร์เรย์
- วัตถุ (วัตถุ)

และแบบพิเศษอีก 2 แบบ คือ

ทรัพยากร
NULL ("ว่าง")

นอกจากนี้ยังมีนามแฝงหลายประการ:

ผสม
- หมายเลข (ตัวเลข)
- โทรกลับ

เรียนรู้เพิ่มเติมเกี่ยวกับประเภทข้อมูลใน PHP

นิพจน์ใน PHP

รูปแบบหลักของนิพจน์คือค่าคงที่และตัวแปร ตัวอย่างเช่น ถ้าคุณเขียน "$a = 100" คุณจะกำหนด "100" ให้กับตัวแปร $a:

ในตัวอย่างข้างต้น $a คือตัวแปร = คือตัวดำเนินการมอบหมาย และ 100 คือนิพจน์ มูลค่าของมันคือ 100

นิพจน์ยังสามารถเป็นตัวแปรได้หากมีค่าเฉพาะที่เกี่ยวข้อง:

$x = 7;
$y = $x;

ในบรรทัดแรกของตัวอย่างที่พิจารณา นิพจน์คือค่าคงที่ 7 และในบรรทัดที่สองคือตัวแปร $x เนื่องจาก ก่อนหน้านี้มันถูกตั้งค่าเป็น 7 $y = $x ก็เป็นนิพจน์เช่นกัน

คุณสามารถหาข้อมูลเพิ่มเติมเกี่ยวกับนิพจน์ใน PHP ได้

ตัวดำเนินการ PHP

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

ตัวอย่างของคำสั่ง PHP:

ผู้ดำเนินการมอบหมาย:

$a = ($b = 4 ) + 5 ; // ผลลัพธ์: $a ถูกกำหนดเป็น 9, ตัวแปร $b ​​ถูกกำหนดเป็น 4

?>

ตัวดำเนินการรวม:

$a = 3 ;
$a += 5 ; // ตั้งค่า $a เป็น 8 คล้ายกับการเขียน: $a = $a + 5;
$b = "สวัสดี" ;
$b .= "นั่น!" - // กำหนด $b เป็นสตริง "Hello There!" เช่นเดียวกับ $b = $b "ที่นั่น!";

?>

ตัวดำเนินการสตริง:

$a = "สวัสดี" ;
$ข = $a "โลก!" - // $b มีสตริง "Hello World!"

$a = "สวัสดี" ;
$a .= "โลก!" - // $a มีสตริง "Hello World!"
?>

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

ข้อมูลโดยละเอียดเกี่ยวกับ ตัวดำเนินการ PHPคุณจะพบ.

ควบคุมโครงสร้างของภาษา PHP

โครงสร้างหลักของภาษา PHP คือ:

1. คำสั่งแบบมีเงื่อนไข (ถ้า, อย่างอื่น);
2. วนซ้ำ (ในขณะที่ ทำ-ในขณะที่ สำหรับ foreach ทำลาย ดำเนินการต่อ);
3. โครงสร้างการเลือก (สวิตช์);
4. โครงสร้างการประกาศ (ประกาศ);
5. ส่งคืนโครงสร้าง;
6. โครงสร้างการรวม (ต้องการ, รวม)

ตัวอย่างของโครงสร้างภาษา PHP:

ถ้า ($a > $b) สะท้อน "ค่าของ a มากกว่า b";
?>

ตัวอย่างข้างต้นแสดงให้เห็นการใช้งานการออกแบบอย่างชัดเจน ถ้าร่วมกับตัวดำเนินการเปรียบเทียบ ($a > $b)

ในตัวอย่างต่อไปนี้หากเป็นตัวแปร $กไม่เท่ากับศูนย์ สตริง "ค่าของ a เป็นจริง" จะถูกพิมพ์ นั่นคือ การโต้ตอบจะปรากฏขึ้น ตัวดำเนินการแบบมีเงื่อนไข(การก่อสร้าง) หากใช้ตัวดำเนินการเชิงตรรกะ:

ถ้า ($a) สะท้อน "ค่าของ a เป็นจริง";
?>

นี่คือตัวอย่างของการวนซ้ำในขณะที่:

$x = 0 ;
ในขณะที่ ($x++< 10 ) echo $ x ;
// พิมพ์ 12345678910
?>

คุณสามารถรับข้อมูลเกี่ยวกับโครงสร้างการควบคุม PHP ทั้งหมดได้

ฟังก์ชั่นที่กำหนดเองใน PHP

ภาษาโปรแกรมทุกภาษามีรูทีนย่อย ในภาษา C เรียกว่าฟังก์ชัน ในภาษาแอสเซมบลีเรียกว่ารูทีนย่อย และใน Pascal มีรูทีนย่อยอยู่ 2 ประเภท: กระบวนการและฟังก์ชัน

ใน PHP มีรูทีนย่อยดังกล่าว

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

นี่คือตัวอย่างฟังก์ชันแบบกำหนดเองใน PHP:

ฟังก์ชัน ฟังก์ชัน() (
$a = 100 ;
เสียงสะท้อน "

$ก

สคริปต์เอาต์พุต 100:

ฟังก์ชันที่ผู้ใช้กำหนดใน PHP สามารถส่งผ่านอาร์กิวเมนต์และรับค่าส่งคืนจากฟังก์ชันได้

คุณสามารถดูข้อมูลโดยละเอียดเกี่ยวกับฟังก์ชันที่กำหนดเองของ PHP ได้

ฟังก์ชัน PHP ในตัว (มาตรฐาน)

PHP มีฟังก์ชันในตัวจำนวนมากที่สามารถทำงานในระดับความซับซ้อนที่แตกต่างกันได้

OOP และ PHP

PHP มีการรองรับการเขียนโปรแกรมเชิงวัตถุ (OOP) ค่อนข้างดี

ใน PHP คุณสามารถสร้างคลาสของระดับต่างๆ วัตถุ และทำงานกับพวกมันได้อย่างยืดหยุ่น

นี่คือตัวอย่าง คลาส PHPและการใช้งาน:

// สร้างคลาส Coor ใหม่:
คลาสคูร์ (
// ข้อมูล (คุณสมบัติ):
var$ชื่อ;

// วิธีการ:
ฟังก์ชั่น Getname() (
เสียงสะท้อน "

จอห์น

หน้า PHP อย่างง่าย (สวัสดี)

สร้างไฟล์ชื่อ hello.php ในไดเร็กทอรีรากของเอกสารเว็บเซิร์ฟเวอร์ของคุณและเขียนสิ่งต่อไปนี้ลงไป:

ตัวอย่างที่ 2-1 สคริปต์ PHP ตัวแรก: hello.php
"; ?>


โปรแกรมนี้จะแสดงผลดังต่อไปนี้:
สวัสดี!

โปรดทราบว่าไม่มีความคล้ายคลึงกับสคริปต์ CGI ไฟล์ไม่จำเป็นต้องสามารถเรียกใช้งานได้หรือทำเครื่องหมายเป็นอย่างอื่น มันเป็นเพียงไฟล์ HTML ธรรมดาที่มีแท็กพิเศษมากมายซึ่งทำหน้าที่เจ๋งๆ มากมาย
โปรแกรมนี้เรียบง่ายมาก และคุณไม่จำเป็นต้องใช้ PHP เพื่อสร้างเพจง่ายๆ เช่นนี้ด้วยซ้ำ สิ่งเดียวที่ทำคือพิมพ์ว่า “Hello! โดยใช้ฟังก์ชัน PHP echo()
หากตัวอย่างนี้ไม่แสดงอะไรเลยหรือแสดงหน้าต่างดาวน์โหลด หรือหากคุณเห็นไฟล์ทั้งหมดนี้ในรูปแบบข้อความ เป็นไปได้มากว่าเว็บเซิร์ฟเวอร์ของคุณไม่รองรับ PHP ขอให้ผู้ดูแลระบบเซิร์ฟเวอร์ของคุณเปิดใช้งานการสนับสนุนนี้ เสนอคำแนะนำในการติดตั้งให้เขา - ส่วน "การติดตั้ง" ของเอกสารนี้ หากคุณต้องการพัฒนาสคริปต์ใน PHP ที่บ้าน ไฟล์ที่จำเป็นจะอยู่ในส่วนนี้ ที่บ้านคุณสามารถพัฒนาสคริปต์โดยใช้อะไรก็ได้ ระบบปฏิบัติการแต่คุณจะต้องติดตั้งเว็บเซิร์ฟเวอร์ที่เหมาะสม

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

มีมากมาย โปรแกรมแก้ไขข้อความ และ สภาพแวดล้อมการพัฒนาแบบรวม (IDE)ซึ่งคุณสามารถสร้างและแก้ไขไฟล์ PHP ได้

โปรแกรมประมวลผลคำ(นักเขียนสตาร์ออฟฟิศ, ไมโครซอฟต์ เวิร์ด, Abiword ฯลฯ) โดยส่วนใหญ่แล้วไม่เหมาะสำหรับการตัดต่อ ไฟล์ PHP- หากคุณกำลังใช้ โปรแกรมประมวลผลคำในการสร้างสคริปต์ใน PHP คุณต้องแน่ใจว่าได้บันทึกไฟล์เป็น PURE TEXT มิฉะนั้น PHP จะไม่สามารถประมวลผลและรันโปรแกรมของคุณได้

เมื่อเขียน สคริปต์ PHPโดยใช้บิวท์อิน วินโดวส์ โน้ตแพดคุณต้องบันทึกไฟล์ที่มีนามสกุล .php Notepad จะเพิ่มนามสกุล .txt โดยอัตโนมัติ มีหลายวิธีในการแก้ไขปัญหานี้
คุณสามารถใส่ชื่อไฟล์ในเครื่องหมายคำพูด (ตัวอย่าง: hello.php)
คุณยังสามารถเลือก "ไฟล์ทั้งหมด" แทน " เอกสารข้อความ» จากรายการดรอปดาวน์พร้อมประเภทไฟล์ในหน้าต่างบันทึก หลังจากนั้น คุณสามารถป้อนชื่อไฟล์โดยไม่ต้องใส่เครื่องหมายคำพูดได้

ตัวแปร

ชื่อตัวแปร

เมื่อประกาศตัวแปรใน PHP ไม่จำเป็นต้องระบุประเภทของตัวแปรอย่างชัดเจน อย่างไรก็ตาม ตัวแปรเดียวกันสามารถมีประเภทที่แตกต่างกันได้ทั่วทั้งโปรแกรม

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

ขอบเขตตัวแปร

ขอบเขตของตัวแปรคือบริบทที่ตัวแปรนั้นถูกกำหนดไว้ ตัวแปร PHP ส่วนใหญ่มีขอบเขตเดียว นอกจากนี้ยังครอบคลุมถึงไฟล์ที่รวมและไฟล์ที่จำเป็นด้วย ตัวอย่างเช่น:
$a = 1; รวมถึง "b.inc";
ที่นี่ตัวแปร $a จะพร้อมใช้งานในสคริปต์ b.inc ที่รวมไว้ อย่างไรก็ตาม ฟังก์ชันที่ผู้ใช้กำหนดจะแนะนำขอบเขตท้องถิ่นภายในฟังก์ชัน ตามค่าเริ่มต้น ตัวแปรใดๆ ที่ใช้ในฟังก์ชันจะถูกจำกัดไว้ที่ขอบเขตภายในของฟังก์ชัน ตัวอย่างเช่น:
$a = 1; /* ขอบเขตทั่วโลก */ การทดสอบฟังก์ชัน () ( echo $a; /* อ้างอิงถึงตัวแปรท้องถิ่น */ ) ทดสอบ ();
สคริปต์นี้จะไม่ส่งออกสิ่งใดเลยเนื่องจากคำสั่ง echo อ้างอิงถึงเวอร์ชันโลคัลของตัวแปร $a ซึ่งไม่มีค่าที่กำหนดให้กับตัวแปรในขอบเขตนั้น สิ่งนี้แตกต่างจากภาษา C ซึ่งตัวแปรส่วนกลางของ C จะถูกทำให้พร้อมใช้งานสำหรับฟังก์ชันต่างๆ โดยอัตโนมัติ เว้นแต่ว่าจะถูกแทนที่โดยเฉพาะในเครื่อง ซึ่งอาจทำให้เกิดปัญหาได้เนื่องจากโปรแกรมเมอร์อาจเปลี่ยนตัวแปรส่วนกลางโดยไม่ได้ตั้งใจ ใน PHP หากจะใช้ในฟังก์ชัน จะต้องประกาศตัวแปรโกลบอลในฟังก์ชันนั้น นี่คือตัวอย่าง:
$a = 1; $ข = 2; ฟังก์ชั่น ผลรวม () ( global $a, $b; $b = $a + $b; ) ผลรวม (); เสียงสะท้อน $b;
สคริปต์นี้จะส่งออกหมายเลข 3 ด้วยการประกาศ $a และ $b global ในฟังก์ชัน การอ้างอิงถึงตัวแปรเหล่านี้ทั้งหมดจะอ้างอิงถึง เวอร์ชันสากล- ไม่มีการจำกัดจำนวนตัวแปรส่วนกลางที่ฟังก์ชันสามารถจัดการได้
วิธีที่สองในการเข้าถึงตัวแปรทั่วโลกคือการใช้อาร์เรย์พิเศษที่กำหนดโดย PHP $GLOBALS ตัวอย่างก่อนหน้านี้สามารถเขียนใหม่ได้ดังนี้:
$a = 1; $ข = 2; ฟังก์ชัน ผลรวม () ( $GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"]; ) ผลรวม (); เสียงสะท้อน $b;

อาร์เรย์ $GLOBALS
อาร์เรย์ $GLOBALS คือ อาร์เรย์ที่เชื่อมโยงโดยที่ดัชนีเป็นชื่อและค่าขององค์ประกอบคือค่าของตัวแปรส่วนกลางที่สอดคล้องกัน
คุณสมบัติที่สำคัญอีกประการหนึ่งของขอบเขตตัวแปรคือตัวแปรคงที่ ตัวแปรคงที่มีเฉพาะในฟังก์ชันภายในเครื่องเท่านั้น แต่จะไม่สูญเสียค่าหลังจากที่โปรแกรมออกจากขอบเขตของฟังก์ชัน ลองพิจารณาตัวอย่างต่อไปนี้:
ทดสอบฟังก์ชัน () ( $a = 0; echo $a; $a++; )
ฟังก์ชั่นนี้ค่อนข้างไร้ประโยชน์เพราะทุกครั้งที่ถูกเรียกมันจะตั้งค่าของ $a เป็น 0 และพิมพ์ 0 นิพจน์ $a++ ที่เพิ่มค่าของตัวแปรจะไม่ทำอะไรเลย เพราะเมื่อฟังก์ชันเสร็จสิ้น ตัวแปร $a จะหายไป ในการสร้างฟังก์ชันตัวนับที่มีประโยชน์ซึ่งจะไม่สูญเสียค่า เราจะประกาศ $a เป็นค่าคงที่:
การทดสอบฟังก์ชัน () ( คงที่ $a = 0; echo $a; $a++; )
ตอนนี้ ทุกครั้งที่เรียกใช้ฟังก์ชัน Test() ฟังก์ชันจะพิมพ์ค่าของตัวแปร $a และเพิ่มค่า
นอกจากนี้ ตัวแปรคงที่ยังช่วยในการทำงานกับฟังก์ชันแบบเรียกซ้ำอีกด้วย ฟังก์ชันที่เรียกตัวเองว่าเรียกซ้ำ คุณควรระมัดระวังในการเขียนฟังก์ชันแบบเรียกซ้ำเพราะคุณสามารถทำให้การวนซ้ำไม่มีที่สิ้นสุด มีความจำเป็นต้องสร้างวิธีการขัดขวางการเรียกซ้ำ ฟังก์ชันแบบง่ายต่อไปนี้นับได้ถึง 10 โดยใช้ตัวแปรคงที่ $count และหยุดการเรียกซ้ำ:
ทดสอบฟังก์ชัน () ( static $count = 0; $count++; echo $count; if ($count< 10) { Test (); } $count--; }

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

• จำนวนเต็ม;
• เชือก;
• บูลีน;
• สองเท่า;
• อาร์เรย์;
• วัตถุ;

ทั้งหมด
ระบุจำนวนเต็มโดยใช้ไวยากรณ์ต่อไปนี้:
$a = 1234; #เลขทศนิยม
$a = -123; #จำนวนลบ
$a = 0123; #เลขฐานแปด (เทียบเท่าทศนิยม 83)
$a = 0123; # เลขฐานสิบหก (เทียบเท่าทศนิยม 18)

ขนาดของจำนวนเต็มขึ้นอยู่กับแพลตฟอร์ม แต่โดยทั่วไปแล้วค่าสูงสุดจะอยู่ที่ประมาณ 2 พันล้าน (32 บิตที่เซ็นชื่อ)
มีฟังก์ชัน gettype() ที่คืนค่าประเภทที่ PHP กำหนดให้กับตัวแปร:
"; echo(gettype($var1)); ?>
ในกรณีแรก PHP จะส่งคืนสตริง ในส่วนที่สองจะเป็นจำนวนเต็ม

ตัวเลขจุดลอยตัว
หมายเลขจุดลอยตัว ("ตัวเลขความแม่นยำสองเท่า") ได้รับการระบุโดยใช้ไวยากรณ์ต่อไปนี้:
$a = 1.234; $a = 1.2e3;
ขนาดของตัวเลขทศนิยมขึ้นอยู่กับแพลตฟอร์ม โดยทั่วไปค่าสูงสุดอาจเป็น 1.8e308 โดยมีความแม่นยำประมาณทศนิยม 14 หลัก (รูปแบบ IEEE 64 บิต)
ความสนใจ
โดยทั่วไปแล้ว ทศนิยมธรรมดา เช่น 0.1 หรือ 0.7 จะถูกแปลงเป็นตัวเลขทศนิยมสองเท่าโดยสูญเสียความแม่นยำไปบ้าง สิ่งนี้สามารถนำไปสู่ผลลัพธ์ที่แปลกได้ ตัวอย่างเช่น function floor((0.1+0.7)*10) จะส่งคืนค่า 7 แทนที่จะเป็น 8 ที่คาดไว้ เนื่องจากผลลัพธ์ของการแทนค่าภายในเป็นตัวเลขเช่น 7.9999999999....
นี่คือคำอธิบายโดยข้อเท็จจริงนี้ เศษส่วนบางประเภทไม่สามารถแสดงเป็นทศนิยมได้อย่างถูกต้องและมีจำนวนหลักจำกัด ตัวอย่างเช่น 1/3 ในรูปแบบทศนิยมจะกลายเป็น 0.3333333 - -
ดังนั้น อย่าเชื่อถือผลลัพธ์ของการคำนวณจุดลอยตัวจนถึงหลักสุดท้าย และอย่าทดสอบความเท่าเทียมกันของจุดลอยตัว หากคุณต้องการความแม่นยำสูงกว่านี้จริงๆ ให้ใช้ฟังก์ชันทางคณิตศาสตร์ที่มีความแม่นยำตามอำเภอใจหรือฟังก์ชัน gmp

สตริง
สามารถระบุสตริงได้โดยใช้ชุดตัวคั่นหนึ่งหรือสองชุด
หากสตริงอยู่ในเครื่องหมายคำพูดคู่ (") ตัวแปรในสตริงจะถูกขยาย (ขึ้นอยู่กับข้อจำกัดในการแยกวิเคราะห์บางประการ) เช่นเดียวกับใน C และ Perl เมื่อระบุ อักขระพิเศษแบ็กสแลช ("\") สามารถใช้ได้:

ตารางที่ 6-1. อักขระที่เข้ารหัสโดยใช้แบ็กสแลช

หากคุณพยายามแสดงอักขระอื่นด้วยวิธีนี้ ทั้งแบ็กสแลชและอักขระนั้นจะถูกพิมพ์ออกมา ใน PHP 3 สิ่งนี้จะออกคำเตือนที่ระดับ E_NOTICE ใน PHP 4 ไม่มีการสร้างข้อความเตือน
วิธีที่สองในการแยกสตริงคือการใช้เครื่องหมายคำพูดเดี่ยว (""") หากสตริงอยู่ในเครื่องหมายคำพูดเดี่ยวอักขระเดียวเท่านั้นที่สามารถใช้ได้ภายในสตริงคือ "\\" และ "\"" วิธีนี้ทำให้คุณสามารถระบุเครื่องหมายคำพูดเดี่ยวและแบ็กสแลชในสตริงที่คั่นด้วยเครื่องหมายคำพูดเดี่ยวได้ ตัวแปรในบรรทัดที่คั่นด้วยเครื่องหมายคำพูดเดี่ยวจะไม่ถูกขยาย
อีกวิธีหนึ่งในการแยกสตริงคือการใช้ไวยากรณ์ของเอกสาร ("<<<"). После <<< укажите идентификатор, затем строку, а затем тот же самый идентификатор, чтобы закрыть «кавычки».
ตัวระบุการปิดจะต้องเริ่มต้นในคอลัมน์แรกของแถว นอกจากนี้ ตัวระบุต้องเป็นไปตามรูปแบบการตั้งชื่อของป้ายกำกับใดๆ ใน PHP โดยจะต้องมีเฉพาะอักขระตัวอักษรและตัวเลขและขีดล่าง และต้องไม่ขึ้นต้นด้วยตัวเลขหรือขีดล่าง
ข้อความดังกล่าวมีลักษณะการทำงานเหมือนกับสตริงที่มีเครื่องหมายคำพูดคู่ แต่ไม่มีเครื่องหมายคำพูดคู่ ซึ่งหมายความว่าคุณไม่จำเป็นต้องเข้ารหัสเครื่องหมายคำพูดด้วยเครื่องหมายทับ แต่คุณยังสามารถใช้การเข้ารหัสเครื่องหมายทับได้ ตัวแปรถูกขยาย แต่ควรใช้ความระมัดระวังเมื่อแสดงตัวแปรที่ซับซ้อนในสตริงดังกล่าว ตัวอย่างที่ 6-1 ตัวอย่างเครื่องหมายคำพูดในสตริงประเภทเอกสาร
ฟู = "ฟู";<<$this->bar = array("Bar1", "Bar2", "Bar3");
) ) $foo = ใหม่ foo(); $name = "ชื่อของฉัน"; เสียงสะท้อน
ฟู ตอนนี้ฉันพิมพ์ ($foo->bar) ควรพิมพ์อักษรตัวใหญ่ "A" ที่นี่: \x41 EOT; -
หมายเหตุ: มีการเพิ่มการสนับสนุนสำหรับรายการสตริงนี้ใน PHP 4

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

หมายเลข: 9

หมายเลข: 9

หมายเลข: 9

"; /* อันนี้จะเป็น "
"; /* รับอักขระตัวแรกของสตริง */ $str = "นี่คือการทดสอบ"; $first = $str; /* รับอักขระตัวสุดท้ายของสตริง */ $str = "นี่ยังคงเป็น ทดสอบ"; $last = $str ; ?>
การแปลงสตริง
หากสตริงประเมินเป็นค่าตัวเลข ค่าผลลัพธ์และประเภทจะถูกกำหนดดังนี้
สตริงจะถูกประเมินเป็นสองเท่าหากมีอักขระใดๆ ".", "e" หรือ "E" มิฉะนั้นจะถูกประเมินเป็นจำนวนเต็ม
$ฟู = 1 + "10.5"; // $foo มีความแม่นยำสองเท่า (11.5) $foo = 1 + "-1.3e3"; // $foo มีความแม่นยำสองเท่า (-1299) $foo = 1 + "bob-1.3e3"; // $foo - จำนวนเต็ม (1) $foo = 1 + "bob3"; // $foo - จำนวนเต็ม (1) $foo = 1 + "หมูตัวเล็ก 10 ตัว"; // $foo - จำนวนเต็ม (11) $foo = 1 + "ลูกหมู 10 ตัว"; // $foo - จำนวนเต็ม (11) $foo = "10.0 สุกร " + 1; // $foo - จำนวนเต็ม (11) $foo = "10.0 สุกร " + 1.0; // $foo มีความแม่นยำสองเท่า (11)

\n";

อาร์เรย์หนึ่งมิติ
PHP รองรับสเกลาร์และอาเรย์แบบเชื่อมโยง จริงๆแล้วไม่มีความแตกต่างระหว่างพวกเขา คุณสามารถสร้างอาร์เรย์ได้โดยใช้ฟังก์ชัน list() หรือ array() หรือโดยการกำหนดค่าขององค์ประกอบอาร์เรย์อย่างชัดเจน
$a = "เอบีซี"; $a = "def"; $b["ฟู"] = 13;
คุณยังสามารถสร้างอาร์เรย์ได้โดยการเพิ่มองค์ประกอบเข้าไป เมื่อกำหนดค่าให้กับตัวแปรอาร์เรย์ด้วยวงเล็บว่าง ค่าดังกล่าวจะถูกผนวกเข้ากับส่วนท้ายของอาร์เรย์
$a = "สวัสดี"; // $a == "สวัสดี" $a = "โลก"; // $a == "โลก"
คุณสามารถจัดเรียงอาร์เรย์ได้โดยใช้ฟังก์ชัน asort(), arsort(), ksort(), rsort(), sort(), uasort(), usort() และ uksort() ขึ้นอยู่กับประเภทการเรียงลำดับที่ต้องการ
คุณสามารถนับจำนวนองค์ประกอบในอาร์เรย์ได้โดยใช้ฟังก์ชัน count()
คุณสามารถเลื่อนดูอาร์เรย์ได้โดยใช้ฟังก์ชัน next() และ prev() อีกวิธีหนึ่งในการย้ายผ่านอาร์เรย์คือการใช้ฟังก์ชัน Each()

การแปลงประเภท
PHP ไม่ต้องการ (หรือสนับสนุน) การประกาศประเภทที่ชัดเจนเมื่อประกาศตัวแปร ประเภทของตัวแปรจะถูกกำหนดโดยบริบทที่ใช้ นั่นคือ ถ้าคุณกำหนดค่าสตริงให้กับ var var ก็จะกลายเป็นสตริง หากคุณกำหนดค่าจำนวนเต็ม var ก็จะกลายเป็นจำนวนเต็ม
ตัวอย่างของการแปลงประเภท PHP อัตโนมัติคือตัวดำเนินการเพิ่มเติม "+" ถ้าตัวถูกดำเนินการใดๆ มีความแม่นยำสองเท่า ตัวถูกดำเนินการทั้งหมดจะถูกประเมินเป็นตัวเลขที่มีความแม่นยำสองเท่า และผลลัพธ์จะเป็นตัวเลขที่มีความแม่นยำสองเท่า มิฉะนั้น ตัวถูกดำเนินการจะถูกตีความว่าเป็นจำนวนเต็ม และผลลัพธ์จะเป็นจำนวนเต็มด้วย โปรดทราบว่าประเภทของตัวถูกดำเนินการจะไม่เปลี่ยนแปลง มีเพียงการประเมินตัวถูกดำเนินการเท่านั้นที่เปลี่ยนแปลง
$ฟู = "0"; // $foo - string "0" (ASCII 48) $foo++; // $foo - สตริง "1" (ASCII 49) $foo += 1; // $foo ตอนนี้เป็นจำนวนเต็ม (2) $foo = $foo + 1.3; // $foo ตอนนี้เป็นตัวเลขที่มีความแม่นยำสองเท่า (3.3) $foo = 5 + "10 Little Piggies"; // $foo - จำนวนเต็ม (15) $foo = 5 + "หมูน้อย 10 ตัว"; // $foo - จำนวนเต็ม (15)
หากสองตัวอย่างสุดท้ายดูแปลกสำหรับคุณ โปรดดูส่วนการแปลงสตริง
หากคุณต้องการให้ตัวแปรมีประเภทเฉพาะ โปรดดูส่วน Type Coercion หากคุณต้องการเปลี่ยนประเภทของตัวแปร โปรดดูส่วน settype()
คุณสามารถทดสอบตัวอย่างในส่วนนี้ได้โดยเพิ่มบรรทัดต่อไปนี้:
echo "\$foo==$foo; พิมพ์ " gettype($foo) . -
\n";
หมายเหตุ: พฤติกรรมของการแปลงอัตโนมัติยังไม่ได้กำหนดไว้ในขณะนี้
$a = 1; // $a - จำนวนเต็ม $a = "f"; // $a กลายเป็นอาร์เรย์ องค์ประกอบ $a เก็บตัวอักษร "f"
แม้ว่าบรรทัดด้านบนดูเหมือนจะทำให้ $a กลายเป็นอาร์เรย์ที่มีองค์ประกอบแรกเป็น "f" อย่างชัดเจน ให้ลองพิจารณาตัวอย่างต่อไปนี้:
$a = "1"; // $a - string $a = "f"; // แล้วการเลื่อนบรรทัดล่ะ? จะเกิดอะไรขึ้น?
เนื่องจาก PHP รองรับสตริงการจัดทำดัชนีผ่าน shift โดยใช้ไวยากรณ์เดียวกันกับอาร์เรย์การจัดทำดัชนี ตัวอย่างข้างต้นอาจทำให้เกิดปัญหา: $a จะกลายเป็นอาร์เรย์ที่มีองค์ประกอบแรก f หรือ f จะกลายเป็นอักขระตัวแรกของสตริง $a หรือไม่
ด้วยเหตุนี้ ตั้งแต่ PHP 3.0.12 และ PHP 4.0b3-RC4 ผลลัพธ์ของการแปลงอัตโนมัติจึงถือว่าไม่ได้กำหนดไว้ มีการอภิปรายเกี่ยวกับวิธีการแก้ไขปัญหานี้

ประเภทการหล่อ
การหล่อประเภทใน PHP ทำงานเหมือนกับใน C: ชื่อของประเภทที่ต้องการจะถูกระบุในวงเล็บก่อนที่จะส่งตัวแปร
$ฟู = 10; // $foo - จำนวนเต็ม $bar = (สองเท่า) $foo; // $bar มีความแม่นยำสองเท่า
อนุญาตให้ร่ายดังต่อไปนี้:

• (int), (จำนวนเต็ม) - แปลงเป็นจำนวนเต็ม
• (จริง), (สองเท่า), (ลอย) - แปลงเป็นสองเท่า
• (สตริง) - แคสต์เป็นประเภทสตริง
• (array) - ส่งเป็นประเภทอาเรย์
• (วัตถุ) - ส่งเพื่อพิมพ์วัตถุ

โปรดทราบว่าอนุญาตให้ใช้แท็บและช่องว่างในวงเล็บได้ ดังนั้นนิพจน์ต่อไปนี้จึงเทียบเท่ากัน:
$foo = (int) $บาร์; $foo = (int) $บาร์;
บางครั้งผลการหล่อทั้งสองแบบก็ไม่ชัดเจน ตัวอย่างเช่น คุณควรใส่ใจกับสิ่งต่อไปนี้
เมื่อส่งตัวแปรสเกลาร์หรือสตริงลงในอาร์เรย์ ตัวแปรนั้นจะกลายเป็นองค์ประกอบแรกของอาร์เรย์:
$var = "เซียว"; $arr = (อาร์เรย์) $var; เสียงสะท้อน $arr; // เอาท์พุท: "ciao"
เมื่อคุณแปลงตัวแปรสเกลาร์หรือสตริงเป็นวัตถุ ตัวแปรจะกลายเป็นคุณลักษณะของวัตถุ ชื่อแอตทริบิวต์จะเป็น "สเกลาร์":
$var = "เซียว"; $obj = (วัตถุ) $var; echo $obj->สเกลาร์; // เอาท์พุท: "ciao"

ค่าคงที่

ชื่อคงที่
ค่าคงที่เป็นตัวระบุค่าอย่างง่าย จากชื่อของพวกเขา เป็นเรื่องง่ายที่จะเข้าใจว่าค่าของพวกเขาไม่สามารถเปลี่ยนแปลงได้ในระหว่างการเรียกใช้สคริปต์ (ข้อยกเว้นคือค่าคงที่ “เวทย์มนตร์” ซึ่งจริงๆ แล้วไม่ใช่ค่าคงที่ในความหมายเต็มของคำ) ชื่อคงที่จะคำนึงถึงขนาดตัวพิมพ์ ตามแบบแผน ชื่อคงที่จะเขียนด้วยตัวพิมพ์ใหญ่เสมอ
ชื่อของค่าคงที่จะต้องเป็นไปตามกฎเดียวกันกับที่ใช้กับชื่ออื่นๆ ใน PHP ชื่อที่ถูกต้องขึ้นต้นด้วยตัวอักษรหรือขีดล่าง และประกอบด้วยตัวอักษร ตัวเลข และขีดล่าง นิพจน์ทั่วไปสำหรับตรวจสอบความถูกต้องของชื่อคงที่มีลักษณะดังนี้: *
หมายเหตุ: คำว่า "ตัวอักษร" ในที่นี้หมายถึงอักขระ a-z, A-Z และอักขระอื่นๆ ที่มีรหัส ASCII 127 ถึง 255 (0x7f-0xff)

การประกาศค่าคงที่
คุณสามารถกำหนดค่าคงที่ได้โดยใช้ฟังก์ชัน Defin() เมื่อกำหนดค่าคงที่แล้ว ค่าของมันจะไม่สามารถเปลี่ยนแปลงหรือทำให้เป็นโมฆะได้
ค่าคงที่จะมีได้เฉพาะข้อมูลสเกลาร์เท่านั้น (บูลีน จำนวนเต็ม ทศนิยม และสตริง)
คุณสามารถรับค่าคงที่ได้โดยการระบุชื่อ ไม่เหมือนกับตัวแปร คุณไม่จำเป็นต้องนำสัญลักษณ์ $ นำหน้าชื่อคงที่ คุณยังสามารถใช้ฟังก์ชันคงที่() เพื่อรับค่าคงที่ได้หากคุณสร้างชื่อค่าคงที่แบบไดนามิก ใช้ฟังก์ชัน get_known_constants() เพื่อรับรายการค่าคงที่ที่ประกาศทั้งหมด
หมายเหตุ: ตัวแปรค่าคงที่และ (ทั่วโลก) อยู่ในเนมสเปซที่แตกต่างกัน ซึ่งหมายความว่า ตัวอย่างเช่น TRUE และ $TRUE เป็นสิ่งที่แตกต่างกันโดยสิ้นเชิง
หากคุณใช้ค่าคงที่ที่ไม่ได้กำหนดไว้ PHP จะถือว่าคุณหมายถึงชื่อของค่าคงที่ เหมือนกับว่าคุณได้ระบุตัวแปรประเภทสตริง (CONSTANT และ CONSTANT) สิ่งนี้จะสร้างข้อผิดพลาดประเภท E_NOTICE ดูบทคู่มือที่อธิบายว่าทำไม $foo ถึงผิด (เว้นแต่คุณจะประกาศ bar เป็นค่าคงที่ก่อนหน้านี้โดยใช้ Defin()) หากคุณต้องการตรวจสอบว่ามีค่าคงที่หรือไม่ ให้ใช้ฟังก์ชัน Defined()

ความแตกต่างระหว่างค่าคงที่และตัวแปร:

• ค่าคงที่ไม่มีเครื่องหมายดอลลาร์นำหน้า ($);
• ค่าคงที่สามารถกำหนดได้โดยใช้ฟังก์ชัน Defin() เท่านั้น ไม่ใช่โดยการกำหนดค่า
• สามารถกำหนดและเข้าถึงค่าคงที่ได้ทุกที่โดยไม่คำนึงถึงขอบเขต
• ค่าคงที่ไม่สามารถกำหนดหรือทำให้เป็นโมฆะได้หลังจากการประกาศครั้งแรก และ
• ค่าคงที่จะมีได้เฉพาะค่าสเกลาร์เท่านั้น

ตัวอย่างที่ 13-1 คำจำกัดความของค่าคงที่

ขอบเขตคงที่
เช่นเดียวกับ superglobals ค่าคงที่สามารถเข้าถึงได้จากทุกขอบเขต คุณสามารถใช้ค่าคงที่ได้ทุกที่ในสคริปต์ของคุณ โดยไม่คำนึงถึงขอบเขตปัจจุบัน สามารถดูข้อมูลเพิ่มเติมเกี่ยวกับขอบเขตได้ที่นี่

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

ตารางที่ 13-1. ค่าคงที่ PHP "วิเศษ" บางตัว

เอาต์พุตแบบง่าย

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

คุณป้อน:

นิพจน์ PHP

นิพจน์ถือเป็นรากฐานสำคัญของ PHP เกือบทุกสิ่งที่คุณเขียนใน PHP นั้นเป็นนิพจน์ คำจำกัดความที่ง่ายและแม่นยำที่สุดของสำนวนนี้คือ “สิ่งใดก็ตามที่มีความหมาย”
รูปแบบหลักของนิพจน์คือค่าคงที่และตัวแปร หากคุณเขียน "$a = 5" คุณกำลังกำหนด "5" ให้กับตัวแปร $a แน่นอนว่า "5" มีค่าเป็น 5 หรืออีกนัยหนึ่ง "5" คือนิพจน์ที่มีค่า 5 (ในกรณีนี้ "5" คือค่าคงที่จำนวนเต็ม)
หลังจากการมอบหมายนี้ คุณคาดหวังว่าค่าของ $a จะเป็น 5 เช่นกัน ดังนั้นหากคุณเขียน $b = $a คุณคาดหวังว่ามันจะทำงานเหมือนกับที่คุณเขียน $b = 5 กล่าวอีกนัยหนึ่ง $a นี่คือ ยังเป็นนิพจน์ที่มีค่า 5 หากทุกอย่างทำงานถูกต้องนี่คือสิ่งที่จะเกิดขึ้นอย่างแน่นอน
ตัวอย่างนิพจน์ที่ซับซ้อนกว่าเล็กน้อยคือฟังก์ชัน ตัวอย่างเช่น พิจารณาฟังก์ชันต่อไปนี้:

สมมติว่าคุณคุ้นเคยกับแนวคิดเรื่องฟังก์ชันเป็นอย่างดี (หากไม่ ให้อ่านบทเกี่ยวกับฟังก์ชัน) คุณจะเชื่อว่ารายการดังกล่าว
$c = foo() เทียบเท่ากับการเขียน $c = 5 อย่างแน่นอนและคุณพูดถูก ฟังก์ชันคือนิพจน์ที่มีค่าเท่ากับสิ่งที่ฟังก์ชันส่งคืน เนื่องจาก foo() ส่งคืนค่า 5 ค่าของนิพจน์ "foo()" จึงเป็น 5 โดยทั่วไปแล้ว ฟังก์ชันต่างๆ ไม่เพียงแต่ส่งคืนค่าคงที่เท่านั้น แต่ยังประเมินบางสิ่งบางอย่างอีกด้วย
แน่นอนว่าค่าใน PHP ไม่จำเป็นต้องเป็นจำนวนเต็ม และบ่อยครั้งที่ค่าเหล่านั้นไม่ใช่ PHP รองรับค่าสเกลาร์สามประเภท: จำนวนเต็ม จุดลอยตัว และค่าสตริง (สเกลาร์เป็นค่าที่คุณไม่สามารถ "แยก" ออกเป็นชิ้นเล็ก ๆ ได้ ซึ่งแตกต่างจากอาร์เรย์ เป็นต้น) PHP ยังรองรับสองประเภทที่รวมกัน (ไม่ใช่สเกลาร์) ได้แก่ อาร์เรย์และอ็อบเจ็กต์ ค่าแต่ละประเภทสามารถกำหนดให้กับตัวแปรหรือส่งกลับโดยฟังก์ชันได้
จนถึงขณะนี้ ผู้ใช้ PHP/FI 2 ไม่ควรสังเกตเห็นการเปลี่ยนแปลงใดๆ อย่างไรก็ตาม PHP ก็เหมือนกับภาษาอื่นๆ มากมาย ที่เข้าใจสำนวนต่างๆ มากมาย PHP เป็นภาษาที่เน้นการแสดงออกและถือว่าเกือบทุกอย่างเป็นการแสดงออก กลับไปที่ตัวอย่างที่เราจัดการไปแล้ว: "$a = 5" เห็นได้ง่ายว่ามีสองค่าที่นี่ - ค่าของค่าคงที่จำนวนเต็ม "5" และค่าของตัวแปร $a ซึ่งรับค่า 5 เช่นกัน แต่ในความเป็นจริง ยังมีอีกค่าหนึ่งที่นี่ - มูลค่าของงานนั้นเอง การมอบหมายงานจะประเมินเป็นค่าที่กำหนด ในกรณีนี้คือ 5 ในทางปฏิบัติ หมายความว่า "$a = 5" ไม่ว่าจะทำอะไรก็ตาม ก็คือนิพจน์ที่มีค่าเป็น 5 ดังนั้น การเขียน "$b = ( $ a = 5)" เทียบเท่ากับการเขียน "$a = 5; $b = 5;" (เครื่องหมายอัฒภาคเป็นจุดสิ้นสุดของนิพจน์) เนื่องจากการดำเนินการมอบหมายงานจะถูกแยกวิเคราะห์จากขวาไปซ้าย คุณจึงสามารถเขียน "$b = $a = 5" ได้เช่นกัน
อีกตัวอย่างที่ดีของการเน้นการแสดงออกคือการเพิ่มขึ้นและการลดลงก่อนและหลัง ผู้ใช้ PHP/FI 2 และภาษาอื่นๆ มากมายอาจคุ้นเคยกับสัญลักษณ์ตัวแปร++ และตัวแปร-- อยู่แล้ว เหล่านี้คือตัวดำเนินการเพิ่มและลดค่า ใน PHP/FI 2 การดำเนินการ ""$a"" ไม่มีความหมาย (ไม่ใช่นิพจน์) ดังนั้นคุณจึงไม่สามารถกำหนดหรือใช้งานในทางใดทางหนึ่งได้ PHP ปรับปรุงความสามารถในการเพิ่ม/ลดโดยทำให้เป็นนิพจน์ เช่นเดียวกับใน C เช่นเดียวกับ C PHP รองรับการเพิ่มขึ้นสองประเภท - คำนำหน้าและ postfix พวกเขาทั้งสองเพิ่มค่าของตัวแปรและผลกระทบต่อตัวแปรจะเหมือนกัน ความแตกต่างคือความหมายของการแสดงออกที่เพิ่มขึ้น การเพิ่มคำนำหน้าซึ่งเขียนเป็น " $variable" จะถูกประเมินเป็นค่าที่เพิ่มขึ้น (PHP เพิ่มตัวแปรก่อนที่จะอ่านค่าของมัน ดังนั้นชื่อ "การเพิ่มล่วงหน้า") การเพิ่ม postfix ซึ่งเขียนเป็น "$variable++" จะถูกคำนวณเป็นค่าเดิมของตัวแปร $variable ก่อนที่จะเพิ่มค่านั้น (PHP จะเพิ่มตัวแปรหลังจากอ่านค่าของมันแล้ว ดังนั้นชื่อ "post-increation")
ประเภทของนิพจน์ที่พบบ่อยมากคือนิพจน์การเปรียบเทียบ โดยประเมินเป็น 0 หรือ 1 ซึ่งหมายถึง FALSE หรือ TRUE ตามลำดับ PHP รองรับ > (มากกว่า), >= (มากกว่าหรือเท่ากับ), == (เท่ากับ), != (ไม่เท่ากับ),< (меньше) и <= (меньше либо равно). Он также поддерживает операторы строгого равенства: === (равно и одного типа) и!== (не равно или не одного типа). Чаще всего эти выражения используются в условиях выполнения операторов, таких как if.
ตัวอย่างสุดท้ายของนิพจน์ที่เราจะดูที่นี่คือการดำเนินการแบบผสมและนิพจน์การกำหนด คุณรู้อยู่แล้วว่าถ้าคุณต้องการเพิ่ม $a ขึ้น 1 คุณสามารถเขียนว่า "$a" หรือ "$a" ได้ แต่ถ้าคุณต้องการเพิ่มมากกว่าหนึ่งรายการ เช่น 3 ล่ะ? คุณสามารถเขียน "$a++" ได้หลายครั้ง แต่เห็นได้ชัดว่านี่ไม่ใช่วิธีที่มีประสิทธิภาพหรือสะดวกนัก วิธีปฏิบัติทั่วไปมากกว่านั้นคือเขียนว่า "$a = $a + 3" "$a + 3" คำนวณเป็น $a บวก 3 และกำหนดให้ $a อีกครั้ง โดยเพิ่มขึ้น $a 3 ใน PHP เช่นเดียวกับในภาษาอื่นบางภาษา เช่น C คุณสามารถเขียนสิ่งนี้ด้วยวิธีที่สั้นกว่า ซึ่งจะช่วยเพิ่มความชัดเจนของความหมายและความรวดเร็วในการทำความเข้าใจโค้ดเมื่อเวลาผ่านไป คุณสามารถเพิ่ม 3 เข้ากับค่าปัจจุบันของ $a โดยใช้สัญลักษณ์ "$a += 3" ความหมายที่แท้จริงคือ “นำค่า $a บวก 3 เข้าไป แล้วกำหนดกลับไปยังตัวแปร $a” นอกจากจะเข้าใจง่ายและกระชับแล้วยังทำงานได้เร็วขึ้นอีกด้วย ค่าของ "$a += 3" เช่นเดียวกับการกำหนดปกติ คือค่าที่กำหนด โปรดทราบว่านี่ไม่ใช่ 3 แต่เป็นมูลค่ารวมของ $a บวก 3 (สิ่งที่กำหนดให้กับ $a) ตัวดำเนินการสองตำแหน่งใดๆ สามารถใช้ในลักษณะนี้ได้ เช่น "$a -= 5" (ลบ 5 จากค่าของ $a), "$b *= 7" (คูณค่าของ $b ด้วย 7) ฯลฯ
มีสำนวนอื่นที่อาจดูผิดปกติหากคุณไม่เคยเห็นในภาษาอื่น - ตัวดำเนินการแบบมีเงื่อนไขแบบไตรภาค:

หากค่าของนิพจน์ย่อยแรกเป็น TRUE (ไม่ใช่ศูนย์) นิพจน์ย่อยที่สองจะถูกดำเนินการ ซึ่งจะเป็นผลจากนิพจน์แบบมีเงื่อนไข มิฉะนั้น นิพจน์ย่อยที่สามจะถูกดำเนินการ และค่าของมันจะเป็นผลลัพธ์
ตัวอย่างต่อไปนี้จะช่วยให้คุณเข้าใจการเพิ่มคำนำหน้าและคำนำหน้าและนิพจน์ได้ดีขึ้นเล็กน้อย:

สำนวนบางอย่างถือได้ว่าเป็นคำแนะนำ ในกรณีนี้ คำสั่งจะดูเหมือน "expression" ";" - นิพจน์ที่ตามด้วยเครื่องหมายอัฒภาค ในรายการ "$b=$a=5;" $a=5 เป็นนิพจน์ที่ถูกต้อง แต่ไม่ใช่คำสั่งในตัวเอง ในขณะที่ "$b=$a=5;" เป็นคำสั่งสอนที่ถูกต้อง
สิ่งสุดท้ายที่ควรกล่าวถึงคือคุณค่าความจริงของสำนวน ในหลายกรณี โดยทั่วไปแล้วคำสั่งและลูปแบบมีเงื่อนไข คุณอาจไม่สนใจค่าเฉพาะของนิพจน์ แต่จะสนใจเฉพาะค่าที่เป็น TRUE หรือ FALSE เท่านั้น ค่าคงที่ TRUE และ FALSE (ไม่คำนึงถึงขนาดตัวพิมพ์) คือค่าบูลีนที่เป็นไปได้สองค่า หากจำเป็น นิพจน์จะถูกแปลงเป็นประเภทบูลีนโดยอัตโนมัติ สำหรับข้อมูลเพิ่มเติมว่าสิ่งนี้เกิดขึ้นได้อย่างไร โปรดดูหัวข้อการคัดเลือกประเภท
PHP นำเสนอการใช้งานนิพจน์ที่สมบูรณ์และมีประสิทธิภาพ และเอกสารประกอบที่สมบูรณ์นั้นอยู่นอกเหนือขอบเขตของบทช่วยสอนนี้ ตัวอย่างข้างต้นน่าจะทำให้คุณเข้าใจว่ามันคืออะไรและคุณสามารถสร้างสำนวนที่มีประโยชน์ด้วยตัวเองได้อย่างไร ต่อไปนี้ เราจะใช้ตัวย่อ expr เพื่อแสดงถึงนิพจน์ PHP ที่ถูกต้องในเอกสารนี้

ตัวดำเนินการ PHP

ตัวดำเนินการคือสิ่งที่ประกอบด้วยค่าตั้งแต่หนึ่งค่าขึ้นไป (นิพจน์ในศัพท์แสงการเขียนโปรแกรม) ที่สามารถประเมินเป็นค่าใหม่ได้ (ดังนั้น โครงสร้างทั้งหมดจึงถือเป็นนิพจน์ได้) ตามนั้นฟังก์ชันหรือโครงสร้างอื่นใดที่ส่งคืนค่า (เช่น print()) เป็นคำสั่ง ซึ่งแตกต่างจากโครงสร้างภาษาอื่น ๆ ทั้งหมด (เช่น echo()) ที่ไม่ส่งคืนสิ่งใดเลย
ตัวดำเนินการมีสามประเภท ประการแรก มีตัวดำเนินการเอกภาคซึ่งดำเนินการกับอาร์กิวเมนต์เดียวเท่านั้น เช่น ! (ตัวดำเนินการปฏิเสธ) หรือ ++ (เพิ่มขึ้น) กลุ่มที่สองประกอบด้วยตัวดำเนินการไบนารี: ประกอบด้วยตัวดำเนินการส่วนใหญ่ที่รองรับใน PHP ซึ่งเป็นรายการทั้งหมดที่คุณสามารถดูได้ในส่วนคำสั่งการดำเนินการของตัวดำเนินการ
และกลุ่มสุดท้ายกลุ่มที่สามคือตัวดำเนินการที่ประกอบด้วย: ใช้เพื่อเลือกแบบมีเงื่อนไขระหว่างตัวดำเนินการสองตัว ขึ้นอยู่กับผลลัพธ์ของการประเมินของผู้ดำเนินการตัวที่สาม กล่าวอีกนัยหนึ่ง ช่วยให้คุณสามารถกำหนดทางเลือกอีกสองสาขาของการดำเนินการเพิ่มเติมได้ ขอแนะนำให้ใส่ตัวดำเนินการแบบไตรภาคไว้ในวงเล็บ

ลำดับความสำคัญในการดำเนินการของตัวดำเนินการ
ลำดับความสำคัญของตัวดำเนินการจะกำหนดว่านิพจน์ทั้งสอง "ใกล้เคียงกัน" มีความสัมพันธ์กันอย่างไร ตัวอย่างเช่น นิพจน์ 1 + 5 * 3 ประเมินเป็น 16 มากกว่า 18 เนื่องจากตัวดำเนินการคูณ ("*") มีลำดับความสำคัญสูงกว่าตัวดำเนินการบวก ("+") หากตัวดำเนินการมีลำดับความสำคัญเท่ากัน พวกเขาจะถูกดำเนินการจากซ้ายไปขวา วงเล็บสามารถใช้เพื่อบังคับลำดับการดำเนินการคำสั่งที่จำเป็น ตัวอย่างเช่น นิพจน์ (1 + 5) * 3 ประเมินเป็น 18
ตารางต่อไปนี้แสดงรายการตัวดำเนินการ จัดเรียงตามลำดับความสำคัญจากมากไปน้อย ผู้ดำเนินการที่อยู่ในบรรทัดเดียวกันจะมีลำดับความสำคัญเท่ากัน และลำดับการดำเนินการจะพิจารณาจากความสัมพันธ์ของพวกเขา

ตารางที่ 15-1. คำสั่งการดำเนินการของผู้ปฏิบัติงาน

การเชื่อมโยงด้านซ้ายบอกเป็นนัยว่านิพจน์ถูกประเมินจากซ้ายไปขวา การเชื่อมโยงทางขวาตามลำดับแสดงถึงลำดับที่ตรงกันข้าม ตัวอย่างที่ 15-1 การเชื่อมโยง
$a = 5, $b = 5 ?>
คุณสามารถใช้วงเล็บเพื่อทำให้โค้ดของคุณอ่านง่ายขึ้น
หมายเหตุ: ทั้งๆ ที่ผู้ประกอบการ! มีลำดับความสำคัญสูงกว่า = PHP อนุญาตให้ใช้โครงสร้างต่อไปนี้: if (!$a = foo()) ซึ่งกำหนดตัวแปร $a ซึ่งเป็นผลลัพธ์ของการดำเนินการฟังก์ชัน foo()

ตัวดำเนินการทางคณิตศาสตร์
จำพื้นฐานของคณิตศาสตร์ของโรงเรียนได้ไหม? ข้อความด้านล่างทำงานในลักษณะเดียวกัน

ตารางที่ 15-2. การดำเนินการทางคณิตศาสตร์

ตัวดำเนินการหาร ("/") จะส่งกลับประเภทจริงเสมอ แม้ว่าทั้งสองค่าจะเป็นจำนวนเต็ม (หรือสตริงที่แปลงเป็นจำนวนเต็ม)
หมายเหตุ: ส่วนที่เหลือของ $a % $b จะเป็นค่าลบสำหรับค่าลบของ $a
คุณสามารถตรวจสอบส่วนเอกสารประกอบ ฟังก์ชันทางคณิตศาสตร์ ได้

ตัวดำเนินการบิต
ตัวดำเนินการ Bitwise อนุญาตให้คุณตั้งค่าบิตเฉพาะเป็น 0 หรือ 1 สำหรับค่าจำนวนเต็ม ถ้าทั้งตัวถูกดำเนินการด้านซ้ายและขวาเป็นสตริง การดำเนินการระดับบิตจะทำงานบนการแสดงค่า ASCII

ตารางที่ 15-3. ตัวดำเนินการ Bitwise

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

ตัวดำเนินการเชิงตรรกะ
ตารางที่ 15-6. ตัวดำเนินการเชิงตรรกะ

เหตุผลสำหรับสองตัวเลือกที่แตกต่างกันสำหรับตัวดำเนินการ และ และ หรือ คือ พวกมันทำงานโดยมีลำดับความสำคัญที่แตกต่างกัน (ดูตารางลำดับความสำคัญของการดำเนินการของตัวดำเนินการ)

ไวยากรณ์ PHP พื้นฐาน

คำสั่ง if-then-else แบบมีเงื่อนไข ไวยากรณ์ทางเลือก

ถ้าคำสั่ง
นี่เป็นหนึ่งในโอเปอเรเตอร์ที่สำคัญที่สุดในหลายภาษา รวมถึง PHP ด้วย ช่วยให้คุณสามารถรันโค้ดบางส่วนตามเงื่อนไขได้ โครงสร้างของคำสั่ง if สามารถแสดงได้ดังนี้:
ถ้า (การแสดงออก) การดำเนินการ_บล็อก
ในที่นี้นิพจน์คือนิพจน์ PHP ที่ถูกต้อง (เช่น สิ่งใดก็ตามที่สำคัญ) ในระหว่างการประมวลผลสคริปต์ นิพจน์จะถูกแปลงเป็นประเภทบูลีน หากผลลัพธ์ของการแปลงคือนิพจน์เป็น True ระบบจะประมวลผลExecution_block มิฉะนั้นExecution_blockจะถูกละเว้น หาก act_block มีหลายคำสั่ง จะต้องอยู่ในเครื่องหมายปีกกา ( )

กฎสำหรับการแปลงนิพจน์เป็นประเภทบูลีน:

1. ค่าต่อไปนี้จะถูกแปลงเป็น FALSE:

• ตรรกะเท็จ
• ศูนย์ทั้งหมด (0)
• ศูนย์จริง (0.0)
• บรรทัดว่างและบรรทัด 0
• อาร์เรย์ที่ไม่มีองค์ประกอบ
• วัตถุที่ไม่มีตัวแปร (วัตถุจะกล่าวถึงรายละเอียดในการบรรยายเรื่องใดเรื่องหนึ่งต่อไปนี้)
• ประเภทพิเศษ NULL

1. ค่าอื่นๆ ทั้งหมดจะถูกแปลงเป็น TRUE

ตัวอย่างที่ 3.1 คำสั่งแบบมีเงื่อนไข if (html, txt)
100*$bax+3) echo "บรรทัดนี้จะไม่ปรากฏบนหน้าจอเนื่องจากไม่ตรงตามเงื่อนไข"; -

ตัวดำเนินการอื่น
เราได้ดูเพียงส่วนเดียวซึ่งเป็นส่วนหลักของคำสั่ง if มีส่วนขยายหลายประการสำหรับตัวดำเนินการนี้ คำสั่ง else จะขยายออกไปหากนิพจน์ที่ถูกทดสอบ if เป็นเท็จ และอนุญาตให้คุณดำเนินการบางอย่างภายใต้เงื่อนไขดังกล่าว
โครงสร้างของคำสั่ง if ที่ขยายออกไปพร้อมกับคำสั่ง else สามารถแสดงได้ดังนี้:
ถ้า (นิพจน์)Execution_block อย่างอื่นExecution_block1
โครงสร้าง if...else สามารถตีความได้ดังนี้: หากตรงตามเงื่อนไข (เช่น นิพจน์ = true) เราจะดำเนินการจากการดำเนินการจาก allowance_block ไม่เช่นนั้นเราจะดำเนินการจากการดำเนินการจาก allowance_block1 ไม่จำเป็นต้องใช้ตัวดำเนินการ else
มาดูกันว่าเราจะเปลี่ยนแปลงตัวอย่างก่อนหน้านี้ได้อย่างไร โดยคำนึงถึงความจำเป็นในการดำเนินการแม้ว่าจะไม่ตรงตามเงื่อนไขก็ตาม

ตัวอย่างที่ 3.2 ตัวดำเนินการอื่น (html, txt)
100*$bax+3) echo "บรรทัดนี้จะไม่ปรากฏบนหน้าจอเนื่องจากไม่ตรงตามเงื่อนไข";

อย่างอื่นก้อง "แต่บรรทัดนี้จะปรากฏขึ้น!"; -
ตัวดำเนินการอื่น
อีกวิธีหนึ่งในการขยายคำสั่ง if แบบมีเงื่อนไขคือการใช้คำสั่ง elseif elseif คือการรวมกันของ else และ if เช่นเดียวกับอย่างอื่น มันจะขยายออกไปหากจะดำเนินการต่างๆ หากเงื่อนไขที่ถูกทดสอบหากเป็นเท็จ แต่ไม่เหมือนกับอย่างอื่น การดำเนินการทางเลือกจะถูกดำเนินการก็ต่อเมื่อเงื่อนไขelseifเป็นจริงเท่านั้น โครงสร้างของคำสั่ง if ซึ่งขยายไปพร้อมกับคำสั่ง else และ elseif สามารถแสดงได้ดังนี้:
ถ้า (นิพจน์)Execution_block elseif (expression1)Execution_block1 ... อย่างอื่นExecution_blockN

อาจมีคำสั่ง elseif หลายคำสั่งในหนึ่งคำสั่ง if block คำสั่ง Elseif จะถูกดำเนินการก็ต่อเมื่อเงื่อนไข if ก่อนหน้าเป็นเท็จ เงื่อนไข elseif ก่อนหน้าทั้งหมดเป็นเท็จ และเงื่อนไข elseif ที่กำหนดเป็น True
ไวยากรณ์ทางเลือก
PHP นำเสนอไวยากรณ์ทางเลือกสำหรับโครงสร้างการควบคุมบางส่วน เช่น if, while, for, foreach และ switch ในแต่ละกรณี วงเล็บเปิดจะต้องแทนที่ด้วยเครื่องหมายทวิภาค (:) และวงเล็บปิดด้วย endif;, end While; ฯลฯ ตามลำดับ
ตัวอย่างเช่น ไวยากรณ์ของคำสั่ง if สามารถเขียนได้ดังนี้:
ถ้า (การแสดงออก): การดำเนินการ_บล็อก endif;

ความหมายยังคงเหมือนเดิม: หากเงื่อนไขที่เขียนในวงเล็บของคำสั่ง if กลายเป็นจริง โค้ดทั้งหมดจะถูกดำเนินการ ตั้งแต่เครื่องหมายทวิภาค ">:" ไปจนถึงคำสั่ง endif การใช้ไวยากรณ์นี้มีประโยชน์เมื่อฝัง php ลงในโค้ด html
ตัวอย่างที่ 3.4 การใช้ไวยากรณ์ทางเลือก (html, txt)
สวัสดี Vanya!

หากใช้โครงสร้าง else และ elseif ก็สามารถใช้ไวยากรณ์ทางเลือกได้:
โครงสร้างอื่นที่ช่วยให้คุณสามารถตรวจสอบเงื่อนไขและดำเนินการต่าง ๆ ขึ้นอยู่กับสวิตช์ ชื่อของโอเปอเรเตอร์นี้สามารถแปลเป็นภาษารัสเซียว่า "สวิตช์" และนั่นคือความหมายของมันจริงๆ ตัวแปรจะสลับระหว่างบล็อกการดำเนินการต่างๆ ขึ้นอยู่กับค่าของตัวแปร switch คล้ายกับคำสั่ง if...elseif...else หรือชุดคำสั่ง if มาก โครงสร้างสวิตช์สามารถเขียนได้ดังนี้:
สวิตช์ (นิพจน์หรือตัวแปร) ( case value1: action_block1 break; case value2: action_block2 break; ... default: default_action_block)
ต่างจากถ้าค่าของนิพจน์ไม่ได้แปลงเป็นประเภทบูลีน แต่เพียงเปรียบเทียบกับค่าที่แสดงอยู่หลังคีย์เวิร์ด case (value1, value2 ฯลฯ ) หากค่าของนิพจน์ตรงกับตัวเลือกใด ๆ บล็อกการดำเนินการที่เกี่ยวข้องจะถูกดำเนินการ - จากโคลอนหลังค่าที่ตรงกันไปจนถึงจุดสิ้นสุดของสวิตช์หรือไปยังคำสั่งแบ่งแรกหากพบ หากค่าของนิพจน์ไม่ตรงกับตัวเลือกใด ๆ การดำเนินการเริ่มต้น (default_action_block) ที่อยู่หลังคำหลักเริ่มต้นจะถูกดำเนินการ นิพจน์ในสวิตช์จะได้รับการประเมินเพียงครั้งเดียว แต่นิพจน์ในคำสั่ง elseif จะได้รับการประเมินทุกครั้ง ดังนั้นหากนิพจน์ค่อนข้างซับซ้อน สวิตช์ก็จะเร็วขึ้น

ตัวอย่าง 3.3 สามารถเขียนใหม่ได้โดยใช้สวิตช์ดังนี้

หากในตัวอย่างนี้เราละเว้นคำสั่งแบ่ง เช่น ในกรณี “Peter”: ถ้าตัวแปรเท่ากับสตริง “Peter” หลังจากแสดงข้อความ “Hello, Petya!” โปรแกรมจะไปต่อและแสดงข้อความ “Hello, Senya!” และเมื่อถึงจุดแตกหักแล้ว จะดำเนินการต่อไปนอกสวิตช์หรือไม่
สำหรับโครงสร้างสวิตช์ เหมือนกับว่า ไวยากรณ์ทางเลือกเป็นไปได้ โดยที่เครื่องหมายปีกกาเปิดของสวิตช์ถูกแทนที่ด้วยโคลอน และเครื่องหมายปีกกาปิดจะถูกแทนที่ด้วยเอ็นด์สวิตช์ ตามลำดับ

ตัวดำเนินการวนซ้ำ: สำหรับ, ในขณะที่, foreach, ตัวเลือกไวยากรณ์

สำหรับ
For loops เป็นลูป PHP ที่ซับซ้อนที่สุด พวกเขาประพฤติตนเหมือนกับคู่หู C ของพวกเขา
ไวยากรณ์ของ for loop คือ: for (expr1; expr2; expr3) คำสั่ง
นิพจน์แรก (expr1) ได้รับการประเมิน (ดำเนินการ) หนึ่งครั้งและไม่มีเงื่อนไขที่จุดเริ่มต้นของลูป
เมื่อเริ่มต้นการวนซ้ำแต่ละครั้ง จะมีการคำนวณ expr2 หากประเมินเป็น TRUE การวนซ้ำจะดำเนินต่อไปและคำสั่งที่ซ้อนกันจะถูกดำเนินการ หากประเมินเป็น FALSE การวนซ้ำจะสิ้นสุดลง
เมื่อสิ้นสุดการวนซ้ำแต่ละครั้ง จะมีการคำนวณ expr3 (ดำเนินการ)
แต่ละนิพจน์สามารถเว้นว่างได้ expr2 ที่ว่างเปล่าหมายความว่าลูปควรทำงานอย่างไม่มีกำหนด (PHP สันนิษฐานโดยปริยายว่าเงื่อนไขนี้เป็น TRUE เช่นเดียวกับใน C) สิ่งนี้อาจไม่ไร้จุดหมายอย่างที่คิด เนื่องจากบ่อยครั้งจำเป็นต้องจบลูปด้วยคำสั่ง break แทนที่จะใช้การทดสอบนิพจน์แบบมีเงื่อนไข for loop
ลองพิจารณาตัวอย่างต่อไปนี้ พวกเขาทั้งหมดเอาท์พุทตัวเลขตั้งแต่ 1 ถึง 10:
/* ตัวอย่างที่ 1 */ สำหรับ ($i = 1; $i<= 10; $i++) { print $i; } /* пример 2 */ for ($i = 1;;$i++) { if ($i >10) ( แบ่ง; ) พิมพ์ $i; ) /* ตัวอย่าง 3 */ $i = 1; สำหรับ (;;) ( if ($i > 10) ( break; ) พิมพ์ $i; $i++; ) /* ตัวอย่าง 4 */ for ($i = 1; $i<= 10; print $i, $i++);
แน่นอนว่าตัวอย่างแรกดูเหมือนจะน่าดึงดูดที่สุด (หรือบางทีอาจเป็นตัวอย่างที่สี่) แต่คุณอาจพบว่าความสามารถในการใช้นิพจน์ว่างใน for loops นั้นมีประโยชน์ในหลาย ๆ สถานการณ์
PHP ยังรองรับ "ไวยากรณ์โคลอน" สำหรับ for loops
สำหรับ (expr1; expr2; expr3): คำสั่ง; - สิ้นสุด;

ในขณะที่
ในขณะที่วนซ้ำนี่เป็นลูป PHP ที่ง่ายที่สุด พวกเขาประพฤติตนเหมือนคู่หู C ของพวกเขา
นี่คือรูปแบบพื้นฐานของคำสั่ง while: while (expr) คำสั่ง
ค่าของตัวดำเนินการ while คือ 3 (สาม) รูเบิล มันบอกให้ PHP ดำเนินการคำสั่งที่ซ้อนกันซ้ำ ๆ ในขณะที่ expr ประเมินค่าเป็น TRUE ค่าของนิพจน์จะถูกตรวจสอบแต่ละครั้งที่จุดเริ่มต้นของลูป ดังนั้นหากค่านั้นเปลี่ยนแปลงในขณะที่ดำเนินการคำสั่งที่ซ้อนกัน การดำเนินการจะไม่หยุดจนกว่าจะสิ้นสุดการวนซ้ำนั้น (แต่ละครั้งที่ PHP ดำเนินการคำสั่งทั้งหมดใน การวนซ้ำเรียกว่าการวนซ้ำหนึ่งครั้ง) บางครั้ง ถ้า expr ประเมินเป็น FALSE ที่จุดเริ่มต้นของลูป คำสั่งที่ซ้อนกันอาจไม่สามารถดำเนินการได้แม้แต่ครั้งเดียว
เช่นเดียวกับคำสั่ง if คุณสามารถสร้างกลุ่มของคำสั่งภายในลูป while โดยใช้เครื่องหมายปีกกา () หรือใช้ไวยากรณ์ทางเลือก: while (expr): คำสั่ง ... end While;
ตัวอย่างต่อไปนี้เหมือนกันและพิมพ์ตัวเลขตั้งแต่ 1 ถึง 10 ทั้งคู่:
/* ตัวอย่าง 1 */ $i = 1; ในขณะที่ ($i<= 10) { print $i++; /* будет печататься значение $i до инкремента (пост-инкремент) */ } /* пример 2 */ $i = 1; while ($i <= 10): print $i; $i++; endwhile;

ทำ..ในขณะที่
Do.. While loop นั้นคล้ายคลึงกับ while loop มาก แต่นิพจน์เงื่อนไขจะถูกทดสอบเมื่อสิ้นสุดการวนซ้ำแต่ละครั้ง แทนที่จะทดสอบที่จุดเริ่มต้น ข้อแตกต่างที่สำคัญจาก while แบบปกติก็คือ การวนซ้ำครั้งแรกของ do.. While loop จะถูกดำเนินการเสมอ (เงื่อนไขจะถูกตรวจสอบเมื่อสิ้นสุดการวนซ้ำเท่านั้น) ในขณะที่การวนซ้ำ while อาจไม่เป็นเช่นนั้น (เงื่อนไข จะถูกตรวจสอบที่จุดเริ่มต้นของการวนซ้ำแต่ละครั้ง และหากประเมินเป็น FALSE ทันทีที่จุดเริ่มต้น การดำเนินการของลูปจะถูกขัดจังหวะทันที)
มีตัวเลือกไวยากรณ์หนึ่งตัวเลือกสำหรับ do.. While ลูป:
$i = 0; ทำ (พิมพ์ $i; ) ในขณะที่ ($i>0);
การวนซ้ำด้านบนจะถูกสำรวจเพียงครั้งเดียว เนื่องจากหลังจากผ่านครั้งแรก การทดสอบนิพจน์แบบมีเงื่อนไขจะส่งกลับค่า FALSE ($i ไม่เกิน 0) และการวนซ้ำจะสิ้นสุดลง
ผู้ใช้ C ขั้นสูงอาจคุ้นเคยกับการใช้ do.. While loop ในลักษณะอื่น ซึ่งช่วยให้การดำเนินการหยุดกลางบล็อกของโค้ดโดยการห่อหุ้มไว้ใน do.. While(0) และใช้คำสั่งแบ่ง ตัวอย่างต่อไปนี้แสดงให้เห็นสิ่งนี้:
ทำ ( ถ้า ($i< 5) { print "i is not big enough"; break; } $i *= $factor; if ($i < $minimum_limit) { break; } print "i is ok"; ...обработка i... } while(0);
ไม่ต้องกังวลหากคุณเข้าใจเพียงเล็กน้อยหรือไม่เข้าใจเลย คุณสามารถเขียนโค้ดสคริปต์และแม้แต่แอปพลิเคชันที่มีคุณสมบัติครบถ้วนได้โดยไม่ต้องใช้ "คุณสมบัติ" นี้

foreach
PHP 4 (ไม่ใช่ PHP 3) มีโครงสร้าง foreach ที่ชวนให้นึกถึง Perl และภาษาอื่นๆ มันมีวิธีง่ายๆ ในการวนซ้ำผ่านอาร์เรย์ ไวยากรณ์มีสองประเภท: ประเภทที่สองเป็นส่วนขยายของประเภทแรกและใช้บ่อยน้อยกว่า:
คำสั่ง foreach(array_expression as $value)
คำสั่ง foreach(array_expression as $key => $value)
ชนิดแรกวนซ้ำผ่านอาร์เรย์ที่ระบุโดย array_expression ในการผ่านแต่ละครั้ง ค่าขององค์ประกอบปัจจุบันจะถูกกำหนดให้กับตัวแปร $value และตัวชี้อาร์เรย์ภายในจะเลื่อนไปข้างหน้าหนึ่งตัว (ดังนั้นในการผ่านครั้งถัดไป คุณจะดูค่าขององค์ประกอบถัดไป)
ประเภทที่สองทำสิ่งเดียวกัน แต่คีย์ขององค์ประกอบปัจจุบันถูกกำหนดให้กับตัวแปร $key
หมายเหตุ: เมื่อเริ่มต้น foreach ตัวชี้อาร์เรย์ภายในจะถูกตั้งค่าเป็นองค์ประกอบแรกของอาร์เรย์โดยอัตโนมัติ ซึ่งหมายความว่าคุณไม่จำเป็นต้องโทรไปรีเซ็ต() ก่อนที่จะเริ่ม foreach loop
หมายเหตุ: โปรดทราบด้วยว่า foreach ดำเนินการกับสำเนาของอาร์เรย์ที่ระบุ ไม่ใช่บนอาร์เรย์เอง ดังนั้นตัวชี้อาร์เรย์จึงไม่ได้รับการแก้ไขเหมือนกับแต่ละ () และการเปลี่ยนแปลงองค์ประกอบอาร์เรย์ที่ส่งคืนจะไม่ส่งผลต่ออาร์เรย์ดั้งเดิม
หมายเหตุ: foreach ไม่รองรับความสามารถในการระงับข้อความแสดงข้อผิดพลาดโดยใช้ "@"
โปรดทราบว่าตัวเลือกต่อไปนี้มีฟังก์ชันการทำงานเหมือนกัน:
รีเซ็ต($arr); ในขณะที่ (list(, $value) = แต่ละ ($arr)) ( echo "Value: $value
\n"; ) foreach ($arr เป็น $value) ( ​​​​echo "Value: $value
\n"; )
ตัวเลือกต่อไปนี้มีฟังก์ชันการทำงานเหมือนกัน:
รีเซ็ต($arr); ในขณะที่ (list($key, $value) = แต่ละ ($arr)) ( echo "Key: $key; Value: $value
\n"; ) foreach ($arr as $key => $value) ( ​​​​echo "Key: $key; Value: $value
\n"; )
ตัวอย่างการใช้งานเพิ่มเติม:
/* ตัวอย่างที่ 1: เฉพาะค่า */ $a = array (1, 2, 3, 17); foreach ($a as $v) ( print "มูลค่าปัจจุบันของ \$a: $v.\n"; ) /* foreach ตัวอย่างที่ 2: value (พร้อมคีย์ที่พิมพ์ไว้เพื่อแสดงภาพประกอบ) */ $a = array (1, 2 , 3, 17); $i = 0; /* สำหรับภาพประกอบเท่านั้น */ foreach($a as $v) ( print "\$a[$i] => $v.\n"; $i++; ) /* foreach ตัวอย่างที่ 3: key\key และ value\ ค่า */ $a = array ("หนึ่ง" => 1, "สอง" => 2, "สาม" => 3, "สิบเจ็ด" => 17); foreach($a as $k => $v) ( print "\$a[$k] => $v.\n"; )

หยุดพัก
break สิ้นสุดการดำเนินการของโครงสร้างปัจจุบัน (วนซ้ำ) สำหรับ, foreach, while, do.. While หรือ switch
break รับอาร์กิวเมนต์ตัวเลขที่เป็นตัวเลือกซึ่งระบุจำนวนโครงสร้างการซ้อนที่มีการทำลายการดำเนินการ
$arr = array("หนึ่ง", "สอง", "สาม", "สี่", "หยุด", "ห้า"); ในขณะที่ (list (, $val) = แต่ละ ($arr)) ( if ($val == "stop") ( break; /* คุณยังสามารถเขียน "break 1;" */ ) echo "$val
\n"; ) /* ใช้อาร์กิวเมนต์เผื่อเลือก */ $i = 0; while (++$i) ( switch ($i) ( case 5: echo "At 5)
\n"; break 1; /* Exit switch only. */ case 10: echo "At 10; เลิก
\n"; break 2; /* Exit switch และ while. */ default: break; ) )

ดำเนินการต่อ
Continue ใช้ในโครงสร้างลูปเพื่อข้ามส่วนที่เหลือของการวนซ้ำปัจจุบันของลูป และดำเนินการดำเนินการต่อจากจุดเริ่มต้นของการวนซ้ำครั้งถัดไป (ผ่าน) ของลูป
ดำเนินการต่อ รับอาร์กิวเมนต์ตัวเลขซึ่งเป็นทางเลือกซึ่งระบุจำนวนลูปที่มีระดับต่างๆ ที่จะข้ามไปยังจุดสิ้นสุด
ในขณะที่ (list ($key, $value) = แต่ละ ($arr)) ( if (!($key % 2)) ( // ข้ามสมาชิกคี่ ดำเนินการต่อ; ) do_something_odd ($value); ) $i = 0; ในขณะที่ ($i++< 5) { echo "Outer
\n"; ในขณะที่ (1) ( echo "& & Middle
\n"; ในขณะที่ (1) ( echo "& & Inner
\n"; Continue 3; ) echo "สิ่งนี้ไม่เคยได้รับเอาต์พุต
\n"; ) echo "ก็ไม่ทำเช่นนี้
\n"; )

รวมโค้ดจากไฟล์: ทำไมคุณต้องรวมโค้ดจากไฟล์, ไฟล์อะไรที่สามารถรวมได้, รวมโอเปอเรเตอร์ต้องการ, รวม, ป้องกันการซ้ำกัน (include_once, need_once)

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

ไฟล์ที่จะรวม
เริ่มต้นด้วยการสร้างไฟล์ที่จะใช้ในคำสั่งรวมในภายหลัง ไม่ว่าเว็บเพจของคุณจะมีหน้าตาเป็นอย่างไร ควรมีส่วนหัวและส่วนท้ายที่มีองค์ประกอบการนำทาง เราจะวางส่วนหัวไว้ในไฟล์แยกต่างหาก จากนั้นรวมไว้ในหน้าจำนวนมาก ซึ่งทั้งหมดจะมีลักษณะเหมือนกัน หากเราต้องการเปลี่ยนแปลงรูปลักษณ์ของเพจของเรา เราจะต้องทำเพียงครั้งเดียวเท่านั้น
ขั้นแรก เรามาสร้างไฟล์ชื่อ top.txt และใส่ข้อความต่อไปนี้ลงไป:

รวมตัวดำเนินการ
ตอนนี้เรามารวมไฟล์ที่เราสร้างไว้ในหน้าการลงทะเบียนกันดีกว่า ทำการเปลี่ยนแปลงต่อไปนี้กับไฟล์ register.php:

ลงทะเบียนสำหรับบัญชี:

ต้องมีคำสั่งรวม
หาก PHP ไม่พบไฟล์ส่วนหัวหรือส่วนท้าย ถือว่าแย่ แต่ก็ไม่ร้ายแรง แอปพลิเคชันจะยังคงใช้งานได้ หากไฟล์ที่ระบุในคำสั่ง include หายไป PHP จะออกคำเตือนและดำเนินการประมวลผลเพจต่อ
อย่างไรก็ตาม ในบางกรณี การไม่มีไฟล์รวมถือเป็นหายนะ ตัวอย่างเช่น เราอาจตัดสินใจว่าการวางฟังก์ชัน validate() และ db_connect() ไว้ในไฟล์แยกต่างหากจะเป็นประโยชน์ จากนั้นจึงรวมไฟล์นั้นไว้ใน register_action.php โดยใช้คำสั่ง include หาก PHP ไม่พบไฟล์ฟังก์ชันแต่ไม่หยุดทำงาน ก็จะเกิดปัญหามากมายตามมา เพื่อป้องกันสถานการณ์นี้ คุณควรใช้คำสั่ง need แทนการรวม:

คุณป้อน:

".$คีย์" = " . $มูลค่า . "

ขอบคุณสำหรับการลงทะเบียน!

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

คุณป้อน:

".$คีย์" = " . $มูลค่า . "