ไวยากรณ์ PHP ออนไลน์ บทเรียนแรกใน PHP: คุณลักษณะทางไวยากรณ์ เอาต์พุตข้อมูล ตัวแปร การทำงานกับข้อผิดพลาด ขอบเขตตัวแปร

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

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

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


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

โปรดทราบว่าไม่มีความคล้ายคลึงกับสคริปต์ CGI ไฟล์ไม่จำเป็นต้องสามารถเรียกใช้งานได้หรือทำเครื่องหมายเป็นอย่างอื่น มันเป็นเพียงไฟล์ HTML ธรรมดาที่มีแท็กพิเศษมากมายซึ่งทำหน้าที่เจ๋งๆ มากมาย
โปรแกรมนี้เรียบง่ายมาก และคุณไม่จำเป็นต้องใช้ PHP เพื่อสร้างเพจง่ายๆ เช่นนี้ด้วยซ้ำ สิ่งเดียวที่ทำคือพิมพ์ว่า “Hello! โดยใช้ ฟังก์ชั่น PHPเสียงสะท้อน()
หากตัวอย่างนี้ไม่แสดงอะไรเลยหรือแสดงหน้าต่างดาวน์โหลด หรือหากคุณเห็นไฟล์ทั้งหมดนี้ในรูปแบบข้อความ เป็นไปได้มากว่าเว็บเซิร์ฟเวอร์ของคุณไม่รองรับ 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 ; ?>
การแปลงสตริง
ค่าถูกกำหนดโดยจุดเริ่มต้นของสตริง หากสตริงขึ้นต้นด้วยข้อมูลตัวเลขที่ถูกต้อง oi จะถูกนำมาใช้เป็นค่า มิฉะนั้นค่าจะเป็น 0 (ศูนย์) ข้อมูลตัวเลขที่ถูกต้องคือเครื่องหมายทางเลือกที่ตามด้วยตัวเลขหนึ่งหลักขึ้นไป (อาจมีจุดทศนิยม) ตามด้วยเลขชี้กำลังทางเลือก เลขชี้กำลังคือ "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 และต้องใช้ตัวดำเนินการด้านล่าง คุณสามารถดูตัวอย่างการใช้งานได้:

คุณป้อน:

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

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

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

บล็อก PHP

สิ่งแรกที่คุณควรรู้คือโค้ด PHP ควรอยู่ในแท็ก PHP เสมอ:

คุณยังสามารถใช้:

อันดับแรกแต่ละคำสั่ง (นิพจน์) จะต้องลงท้ายด้วยเครื่องหมายอัฒภาค ตัวอย่างเช่น:

//บอก PHP ให้แสดงข้อผิดพลาดทั้งหมดที่เกี่ยวข้องให้เราทราบ header("ประเภทเนื้อหา: text/html; charset=utf-8"); // การเข้ารหัส echo "สคริปต์ PHP แรกของเราใช้งานได้!
"; //ส่งออกข้อความไปยังเพจ ?>

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

"; ?>

ที่สามคำสั่ง PHP สามารถแบ่งออกเป็นหลายบรรทัด:

"; ?>

ผลลัพธ์:

เราสังเกตเห็นว่าเบราว์เซอร์ตีความแต่ละบรรทัดใหม่เป็นพื้นที่ปกติ ซึ่งเป็นสิ่งที่เราคาดหวัง

ที่สี่, PHP ก็เหมือนกับภาษาโปรแกรมอื่นๆ ที่มีการแสดงความคิดเห็น PHP มี 2 ประเภท: บรรทัดเดียวและหลายบรรทัด

มีความเห็นว่าสำหรับโปรแกรมเมอร์ที่ดี ความคิดเห็นควรประกอบด้วย 30% ของโค้ดทั้งหมด อย่างไรก็ตาม ความคิดเห็นที่ซ้ำซ้อนก็ไม่จำเป็นอย่างยิ่งเช่นกัน คุณไม่ควรแสดงความคิดเห็นเช่น "ฉันมองออกไปนอกหน้าต่างและเกาจมูก"

การส่งออกข้อมูลใน PHP

เอาต์พุตข้อมูลในภาษาการเขียนโปรแกรม PHP ดำเนินการโดยใช้โครงสร้างภาษาหลักสองภาษา:

"; พิมพ์ "นี่คือข้อความเดียวกันทุกประการ"; ?>

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

", "สคริปต์ PHP แรกของเราใช้งานได้!", "";
//เช่นกัน แต่ใช้การพิมพ์:พิมพ์ "

"; print "สคริปต์ PHP แรกของเราใช้งานได้!"; print "

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

อย่างไรก็ตามสิ่งเดียวกันสามารถเขียนได้ดังนี้:

นี่คือสิ่งที่ฉันหมายถึงในบทความก่อนหน้านี้เมื่อฉันพูดถึงเรื่องนั้น

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

ตัวแปรใน PHP เริ่มต้นในเชิงสัญลักษณ์ โดยมีเครื่องหมายดอลลาร์ $ ตามด้วยตัวอักษรละตินหรือขีดล่างโดยไม่มีการเว้นวรรค (ตัวเลขไม่สามารถเป็นอักขระตัวแรกในชื่อตัวแปรได้) นอกจากนี้ ชื่อตัวแปรอาจมีทั้งตัวอักษรละตินและตัวเลข และมีอักขระขีดล่างเหมือนกัน ตัวอย่างเช่น:

$name="เซอร์เกย์"; $_blog1="ไซต์บน!";
echo $name, " - ผู้เขียนบล็อก", $_blog1; -

ผลลัพธ์:

ชื่อตัวแปรต้องคำนึงถึงขนาดตัวพิมพ์! นั่นคือ $Name, $naMe, $name เป็นตัวแปรสามตัวที่แตกต่างกันโดยสิ้นเชิง หากเราต้องการใส่สิ่งใหม่ลงในตัวแปรที่มีอยู่ ค่าเก่าของตัวแปรนี้จะถูกลบโดยอัตโนมัติ:

$name="เซอร์เกย์"; $_blog1="ไซต์บน!"; $name="อันเดรย์"; //เขียนค่าใหม่ให้กับตัวแปรชื่อ
echo $name, " - ผู้เขียนบล็อก", $_blog1; -

ผลลัพธ์:

โดยปกติแล้ว เราสามารถส่งผ่านค่าของตัวแปรหนึ่งไปยังอีกตัวแปรหนึ่งได้:

$name = "เซอร์เกย์"; $_blog1 = "ไซต์บน!"; $ชื่อ = $_blog1;
echo $name, " - ผู้เขียนบล็อก", $_blog1; -

ผลลัพธ์:

อย่างไรก็ตาม ค่าของตัวแปร $_blog1 จะยังคงอยู่ในนั้น

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

$ชื่อ = 45;

เหมือนกับการใส่ตัวแปรเข้าไปในตัวแปร:

$ชื่อ = $_blog1;

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

$name="เซอร์เกย์"; $_blog1="ไซต์บน!"; $name=$_blog1; ไม่ได้ตั้งค่า($ชื่อ); //ลบตัวแปรชื่อออก
echo $name, " - ผู้เขียนบล็อก", $_blog1; -

ผลลัพธ์:

การจัดการกับข้อผิดพลาดใน PHP

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

PHP ยังพยายามบอกเราว่าเราทำผิดพลาดที่ไหนและอย่างไร ในกรณีของเราเขาเขียนว่า:

ตัวแปรที่ไม่ได้กำหนด: ชื่อ

ซึ่งแปลว่า “ตัวแปรที่ไม่ได้กำหนด: ชื่อ” จากนั้นจึงแสดงไฟล์และบรรทัดที่เกิดเหตุการณ์ทั้งหมดนี้ให้เราดู:

ใน Z:\home\localhost\www\blog2\second-page.php ออนไลน์ 10

นั่นคือในไฟล์ Second-page.phpบน บรรทัดที่ 10- ในกรณีนี้ PHP ทำถูกต้อง แต่บ่อยครั้งที่ข้อผิดพลาดนั้นสูงกว่าหนึ่งบรรทัดขึ้นไป เช่น เมื่อเราลืมใส่เครื่องหมายอัฒภาคที่ส่วนท้ายของคำสั่งถัดไป:

$name="เซอร์เกย์"; $_blog1="ไซต์บน!" //อุ๊ย ลืม :(
echo $name, " - ผู้เขียนบล็อก", $_blog1; -

ผลลัพธ์:

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

PHP บอกเราว่าข้อผิดพลาดอยู่ที่บรรทัดที่ 8 แต่จริงๆ แล้วฉันลืมใส่เครื่องหมายอัฒภาค 2 บรรทัดด้านบน:

ฉันดึงความสนใจของคุณไปที่ความจริงที่ว่าเมื่อคุณเห็น "ข้อผิดพลาดทางไวยากรณ์ ไม่คาดคิด"จากนั้นในกรณี 99% หมายความว่าคุณลืมใส่อัฒภาค

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

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

» ไวยากรณ์ภาษา PHP

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

ตามที่กล่าวไว้ในบทที่ 1 สคริปต์ PHP เป็นข้อความที่ง่ายที่สุด และนั่นคือเหตุผลว่าทำไมเมื่อคุณสร้างมันขึ้นมา คุณสามารถใช้โปรแกรมแก้ไขข้อความธรรมดาได้ (เช่น Windows Notepad) เราจะไม่เลื่อนเรื่องนี้ออกไปนานเกินไปและจะเริ่มเขียนโปรแกรม ตามประเพณีผลงานจะเป็นข้อความ "Hello, World!" ในหน้าต่างเบราว์เซอร์ของคุณ คุณต้องเปิดตัวแก้ไขข้อความ ป้อนบรรทัดจากรายการ 3.1 ที่นั่น และบันทึกไฟล์นี้ด้วยนามสกุล .php (เช่น hello.php) วางไฟล์ไว้ในไดเรกทอรีรากของเว็บเซิร์ฟเวอร์ของคุณ (ในกรณีของเราคือ C:\Home_server\Apache2\htdocs\) และป้อน http://localhost/hello.php ในบรรทัดเบราว์เซอร์ ก่อนที่จะกดปุ่ม Enter ตรวจสอบให้แน่ใจว่าได้โหลดกระบวนการ Apache อีกครั้ง ซึ่งได้รับการยืนยันโดยไอคอน Apache Server Monitor ซึ่งยูทิลิตี้อยู่ที่มุมด้านล่างทางด้านขวาของจอภาพ

รายการ 3.1. โปรแกรมนี้จะแสดงข้อความ

‹?php
สะท้อน "สวัสดีชาวโลก!";
?›

ผลลัพธ์ของโปรแกรมดังรูป

ตอนนี้เรามาดูรายละเอียดของโปรแกรมนี้กันดีกว่า คุณต้องใส่ใจกับโครงสร้าง ‹?php ... ?› ซึ่งคล้ายกับแท็ก HTML มาก ใช้ในการแยกโค้ด PHP คำว่า echo ใช้ในการพิมพ์สตริง โดยจะอยู่ในเครื่องหมายคำพูดหลังจากนั้น (เราจะดูคำสั่งนี้ในภายหลัง) อัฒภาค (;) ทำสิ่งเดียวกับมหัพภาคท้ายประโยค

คุณต้องเลือกจากเมนูเบราว์เซอร์ (ในกรณีของเราคือ Internet Explorer) ดูย่อหน้า เป็น HTML- และเนื้อหาจะถูกเปิดเผยให้คุณเห็นทุกอย่างที่อยู่ในเพจด้วยโปรแกรมแก้ไขข้อความ โปรดทราบว่าเว็บเซิร์ฟเวอร์ส่งเฉพาะบรรทัด "Hello, World!" ไปยังเบราว์เซอร์ และนี่คือจุดเด่นหลักของการเขียนโปรแกรมเซิร์ฟเวอร์ เพราะเมื่อมีการเรียกไฟล์ HTML ไฟล์เหล่านั้นจะถูกส่งไปโดยไม่มีการเปลี่ยนแปลง ในกรณีนี้ โค้ด PHP จะถูกดำเนินการก่อน จากนั้นผลลัพธ์จะถูกส่งไปยังเบราว์เซอร์

อีกสิ่งหนึ่งที่เกี่ยวกับ ไวยากรณ์ภาษา PHPคุณไม่ควรลืมว่าถ้าโค้ดไม่ได้อยู่ในชุดแท็กพิเศษ ‹?php...?› โค้ดจะถูกส่งโดยไม่ต้องประมวลผล PHP (ดูรูปและรายการด้านล่าง)

รายการ 3.2. โปรแกรมที่ไม่ใช้แท็ก PHP

‹html›
<ศีรษะ>
‹title›ข้อความนอกแท็ก PHP‹/title›

<ร่างกาย>
echo "นี่ไม่ใช่โค้ด PHP";
‹br›
‹?php
สะท้อน "สวัสดีชาวโลก!";
?›
‹br›
echo "นี่ไม่ใช่โค้ด PHP";

ดูภาพสำหรับผลลัพธ์ของงานนี้ 3.2. และโปรดทราบว่าในกรณีของเรา คำสั่ง echo จะไม่ทำงานในบรรทัดแรกและบรรทัดสุดท้าย แต่จะแสดงเป็นข้อความธรรมดา สถานการณ์นี้มักใช้บ่อยมากในทางปฏิบัติเพื่อแสดงข้อความขนาดใหญ่ (คุณจะได้เรียนรู้รายละเอียดเพิ่มเติมในบทนี้)

กลับไปดูโครงสร้างที่เฟรมโค้ด PHP กัน นอกจากแท็กที่รู้จักกันดี ‹?php...?› ยังมีอีกสามประเภท:

• ‹?...?›
• ‹%...%›
• ‹ภาษาสคริปต์ = "php"›...‹/script›

เมื่อคุณเลือกการออกแบบประเภทใดประเภทหนึ่ง คุณต้องแน่ใจว่าการตั้งค่า PHP อนุญาตให้คุณใช้งานได้ ตัวอย่างเช่น แท็กขนาดเล็ก ‹?...?› จะไม่เปิดใช้งานตามค่าเริ่มต้นเสมอไป (ดูค่าของพารามิเตอร์ short_ open_tag และไฟล์การกำหนดค่า php.ini) ซึ่งเป็นเหตุผลว่าทำไมจึงไม่แนะนำให้ใช้ โครงสร้าง ‹script language="php"›...‹/script› ก็เหมือนกับ ‹?php...?› มีให้บริการเสมอ แต่เนื่องจากลักษณะที่ยุ่งยาก จึงไม่ค่อยได้ใช้ แท็ก ‹%...%› ถูกใช้ใน PHP เวอร์ชัน 4.0.3 การดำเนินการขึ้นอยู่กับพารามิเตอร์ asp_tags ในบทช่วยสอนของเรา เรามักจะติดแท็กในรูปแบบ ‹?php...?›

ฉันควรจะพูดอีกสักสองสามคำเกี่ยวกับแท็กหรือไม่>. ใน PHP ยอมรับเป็นเครื่องหมายอัฒภาค (;) ซึ่งเป็นเหตุผลว่าทำไมคุณจึงไม่จำเป็นต้องเขียนไว้ที่ท้ายบรรทัดสุดท้าย

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

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

ฟังก์ชัน function_name (พารามิเตอร์) ( เนื้อหาของฟังก์ชัน )

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

ฟังก์ชั่น mytime($h, $g) ( $t = pow(2*$h/$g, 0.5); echo "เวลาที่ตกลงมาจากที่สูง ".$h." ที่ g = ".$g. " คือ ".$t." วินาที";

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

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

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

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

ฟังก์ชั่น PHP มีและไม่มีพารามิเตอร์

ในตัวอย่างก่อนหน้าเกี่ยวกับ Free Fall Time เราดูฟังก์ชันที่มีพารามิเตอร์ ในกรณีของเรา ตัวแปรเหล่านี้คือ $h และ $g ใน PHP คุณสามารถใช้ฟังก์ชันที่ไม่มีพารามิเตอร์ได้ ในกรณีนี้ ไม่มีสิ่งใดถูกเขียนในวงเล็บหลังชื่อฟังก์ชัน ตัวอย่างของฟังก์ชันดังกล่าวจะเป็นฟังก์ชันที่แสดงโซลูชันสำเร็จรูปบางอย่าง เช่น ลิงก์หรือข้อความ

ฟังก์ชั่น mylink() ( echo "

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