ตัวแปรสามารถแสดงเป็นกล่องที่มีค่าได้

ตัวแปร - $ (เครื่องหมายดอลลาร์) หรือที่เปรียบเปรยคือชื่อที่ตั้งให้กับกล่องจินตภาพซึ่งสามารถใส่ค่าสัญลักษณ์ใดๆ ลงไปได้

ชื่อตัวแปรทั้งหมดใน PHP เริ่มต้นด้วย $ (เครื่องหมายดอลลาร์)

ตัวอย่างเช่น $testVariable = 3; (นิพจน์ต่อไปนี้จะสร้างตัวแปรชื่อ $testVariable (และกำหนดค่าให้เป็น 3

$ทดสอบตัวแปร = 3;

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

$testVariable = "สาม";

เครื่องหมายเท่ากับที่เราใช้ในสองนิพจน์สุดท้ายเรียกว่าตัวดำเนินการมอบหมาย ใช้สำหรับกำหนดค่าให้กับตัวแปร ตัวดำเนินการอื่นๆ ใช้ในการดำเนินการทางคณิตศาสตร์ต่างๆ
$ทดสอบตัวแปร =1+1; // กำหนดค่า 2
$ทดสอบตัวแปร =1-1; // กำหนดค่า 0
$ทดสอบตัวแปร = 2*2; //กำหนดค่า 4
ตัวแปรทดสอบ =2/2; // กำหนดค่า 1
จากตัวอย่างนี้ คุณอาจเดาได้ว่า + คือตัวดำเนินการบวก -- คือตัวดำเนินการลบ * คือตัวดำเนินการคูณ และ / คือตัวดำเนินการหาร ทั้งหมดเป็นตัวดำเนินการทางคณิตศาสตร์ที่ดำเนินการกับตัวเลข สามารถใช้ตัวแปรได้ทุกที่ที่ใช้ค่าสัญลักษณ์เฉพาะ ลองดูชุดนิพจน์ต่อไปนี้
$var1 = "PHP"; // กำหนดค่า "PHP" ให้กับตัวแปร $varl
$var2 = 5; // กำหนดค่า 5 ให้กับ $var2
$var3 = $var2 + 1; /// กำหนดค่า 6 ให้กับตัวแปร $var3
$var2 = $varl; // กำหนดค่า "PHP" ให้กับตัวแปร $var2
เสียงสะท้อน $var1; // จะโยน "RNR" ออกไป
เสียงสะท้อน $var2; // พิมพ์ "5"
เสียงสะท้อน $var3; // พิมพ์ "6"
เสียงสะท้อน $var1 "-ทุกอย่างของเรา!"; // แสดงว่า "PHP คือทุกสิ่งของเรา!"
echo "$var1 คือทุกสิ่งทุกอย่างของเรา!"; // แสดงว่า "PHP คือทุกสิ่งของเรา!"
echo "$var1 คือทุกสิ่งทุกอย่างของเรา!"; // แสดง "$varl คือทุกสิ่งทุกอย่างของเรา!"
ให้ความสนใจกับสองบรรทัดสุดท้าย คุณสามารถเพิ่มชื่อตัวแปรภายในข้อความและรับค่าของตัวแปรในตำแหน่งเดียวกันได้หากคุณใส่บรรทัดเข้าไป เครื่องหมายคำพูดคู่แทนที่จะเป็นคนโสด กระบวนการแปลงชื่อตัวแปรเป็นค่าเรียกว่าการแก้ไข ดังที่คุณเห็นจากตัวอย่างบรรทัดสุดท้าย มีข้อความล้อมรอบอยู่ คำพูดเดียวไม่สอดแทรกชื่อตัวแปรลงในเนื้อหา

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

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

ประเภทของตัวแปร PHP ตัวไหนรองรับ:

จำนวนเต็ม (จำนวนเต็ม)

จำนวนเต็มที่ลงนาม โดยทั่วไปจะมีความยาว 32 บิต (-2,147,483,648 ถึง 2,147,483,647 เผื่อมีใครสนใจ) double (จำนวนจริง) จำนวนจริงที่มีความแม่นยำค่อนข้างสูง (ควรจะเพียงพอสำหรับการคำนวณทางคณิตศาสตร์ส่วนใหญ่)

สตริง (สตริงข้อความ)

สตริงที่มีความยาวเท่าใดก็ได้ ต่างจาก C ตรงที่สตริงสามารถมีอักขระว่างได้ ซึ่งจะไม่ส่งผลกระทบต่อโปรแกรม แต่อย่างใด กล่าวอีกนัยหนึ่ง สตริงสามารถใช้เพื่อเก็บข้อมูลไบนารีได้ ความยาวของบรรทัดถูกจำกัดด้วยจำนวนหน่วยความจำว่างเท่านั้น ดังนั้นจึงค่อนข้างเป็นไปได้ที่จะอ่านไฟล์ "ขนาดใหญ่" ทั้งหมดที่มีขนาด 200-300 กิโลไบต์เป็นหนึ่งบรรทัด (ซึ่งมักจะทำ) สตริงสามารถประมวลผลได้อย่างง่ายดายโดยใช้ฟังก์ชันมาตรฐาน นอกจากนี้ยังยอมรับการเข้าถึงอักขระใดๆ โดยตรงได้อีกด้วย

อาร์เรย์ (อาเรย์แบบเชื่อมโยง)

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

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

ทรัพยากร

ทรัพยากรที่ PHP ปฏิบัติในลักษณะพิเศษ ทรัพยากรตัวอย่าง - ตัวแปรที่มีหมายเลขอ้างอิง เปิดไฟล์- ตัวแปรดังกล่าวสามารถนำมาใช้ในภายหลังเพื่อระบุให้ PHP ทราบว่าควรดำเนินการกับไฟล์ใด (เช่น การอ่านบรรทัด) อีกตัวอย่างหนึ่ง: ฟังก์ชัน imageCreate() ของไลบรารีกราฟิก GD จะสร้างรูปภาพ "ว่าง" ใหม่ตามขนาดที่ระบุในหน่วยความจำและส่งกลับตัวระบุ เมื่อใช้ตัวระบุนี้ คุณสามารถปรับแต่งรูปภาพได้ (เช่น วาดเส้นหรือข้อความที่แสดง) จากนั้นบันทึกผลลัพธ์เป็นไฟล์ PNG หรือ JPEG

บูลีน (ประเภทบูลีน)

มีตัวแปรประเภท "สมมุติ" อีกประเภทหนึ่ง - ตรรกะ ตัวแปรบูลีนสามารถมีค่าใดค่าหนึ่งจากสองค่า: เท็จหรือจริง โดยทั่วไปแล้ว ตัวเลขที่ไม่ใช่ศูนย์ใดๆ (และสตริงที่ไม่ว่างเปล่า) รวมถึง คำหลักจริงเป็นสัญลักษณ์ของความจริง ในขณะที่ 0 สตริงว่าง และคำว่าเท็จเป็นสัญลักษณ์ของความเท็จ ดังนั้น นิพจน์ที่ไม่ใช่ค่าว่างใดๆ (โดยเฉพาะค่าของตัวแปร) จะถือว่าเป็นจริงในบริบทเชิงตรรกะ คุณสามารถใช้ค่าคงที่ false และ true ได้ ขึ้นอยู่กับตรรกะของโปรแกรม เมื่อดำเนินการทางคณิตศาสตร์กับตัวแปรลอจิคัล ตัวแปรจะเปลี่ยนเป็นตัวแปรตัวเลขปกติ กล่าวคือ เท็จถือเป็น O และจริงเป็น 1

NULL (ค่าพิเศษ)คุณสามารถกำหนดค่าคงที่พิเศษ NULL (หรือ null ซึ่งเป็นค่าเดียวกัน) ให้กับตัวแปรเพื่อทำเครื่องหมายด้วยวิธีพิเศษ ประเภทของค่าคงที่นี้เป็นค่าพิเศษและเรียกอีกอย่างว่า NULL นี่เป็นประเภทแยกต่างหากและฟังก์ชัน gettype()

การดำเนินการกับตัวแปร

ไม่ว่าตัวแปรจะเป็นประเภทใดก็ตาม คุณสามารถดำเนินการพื้นฐานได้สามประการกับตัวแปรนั้น

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

การตรวจสอบการดำรงอยู่คุณสามารถตรวจสอบว่ามีตัวแปรที่ระบุอยู่หรือไม่ (นั่นคือ ได้ถูกเตรียมใช้งานแล้ว) ซึ่งทำได้โดยใช้ตัวดำเนินการ isset ที่สร้างไว้ใน PHP ตัวอย่างเช่น:
ถ้า (isset(SmyVar))
echo "มีตัวแปรดังกล่าวอยู่ ค่าของมันคือ SmyVar";

ถ้าตัวแปรเข้า. ในขณะนี้ไม่มีอยู่ (นั่นคือ ไม่เคยกำหนดค่าไว้ที่ใดก็ได้มาก่อน หรือถูกลบออกด้วยตนเองโดยใช้ unset จากนั้น isset o จะส่งคืน false หรือเป็นจริง สิ่งสำคัญคือต้องจำไว้ว่าเราไม่สามารถใช้ตัวแปรที่ไม่ได้เตรียมใช้งานในโปรแกรมได้ - มิฉะนั้นสิ่งนี้จะสร้างคำเตือนจากล่าม (ซึ่งส่วนใหญ่บ่งชี้ว่ามีข้อผิดพลาดเชิงตรรกะในสคริปต์) แน่นอนว่าสามารถปิดคำเตือนได้ จากนั้นตัวแปรที่ไม่ได้กำหนดค่าเริ่มต้นทั้งหมดจะถือว่าเท่ากับสตริงว่าง เราไม่แนะนำให้คุณทำเช่นนี้โดยเด็ดขาด - ควรมีการตรวจสอบเพิ่มเติมในโค้ดมากกว่าการยุ่งยากเพิ่มเติมกับการ "จับ" ข้อผิดพลาดที่อาจเกิดขึ้นในอนาคต หากคุณยังคงต้องการปิดการใช้งานคำเตือนที่โชคร้ายนี้ (และที่ ในเวลาเดียวกันกับอย่างอื่นทั้งหมด) ควรใช้ตัวดำเนินการปิดใช้งานข้อผิดพลาดและซึ่งทำหน้าที่ในเครื่อง /

การทำลาย

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

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

ชื่อตัวแปรที่ถูกต้อง:

$ ผลลัพธ์,
$ผลลัพธ์หรือ
$reSULt.
ข้อผิดพลาดเมื่อป้อนชื่อตัวแปรจากแป้นพิมพ์เป็นหนึ่งในข้อผิดพลาดที่พบบ่อยที่สุดในสคริปต์ PHP

ชื่อตัวแปรไม่ถูกต้อง เช่น:

$12_hoi.rs_AM (ตัวเลขที่จุดเริ่มต้นของชื่อตัวแปร)
$High Noon (การมีอยู่ของที่ว่าง)
$High-Noon (การใช้เครื่องหมายลบก็เป็นอักขระพิเศษใน PHP เช่นกัน)

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

ผู้ดำเนินการที่ได้รับมอบหมาย

เราจะไม่เข้าใจผิดมากนักถ้าเราบอกว่าไม่มีโปรแกรมใดในโลกที่จะไม่มีผู้ปฏิบัติงานที่ได้รับมอบหมายเพียงคนเดียว และแน่นอนว่าในโปรแกรม PHP โอเปอเรเตอร์นี้ก็อยู่ที่นั่นด้วย เราเคยเห็นแล้ว มันคือเครื่องหมายเท่ากับ (=): $ Variable_name = value;

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

ใน ชื่อพีพีตัวแปรจะเริ่มต้นด้วยเครื่องหมายดอลลาร์ ($) เสมอ ซึ่งจะต้องตามด้วยตัวอักษร หลังจากนั้นจึงใช้ตัวอักษร ตัวเลข และขีดล่างได้ ชื่อต้องคำนึงถึงขนาดตัวพิมพ์ เช่น ตัวแปร $value, $Value, $VALUE และ $VaLuE เป็นตัวแปรที่แตกต่างกันสี่ตัว แม้ว่าชื่อจะอ่านเหมือนกันก็ตาม

ตัวอย่างของชื่อตัวแปรที่ถูกต้องทางวากยสัมพันธ์:

ตัวอย่างชื่อที่ไม่ถูกต้อง:

มีสิ่งหนึ่งที่ กฎทั่วไป(สำหรับภาษาการเขียนโปรแกรมทั้งหมด) เกี่ยวกับการตั้งชื่อตัวแปร กฎนั้นง่ายมาก: ชื่อควรมีความหมายเสมอ

ตัวอย่างโค้ดที่อ่านได้ไม่ดี

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

ตัวอย่างโค้ดที่สามารถอ่านได้ง่าย

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

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

ลองดูตัวอย่าง:

การส่งผ่านตัวแปรตามค่า

มีฟังก์ชันพิเศษใน PHP สำหรับการทำงานกับตัวแปร:

• isset() - ตรวจสอบว่าตัวแปรได้รับการประกาศแล้วและค่าของมันแตกต่างจาก NULL หรือไม่
• ว่างเปล่า() - อะนาล็อกของ isset()
• unset() เป็นฟังก์ชันภาษาในตัวที่จะลบค่าของตัวแปรและลบตัวแปรออกจากรายการตัวแปรที่มีอยู่ (ทำลายตัวแปร)

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

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

บล็อกของโปรแกรมในกรณีนี้คือ "สคริปต์", "ฟังก์ชัน" หรือ "คลาส" ตัวอย่างเช่น:

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

การแก้ไขสถานการณ์นั้นง่ายมาก เพียงเพิ่มหนึ่งบรรทัด (เป็นตัวหนา):

ชื่อ $ ทั่วโลก;// ระบุอย่างชัดเจนว่าเราควรจะ // ใช้ตัวแปรโกลบอล

ใน $ชื่อเต็ม = ชื่อ $. $ครอบครัว; echo "ชื่อภายในฟังก์ชัน: ".$fullName;

) echo "ชื่อก่อนการเรียกใช้ฟังก์ชัน: ".$name;

// ผลลัพธ์: "ชื่อก่อนที่จะเรียกใช้ฟังก์ชัน: Vasya" tryChengeName("Ivanov");

// ผลลัพธ์: "ชื่อภายในฟังก์ชัน: Vasya Ivanov" echo "ชื่อหลังจากการเรียกใช้ฟังก์ชัน: ".$name;

// ผลลัพธ์: "ชื่อหลังจากเรียกใช้ฟังก์ชัน: Vasya Ivanov" ?> ในตัวอย่างนี้ตัวแปร $name มีขอบเขตเท่ากับสคริปต์ทั้งหมด และตัวแปร $fullName ที่ประกาศภายในฟังก์ชันจะมีขอบเขตเท่ากับฟังก์ชันนั้นเอง ซึ่งหมายความว่าเมื่อฟังก์ชันออกจากการทำงาน ตัวแปร $fullName จะถูกทำลาย และความพยายามในการอ่านค่าของตัวแปรจะส่งผลให้เกิดข้อผิดพลาด เราจะดูตัวอย่างการทำงานกับคลาสในส่วน "คลาสและการสืบทอด"ตัวแปรตัวแปร

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

ขอแนะนำอย่างยิ่งว่าอย่าใช้เทคนิคดังกล่าวเว้นแต่จำเป็นจริงๆ โค้ดที่อัดแน่นไปด้วยเทคนิคดังกล่าวนั้นรักษาได้ยากมาก นี่เป็นสิ่งสำคัญอย่างยิ่งเมื่อทำงานกับข้อมูลที่ผู้ใช้ป้อน เหตุผลหลักความยากลำบาก - การพึ่งพาโดยนัย ตัวอย่างเช่นจะเกิดอะไรขึ้นหากคุณเขียนอะไรบางอย่างแทนชื่อ "วาสยา" """""_;%//^q""- ขวา! ในกรณีส่วนใหญ่สคริปต์จะไม่สามารถดำเนินการได้! แน่นอนคุณสามารถเพิ่มการตรวจสอบการปรากฏตัวของอักขระ "ผิด" ได้ แต่จะง่ายกว่าที่จะไม่ใช้เทคนิคดังกล่าวเลย

ค่าคงที่

ค่าคงที่ PHP อีกประเภทหนึ่งเรียกว่า “ค่าคงที่เวทย์มนตร์” สิ่งเหล่านี้คือค่าคงที่ของระบบซึ่งค่าจะถูกกำหนดและตั้งค่าโดยล่าม มีค่าคงที่บางประการดังนี้:

• __LINE__ มีตัวเลข เส้นปัจจุบันในไฟล์ปัจจุบัน
• __FILE__ ประกอบด้วยชื่อเต็มของไฟล์ปัจจุบัน
• __FUNCTION__ ประกอบด้วยชื่อของฟังก์ชันปัจจุบัน
• __CLASS__ ประกอบด้วยชื่อของคลาสปัจจุบัน
• __วิธีการ__ ประกอบด้วยชื่อของวิธีการปัจจุบันของคลาสปัจจุบัน

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

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

เมื่อใช้ตัวแปรต้องปฏิบัติตามกฎต่อไปนี้:

• ใน PHP คุณไม่จำเป็นต้องประกาศตัวแปรก่อนใช้งาน
• ตัวแปรใน PHP จะแสดงด้วยเครื่องหมายดอลลาร์ตามด้วยชื่อตัวแปร
• ชื่อตัวแปรจะคำนึงถึงขนาดตัวพิมพ์ ซึ่งหมายความว่าชื่อตัวแปร $myVar , $MYVAR หรือ $MyVar จะถือเป็นชื่อตัวแปรที่แตกต่างกันสามชื่อ

การเริ่มต้นคือการกำหนดค่าเริ่มต้นให้กับตัวแปร คุณสามารถกำหนดค่าให้กับตัวแปรโดยใช้ตัวดำเนินการกำหนด ซึ่งแสดงด้วยสัญลักษณ์เท่ากับ (=)

$str = "string1,"; $Str = "string2"; เสียงสะท้อน $str, $Str;

ตัวแปรใน PHP ไม่มีประเภท ดังนั้นก่อนอื่นสามารถกำหนดค่าตัวแปรประเภทหนึ่งได้ จากนั้นตัวแปรเดียวกันก็สามารถกำหนดค่าประเภทอื่นได้:

$x = 10; // ก่อนอื่นให้กำหนดหมายเลข $x = "text"; //จากนั้นจึงกำหนดสตริง

เนื่องจากชื่อตัวแปรถูกแทนที่ด้วยค่า คุณสามารถคัดลอกค่าจากตัวแปรหนึ่งไปยังอีกตัวแปรหนึ่งได้:

$num1 = 10; $num2 = $num1; // เช่นเดียวกับ $num2 = 10;

ในตัวอย่างนี้ ตัวแปร $num1 ถูกกำหนดให้เป็นหมายเลข 10 จากนั้นตัวแปร $num2 จะถูกกำหนดค่าของตัวแปร $num1 แม้ว่าตัวแปร $num1 และ $num2 จะมีอยู่ก็ตาม ค่าเดียวกันแต่ละรายการมีสำเนาหมายเลข 10 ของตัวเอง ดังนั้นการเปลี่ยนค่าของหนึ่งในนั้นจะไม่ส่งผลกระทบต่ออีกรายการ:

$num2: " . $num2; // 10 $num1 = 20; echo "
$num1: " . $num1; // 20 เสียงสะท้อน "
$num2: " . $num2; // 10 ?>

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

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

// เมื่อทำงานกับสตริง $str = $str "เอบีซี"; // เช่นเดียวกับ "" . "abc" // เมื่อทำงานกับตัวเลข $num = $num + 25; // เช่นเดียวกับ 0 + 25 // โดยที่ค่าบูลีนคาดว่าจะ $num = $bool ? 1:2; // เช่นเดียวกับ FALSE? 1:2; // เมื่อทำงานกับตัวแปรในรูปแบบอาร์เรย์ $arr = "abc"; // เช่นเดียวกับ $arr = ; // เมื่อทำงานกับตัวแปรที่เป็นวัตถุ $obj->foo = "abc"; // stdClass ใหม่; $obj->foo = "เอบีซี"; // ไม่มีบริบทการใช้งาน echo gettype($x); // โมฆะ

เหตุใดจึงต้องมีตัวแปร?

ตัวแปรช่วยให้โค้ดโปรแกรมชัดเจนยิ่งขึ้น ลองดูตัวอย่างเล็กๆ น้อยๆ:

$total_price = 2.42 + 4.33; // ราคารวม

ตัวเลขที่นี่อาจหมายถึงอะไรก็ได้ เพื่อให้ชัดเจนยิ่งขึ้นว่ามีอะไรเพิ่มขึ้นที่นี่ คุณสามารถกำหนด 2.42 เป็นค่าของตัวแปร $candy_price (ราคาของลูกกวาด) และ 4.33 เป็นค่าของตัวแปร $oil_price (ราคาน้ำมัน):

$total_price = $candy_price + $oil_price;

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

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

ตัวแปร ตัวแปร

PHP มีความสามารถในการใช้ค่าของตัวแปรหนึ่งเป็นชื่อของตัวแปรอื่น ตัวแปรที่ใช้ค่าของตัวแปรเป็นชื่อจะถูกเรียก ตัวแปรตัวแปร.

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

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

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

• $variable_name = ค่า;

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

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

ตัวอย่างเล็กๆ น้อยๆ พร้อมตัวแปร

ดังนั้นการใช้ตัวแปรเข้ามา ภาษา PHPเราต้องประกาศมันก่อน (ตั้งชื่อสิ่งนี้) และให้ค่าแก่มัน ต่อไปนี้เป็นวิธีดำเนินการอย่างถูกต้อง:

หมายเหตุ: PHP ไม่จำเป็นต้องประกาศตัวแปรก่อนใช้งาน ตัวอย่างเช่น ใน Pascal เราจะต้องประกาศรายการตัวแปรทั้งหมดในส่วน var ก่อน คุณไม่ต้องการอะไรแบบนั้นใน PHP

ชื่อตัวแปรที่อนุญาต

มีกฎบางประการที่ต้องปฏิบัติตามเมื่อเลือกชื่อตัวแปร PHP ของคุณ

• ตัวแปร PHP ต้องขึ้นต้นด้วยตัวอักษรหรือขีดล่าง "_"
• ตัวแปร PHP สามารถประกอบด้วยอักขระตัวอักษรและตัวเลขและขีดล่างเท่านั้น a-z, A-Z, 0-9 หรือ _
• ตัวแปรที่มีมากกว่าหนึ่งคำสามารถคั่นด้วยขีดล่างได้ $my_variable
• ตัวแปรที่มีมากกว่าหนึ่งคำสามารถแยกตามตัวพิมพ์เล็กและใหญ่ได้ $ตัวแปรของฉัน

นั่นคือทั้งหมดที่ ตอนนี้คุณมีอันหนึ่งอยู่ในมือแล้ว เครื่องมืออันทรงพลังเหมือนตัวแปร! ก้าวไปสู่บทเรียนใหม่!

12 ปีที่แล้ว

Gotcha เล็กน้อยที่ต้องระวัง:

ถ้าคุณ ปิด RegisterGlobals และที่เกี่ยวข้อง จากนั้นใช้ get_defin_vars() คุณอาจเห็นอะไรประมาณนี้ ต่อไปนี้:

อาร์เรย์
[ GLOBALS ] => อาร์เรย์
[ GLOBALS ] => อาร์เรย์
*การเรียกซ้ำ*
[ _POST ] => อาร์เรย์()
[ _GET ] => อาร์เรย์()
[ _COOKIE ] => อาร์เรย์()
[ _FILES ] => อาร์เรย์()
)

[ _POST ] => อาร์เรย์()
[ _GET ] => อาร์เรย์()
[ _COOKIE ] => อาร์เรย์()
[ _FILES ] => อาร์เรย์()

)
?>

โปรดสังเกตว่า $_SERVER ไม่ได้อยู่ที่นั่น ดูเหมือนว่า php จะโหลด superglobal $_SERVER เท่านั้นหากมีการใช้งานที่ไหนสักแห่งที่คุณสามารถทำได้:

พิมพ์ "

" . htmlspecialchars(print_r(get_defin_vars(), true))"

" ;
พิมพ์ "

" . htmlspecialchars (print_r ($_SERVER , true )) . "

" ;
?>

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

6 ปีที่แล้ว

เนื่องจาก get_defin_vars() รับเฉพาะตัวแปร ณ จุดที่คุณเรียกใช้ฟังก์ชัน จึงมีวิธีง่ายๆ ในการรับตัวแปรที่กำหนดภายในขอบเขตปัจจุบัน

// ด้านบนสุดของสคริปต์ php ของคุณ
$vars = get_defin_vars();

// ตอนนี้ทำธุระของคุณซะ
$foo = "ฟู" ;
$บาร์ = "บาร์" ;

// รับตัวแปรทั้งหมดที่กำหนดไว้ในขอบเขตปัจจุบัน
$vars = array_diff(get_defin_vars(), $vars);

เสียงสะท้อน "

"
;
print_r($วาร์ส); 
เสียงสะท้อน "

" ;
?>

15 ปีที่แล้ว

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

ฟังก์ชัน GenerateDebugReport ($method, $definition_vars, $email = "undef" )(
// ฟังก์ชั่นสร้างรายงานการแก้ปัญหาเพื่อแสดงหรือส่งอีเมล
// การใช้งาน: GenerateDebugReport(method,get_defin_vars(),email);
// โดยที่วิธีการคือ "เบราว์เซอร์" หรือ "อีเมล"

// สร้างรายการละเว้นสำหรับคีย์ที่ส่งคืนโดย "get_defin_vars"
// ตัวอย่างเช่น HTTP_POST_VARS, HTTP_GET_VARS และอื่นๆ
// ซ้ำซ้อน (เหมือนกับ _POST, _GET)
// รวมถึง vars ที่คุณต้องการละเว้นด้วยเหตุผลด้านความปลอดภัย - เช่น PHPSSID.
$ignorelist =array("HTTP_POST_VARS" , "HTTP_GET_VARS" ,
"HTTP_COOKIE_VARS" , "HTTP_SERVER_VARS" ,
"HTTP_ENV_VARS" , "HTTP_SESSION_VARS" ,
"_ENV" , "PHPSESSID" , "SESS_DBUSER" ,
"SESS_DBPASS" , "HTTP_COOKIE" );

$ประทับเวลา = วันที่ ("ด/ว/ย ชม:m:s" );
$message = "สร้างรายงานดีบั๊กแล้ว $timestamp \n" ;

// รับข้อผิดพลาด SQL สุดท้ายเพื่อการวัดผลที่ดี โดยที่ $link คือตัวระบุทรัพยากร
// สำหรับ mysql_connect แสดงความคิดเห็นหรือแก้ไขฐานข้อมูลหรือการตั้งค่านามธรรมของคุณ
$ ลิงค์ทั่วโลก ;
$sql_error = mysql_error($ลิงค์);
ถ้า($sql_error )(
$message .= "\nข้อความ Mysql:\n" mysql_error($ลิงค์);
}
// สิ้นสุด MySQL

// สามารถใช้ฟังก์ชันแบบเรียกซ้ำได้ที่นี่ คุณได้รับความคิด ;-)
foreach($define_vars เป็น $key => $val )(
if(is_array ($val ) && ! in_array ($key , $ignorelist ) && นับ ($val ) > 0 )(
$message .= "\n $key array (key=value):\n" ;
foreach($val เป็น $subkey => $subval )(
if(! in_array ($subkey , $ignorelist ) && ! is_array ($subval ))(
$message .= $คีย์ย่อย - $ย่อย. "\n" ;
}
elseif(! in_array ($คีย์ย่อย, $ignorelist ) && is_array ($subval ))(
foreach($subval เป็น $subsubkey => $subsubval )(
if(! in_array ($คีย์ย่อย, $ignorelist))(
$ข้อความ .= $คีย์ย่อย - $ย่อยย่อย "\n" ;
}
}
}
}
}
อย่างอื่น(! is_array ($วาล) && ! in_array ($คีย์ , $ignorelist ) && $val )(
$message .= "\nตัวแปร" $คีย์ - $วาล "\n" ;
}
}

ถ้า($method == "เบราว์เซอร์" )(
echo nl2br($ข้อความ);
}
elseif($method == "อีเมล" )(
ถ้า($อีเมล์ == "ไม่ได้กำหนด" )(
$อีเมล์ = $_SERVER [ "SERVER_ADMIN" ];
}

$mresult = mail ($email , "รายงานการแก้ปัญหาสำหรับ" . $_ENV [ "HOSTNAME" ]. "" , $message );
ถ้า($mresult == 1 )(
เสียงสะท้อน "ส่งรายงานการแก้ไขเรียบร้อยแล้ว\n";
}
อื่น(
เสียงสะท้อน "ไม่สามารถส่งรายงานการแก้ไขข้อบกพร่อง\n";
}
}
}
?>

17 ปีที่แล้ว

รูทีนง่ายๆ ในการแปลงอ็อบเจ็กต์ get_defin_vars เป็น XML

ฟังก์ชั่น obj2xml ($v, $indent = "" ) (
ในขณะที่ (รายการ($key , $val ) = แต่ละ ($v )) (
ถ้า ($key == "__attr" ) ดำเนินการต่อ;
// ตรวจสอบ __attr
ถ้า (is_object ($val -> __attr )) (
ในขณะที่ (list($key2 , $val2 ) = แต่ละ ($val -> __attr )) (
$attr .= " $key2 =\" $val2 \"" ;
}
}
อย่างอื่น $attr = "" ;
ถ้า (is_array ($val ) || is_object ($val )) (
พิมพ์(" $indent< $key$attr >\n" );
obj2xml($val, $indent. "");
พิมพ์(" $indent\n" );
}
อย่างอื่นพิมพ์(" $indent< $key$attr >$วาล\n" );
}
}

// ตัวอย่างวัตถุ
$x -> ชื่อ -> แรก = "จอห์น" ;
$x -> ชื่อ -> สุดท้าย = "สมิธ" ;
$x -> arr [ "ผลไม้" ] = "กล้วย" ;
$x -> arr [ "ผัก" ] = "แครอท" ;
$y -> ลูกค้า = $x ;
$y -> ลูกค้า -> __attr -> id = "176C4" ;

$z = get_defin_vars();
obj2xml($z["y"]);
?>
จะส่งออก:


จอห์น
สมิธ


กล้วย
แครอท

10 ปีที่แล้ว

ตามหมายเหตุ get_defin_vars() จะไม่ส่งคืนชุดการอ้างอิงตัวแปร (ตามที่ฉันหวังไว้) ตัวอย่างเช่น:

//กำหนดตัวแปร
$my_var = "ฟู" ;

// รับรายการตัวแปรที่กำหนดของเรา
$define_vars = get_defin_vars();

// ตอนนี้ลองเปลี่ยนค่าผ่านอาร์เรย์ที่ส่งคืน
$define_vars [ "my_var" ] = "bar" ;

เสียงสะท้อน $my_var , "\n" ;

?>

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

$define_vars = array();
$var_names = array_keys(get_defin_vars());

foreach ($var_names เป็น $var_name)
{
$define_vars [ $var_name ] =& $ $var_name ;
}

?>

1 ปีที่ผ่านมา

ฉันโพสต์ที่นี่ก่อนหน้านี้เกี่ยวกับ "สิ่งนี้" อยู่ใน get_defin_vars

ปรากฎว่าไม่ได้อยู่ที่นั่นเสมอไป แต่ในบางกรณีก็จะปรากฏขึ้นอย่างอธิบายไม่ได้

Php -r "
การทดสอบชั้นเรียน(
ฟังก์ชั่นสาธารณะ a() (var_dump(array_keys(get_defin_vars()));$a = 123;)
ฟังก์ชั่นสาธารณะ b() (var_dump(array_keys(get_defin_vars()));$this;)
}
$t = การทดสอบใหม่();
$t->a();
$t->b();
"

อาร์เรย์()
อาร์เรย์ ("นี้")

สิ่งนี้ไม่ได้เกิดขึ้นใน PHP 7.2 แต่จะเกิดขึ้นใน PHP 5.6

1 ปีที่ผ่านมา

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

ฉันจะไม่แนะนำคำแนะนำที่นี่ที่แปลงเป็นข้อมูลอ้างอิง

ฟังก์ชั่นสาธารณะ x($a, $b, $c) (
foreach(array_keys(get_defin_vars()) เป็น $key)
if($key !== "สิ่งนี้")
$นี่->y($($คีย์));
}

ฟังก์ชั่นสาธารณะ y(&$input) (
$อินพุต++;
}

แทนที่จะใช้ $() คุณสามารถใช้ $$ ได้

ฉันได้ทำสิ่งที่แปลกประหลาดในช่วงเวลาของฉันเพื่อสร้างโค้ดที่ธรรมดามาก แต่ฉันไม่เคยต้องทำอะไรเลยเหมือนที่กล่าวมาข้างต้น มันอาจจะไม่ได้ผลด้วยซ้ำ (แต่ควรจะเพราะมันไม่ต่างกับ $a[$key])

คุณสามารถทำ $$key++ ได้ แต่ฉันไม่เคยเห็นโค้ดแบบนั้นซึ่งไม่ได้แย่ขนาดนั้นมาก่อน (ใช้ไดนามิกโดยที่ไดนามิกไม่มีประโยชน์)

หากคุณกำลังทำอะไรแบบนั้นก็ให้ตรวจสอบเพิ่มเติม