ขอบเขตของตัวแปรคือบริบทที่ตัวแปรถูกกำหนดไว้

ในกรณีส่วนใหญ่ ตัวแปร PHP ทั้งหมดจะมีขอบเขตเพียงขอบเขตเดียว ขอบเขตเดียวนี้ยังครอบคลุมถึงไฟล์ที่รวมและไฟล์ที่จำเป็นด้วย ตัวอย่างเช่น:
$a = 1 ;
?>

รวม "b.inc" ;

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

ตัวอย่างเช่น:
{
$a = 1 ; /* ขอบเขตทั่วโลก */
}

การทดสอบฟังก์ชัน()
?>

เสียงสะท้อน $a ;

/* อ้างอิงถึงตัวแปรขอบเขตท้องถิ่น */ ทดสอบ();

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

คำสำคัญ ทดสอบ();

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

ขั้นแรกให้เป็นตัวอย่างการใช้งาน
{
ตัวอย่าง #1 การใช้งาน

$ข=2 ;
}

ฟังก์ชันผลรวม()
ทั่วโลก $a, $b;
?>

$ข = $a + $b ; 3 รวม();

เสียงสะท้อน $b ;

$GLOBALS เป็นอาร์เรย์ที่เชื่อมโยงซึ่งมีคีย์คือชื่อและค่าเป็นเนื้อหาของตัวแปรโกลบอล โปรดทราบว่า $GLOBALS มีอยู่ในขอบเขตใดๆ เนื่องจาก $GLOBALS เป็น superglobal

ด้านล่างนี้เป็นตัวอย่างที่แสดงให้เห็นถึงความสามารถของ superglobals:

ตัวอย่าง #3 Superglobals และขอบเขต
{
ฟังก์ชั่น test_global()
// ตัวแปรที่กำหนดไว้ล่วงหน้าส่วนใหญ่ไม่ใช่
// "ซุปเปอร์" และจะมีจำหน่ายในพื้นที่นั้น
// การมองเห็น ฟังก์ชั่นจำเป็นต้องระบุ "ทั่วโลก"

$HTTP_POST_VARS ทั่วโลก;

ก้อง $HTTP_POST_VARS["ชื่อ"];
// Superglobals มีอยู่ในขอบเขตใด ๆ
// มองเห็นได้และไม่จำเป็นต้องระบุ "ทั่วโลก"
// Superglobals มีให้บริการตั้งแต่ PHP 4.1.0 และ
// การใช้ HTTP_POST_VARS เลิกใช้แล้ว
}
?>

echo $_POST ["ชื่อ" ];:

ความคิดเห็น ทดสอบ();การใช้คำหลัก

ภายนอกฟังก์ชันไม่ใช่ข้อผิดพลาด สามารถใช้ในไฟล์ที่รวมอยู่ในฟังก์ชันได้ การใช้แบบคงที่ (คงที่

) ตัวแปร คุณสมบัติที่สำคัญอีกประการหนึ่งของขอบเขตตัวแปรคือคงที่

ตัวแปร. ตัวแปรคงที่มีอยู่ในขอบเขตภายในของฟังก์ชันเท่านั้น แต่จะไม่สูญเสียค่าเมื่อการทำงานของโปรแกรมออกจากขอบเขตนั้น ลองพิจารณาตัวอย่างต่อไปนี้:

ตัวอย่างที่ 4 แสดงให้เห็นถึงความจำเป็นในการใช้ตัวแปรคงที่
{
ทดสอบฟังก์ชัน()
$a = 0 ;
เสียงสะท้อน $a ;
}
?>

$a++; 0 ฟังก์ชั่นนี้ค่อนข้างไร้ประโยชน์เพราะทุกครั้งที่มันถูกเรียก มันจะตั้งค่า $a เป็น 0 และเอาท์พุท

- การเพิ่มขึ้นของตัวแปร $a ++ ไม่มีบทบาทที่นี่ เนื่องจากตัวแปร $a จะหายไปเมื่อออกจากฟังก์ชัน ในการเขียนฟังก์ชันการนับที่เป็นประโยชน์ซึ่งจะไม่สูญเสียค่าตัวนับปัจจุบัน ตัวแปร $a จะถูกประกาศแบบคงที่:

ตัวอย่างที่ 4 แสดงให้เห็นถึงความจำเป็นในการใช้ตัวแปรคงที่
{
ตัวอย่าง #5 ตัวอย่างการใช้ตัวแปรคงที่
$a = 0 ;
เสียงสะท้อน $a ;
}
?>

คงที่ $a = 0 ; ตอนนี้ $a จะเริ่มต้นได้เฉพาะในการเรียกใช้ฟังก์ชันครั้งแรกและการเรียกใช้ฟังก์ชันแต่ละครั้งทดสอบ()

จะพิมพ์ค่าของ $a และเพิ่มค่า

echo $_POST ["ชื่อ" ];:

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

ตัวอย่าง #7 การประกาศตัวแปรคงที่

ฟังก์ชั่นฟู ()(
คงที่ $int = 0 ; // ขวา
คงที่ $int = 1 + 2 ; // ไม่ถูกต้อง (เนื่องจากเป็นนิพจน์)
คงที่ $int = sqrt(121); // ไม่ถูกต้อง (เนื่องจากนี่เป็นนิพจน์ด้วย)

$int++;
เสียงสะท้อน $int ;
}
?>

echo $_POST ["ชื่อ" ];:

การประกาศแบบคงที่จะได้รับการประเมินระหว่างการคอมไพล์สคริปต์

ลิงค์กับทั่วโลก ( ทดสอบ();) และแบบคงที่ ( การใช้แบบคงที่ () ตัวแปร

Zend Engine 1 ซึ่งขับเคลื่อน PHP 4 ถือว่าตัวแก้ไขตัวแปรแบบคงที่และส่วนกลางเป็นข้อมูลอ้างอิง ตัวอย่างเช่น ตัวแปรโกลบอลจริงที่ฝังอยู่ในขอบเขตของฟังก์ชันโดยการระบุคีย์เวิร์ด ทดสอบ();ส่งผลให้สร้างการอ้างอิงถึงตัวแปรส่วนกลาง ซึ่งอาจนำไปสู่พฤติกรรมที่ไม่คาดคิด ดังที่แสดงในตัวอย่างต่อไปนี้:

ฟังก์ชั่น test_global_ref() (
$obj ทั่วโลก;
$obj = &คลาสมาตรฐานใหม่ ;
}

ฟังก์ชั่น test_global_noref() (
$obj ทั่วโลก;
$obj = คลาสมาตรฐานใหม่ ;
}

test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>

ผลลัพธ์ของการรันตัวอย่างนี้: get_instance_noref () (
คงที่ $obj ;

เอคโค่ "วัตถุคงที่:";
var_dump($obj);
ถ้า (!isset($obj )) (
// กำหนดวัตถุให้กับตัวแปรคงที่
$obj = คลาสมาตรฐานใหม่ ;
}
$obj -> คุณสมบัติ++;
กลับ $obj ;
}

$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
เสียงสะท้อน "\n" ;
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>

ผลลัพธ์ของการรันตัวอย่างนี้:

วัตถุคงที่: NULL
วัตถุคงที่: NULL

วัตถุคงที่: NULL
วัตถุคงที่: วัตถุ (stdClass)(1) (
["ทรัพย์สิน"]=>
อินท์(1)
}

ตัวอย่างนี้แสดงให้เห็นว่าเมื่อคุณกำหนดการอ้างอิงให้กับตัวแปรคงที่ จะไม่เป็นเช่นนั้น น่าจดจำเมื่อคุณเรียกใช้ฟังก์ชัน &get_instance_ref()เป็นครั้งที่สอง

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

ในตัวอย่างนี้ ตัวแปร $a จะพร้อมใช้งานภายในสคริปต์ที่รวมอยู่ด้วย - main.inc

ตัวแปรท้องถิ่น

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

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

30 ?>

จากผลของการดำเนินการส่วนนี้ สิ่งต่อไปนี้จะปรากฏขึ้น: 30.

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

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

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

ในบทความนี้ เราจะศึกษาอย่างชัดเจนว่าตัวแปรส่วนกลางคืออะไรและทำงานอย่างไร

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

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

ตัวแปรร่วม: สัญกรณ์อื่น
มีวิธีอื่นในการตั้งค่าตัวแปรโกลบอลหรือไม่? ใช่และไม่ได้อยู่คนเดียว มาดู $GLOBALS ก่อน เป็นอาเรย์แบบเชื่อมโยงซึ่งมีคีย์เป็นชื่อ เนื้อหาของตัวแปรส่วนกลางจะถูกใช้เป็นค่า เป็นที่น่าสังเกตว่าหลังจากการประกาศแล้ว อาร์เรย์นี้มีอยู่ในขอบเขตใดๆ นี่เป็นเหตุให้พิจารณาว่าเป็นเรื่องระดับโลก ดูเหมือนว่า: $GLOBALS ['ตัวแปร']

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

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

รหัสที่เป็นอันตราย
มาตั้งค่าตัวแปรเป็นจริงสำหรับผู้ใช้ที่ได้รับอนุญาต:
If (authenticate_user()) ($authoriza=true;) if ($authorize) ( รวม “/highly/sensitive/data.php”;) ตัวแปรในสถานะนี้สามารถตั้งค่าได้โดยอัตโนมัติ เมื่อพิจารณาว่าข้อมูลสามารถถูกแทนที่ได้ และไม่มีการกำหนดแหล่งที่มาของข้อมูล ดังนั้นผู้ใช้แทบทุกคนจึงสามารถผ่านการตรวจสอบดังกล่าวและปลอมแปลงเป็นบุคคลอื่นได้ ผู้โจมตีสามารถขัดขวางตรรกะของสคริปต์ทั้งหมดได้ หากต้องการ หากคุณเปลี่ยนค่าของคำสั่ง รหัสจะทำงานได้อย่างถูกต้อง นี่คือสิ่งที่เราต้องทำ อย่างไรก็ตาม การเริ่มต้นตัวแปรไม่เพียงแต่เป็นแนวทางปฏิบัติที่ดีในหมู่โปรแกรมเมอร์เท่านั้น แต่ยังรับประกันความเสถียรของสคริปต์อีกด้วย

ตัวเลือกที่เชื่อถือได้
เพื่อให้บรรลุเป้าหมายนี้ คุณสามารถลองปิดการใช้งานคำสั่งหรือเขียนโค้ดที่ซับซ้อนมากขึ้นได้ เช่น: if (isset($_SESSION ['username'])) (echo “Hello” ($_SESSION ['username') ])”;) อื่น ๆ (ก้อง “สวัสดีแขก”; สะท้อน “ยินดีต้อนรับ!”;) ในกรณีนี้การเปลี่ยนตัวจะเป็นเรื่องยาก อย่างไรก็ตามมันเป็นไปได้ ในการดำเนินการนี้ คุณจะต้องดูแลความพร้อมของเครื่องมือตอบสนองอย่างรวดเร็วล่วงหน้า หากคุณต้องการรวมตัวแปรส่วนกลางใน PHP คุณสามารถใช้เครื่องมือต่อไปนี้: หากคุณรู้แน่ชัดว่าจะได้รับค่าในช่วงใด คุณสามารถเขียนมันในลักษณะที่สคริปต์ตรวจสอบข้อเท็จจริงนี้โดยการเปรียบเทียบ แน่นอนว่าสิ่งนี้ไม่สามารถรับประกันการป้องกันการทดแทนค่าได้ 100% อย่างไรก็ตามการเลือกตัวเลือกที่เป็นไปได้จะทำให้การดำเนินการยุ่งยากขึ้นอย่างมาก

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

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

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

สวัสดีผู้อ่านบล็อกที่รัก เว็บไซต์บน! เมื่อเราได้เรียนรู้ว่ามีฟังก์ชันใน PHP เราได้เรียนรู้วิธีสร้างฟังก์ชันของเราเอง ส่งอาร์กิวเมนต์ไปให้ฟังก์ชันเหล่านั้น และเรียกฟังก์ชันเหล่านั้นให้ดำเนินการ ต่อไปในหัวข้อฟังก์ชั่นใน PHP จำเป็นต้องเน้นสิ่งต่อไปนี้:

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

ฟังก์ชันแบบมีเงื่อนไข

เราสามารถสร้าง (กำหนด, อธิบาย) ฟังก์ชั่นตามเงื่อนไขได้ ตัวอย่างเช่น:

//เรียกใช้ฟังก์ชัน sayHi ก็เรียกได้ทุกที่ /*ฟังก์ชัน sayGoodbye ไม่สามารถเรียกใช้ที่นี่ได้ เนื่องจากเรายังไม่ได้ตรวจสอบเงื่อนไขและยังไม่ได้เข้าไปใน if build*/ if($apply)( function sayGoodbye())( echo "ลาก่อนทุกคน!
"; } } /*ตอนนี้เราบอกลาได้แล้ว*/
"; }

ผลลัพธ์:

และดูตัวอย่างนี้:

/*และนี่คือสิ่งที่จะเกิดขึ้นหากคุณเอ่ยคำลาที่นี่*/บอกลา(); if($apply)( function sayGoodbye())( echo "ลาก่อนทุกคน!
"; ) ) ฟังก์ชั่น sayHi())( echo "สวัสดีทุกคน!
"; }

ผลลัพธ์:

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

ฟังก์ชันที่ซ้อนกัน

ฟังก์ชันที่ซ้อนกันคือฟังก์ชันที่ประกาศไว้ภายในฟังก์ชันอื่น ตัวอย่าง:

/*คุณไม่สามารถเรียก sayGoodbye ที่นี่ได้ เนื่องจากจะปรากฏหลังจากเรียกใช้ฟังก์ชัน sayHi เท่านั้น*/พูดว่าสวัสดี(); /*เรียกใช้ฟังก์ชัน sayHi เรียกได้ทุกที่*/ /*ตอนนี้เราบอกลาได้แล้ว*/บอกลา(); ฟังก์ชั่น sayHi())( echo "สวัสดีทุกคน!
"; ฟังก์ชั่น sayGoodbye())( echo "ลาก่อนทุกคน!
"; } }

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

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

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

ใน PHP เทคนิคที่อธิบายไว้ข้างต้นนั้นไม่ค่อยได้ใช้มากนัก เช่น ใน JavaScript

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

PHP มีสองขอบเขต: ทั่วโลกและ ท้องถิ่น- โครงสร้างภาษาการเขียนโปรแกรมแต่ละภาษามีขอบเขตที่แตกต่างกัน ตัวอย่างเช่น ใน C++ แม้แต่ลูปก็มีขอบเขต (ท้องถิ่น) ของตัวเอง อย่างไรก็ตาม ใน PHP นี่เป็นขอบเขตทั่วโลก แต่วันนี้เรากำลังพูดถึงฟังก์ชั่น

ฟังก์ชั่นใน PHP มีขอบเขตภายในของตัวเอง (ภายใน) นั่นคือตัวแปรทั้งหมดภายในฟังก์ชั่นจะมองเห็นได้เฉพาะภายในฟังก์ชั่นนี้เท่านั้น

อีกครั้งหนึ่ง: ทุกสิ่งที่อยู่นอกฟังก์ชันคือขอบเขตส่วนกลาง ทุกอย่างภายในฟังก์ชันคือขอบเขตภายในเครื่อง ตัวอย่าง:

เรียนผู้เชี่ยวชาญ โปรดทราบ คำถาม! คำสั่งสุดท้ายจะออกมาเป็นอย่างไร? สะท้อน $ ชื่อ; ?

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

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

ฉันขออธิบายขอบเขตในรูป:

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

การเข้าถึงตัวแปรส่วนกลางจากขอบเขตท้องถิ่น

แต่จะเกิดอะไรขึ้นถ้าเรายังคงต้องการเข้าถึงตัวแปร $name เดียวกันจากขอบเขตส่วนกลางจากฟังก์ชัน ไม่ใช่แค่เข้าถึงตัวแปรเท่านั้น แต่ยังต้องเปลี่ยนแปลงด้วย มี 3 ตัวเลือกหลักสำหรับสิ่งนี้ คนแรกคือการใช้คำหลัก ทดสอบ();:

"; ชื่อ $ ทั่วโลก; /*จากนี้ไปเราหมายถึงตัวแปรโกลบอล $name*/$name = "รัด เซอร์เกย์"; ) $name = "อันเดรย์"; พูดสวัสดี($ชื่อ); สะท้อน $ ชื่อ; -

ผลลัพธ์:

แต่วิธีนี้มีข้อเสียเนื่องจากเราเข้าถึงตัวแปรโกลบอล $ชื่อเราสูญเสีย (เขียนทับ) ตัวแปรท้องถิ่น $ชื่อ.

วิธีที่สองคือการใช้ PHP อาร์เรย์ superglobal- PHP เองจะวางตัวแปรทุกตัวที่เราสร้างขึ้นในขอบเขตส่วนกลางลงในอาร์เรย์นี้โดยอัตโนมัติ ตัวอย่าง:

$name = "อันเดรย์"; //เหมือนกัน.$GLOBALS["name"] = "อันเดรย์";

เพราะฉะนั้น:

"; $GLOBALS["name"] = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

ผลลัพธ์จะเหมือนกับเมื่อใช้คำหลัก ทดสอบ();:

เฉพาะครั้งนี้เท่านั้นที่เราไม่ได้เขียนตัวแปรภายในเครื่องใหม่ ซึ่งก็คือตัวแปร $ชื่อภายในฟังก์ชันยังคงเหมือนเดิมและเท่ากัน “อันเดรย์”, ไม่ "รัด เซอร์เกย์".

การผ่านข้อโต้แย้งโดยการอ้างอิง

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

ดังนั้น การส่งอาร์กิวเมนต์ที่ถูกต้องโดยการอ้างอิงใน PHP 5.3 และสูงกว่านั้นจะทำดังนี้:

ฟังก์ชั่น sayHi(& $name)(

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

และในที่สุดเราก็มี:

//ยอมรับไม่ใช่ค่า แต่เป็นการอ้างอิงถึงค่าสะท้อน "สวัสดี ".$ชื่อ"!
"; $name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

ผลลัพธ์:

ตัวแปรคงที่

ลองนึกภาพสถานการณ์ต่อไปนี้: เราต้องนับจำนวนครั้งที่เราทักทายทั้งหมด นี่คือสิ่งที่เรากำลังพยายามทำ:

"; $c++; // เพิ่มตัวนับขึ้น 1

---

ผลลัพธ์:

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

// ตัวนับทำให้คงที่สะท้อน "สวัสดี ".$ชื่อ"!
"; $c++; // เพิ่มตัวนับขึ้น 1 echo "เพิ่งกล่าวสวัสดี" . $ซี " ครั้งหนึ่ง.

---

"; ) sayHi("Rud Sergey"); sayHi("Andrey"); sayHi("Dmitry");

ผลลัพธ์:

ส่งกลับค่า

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

ผลลัพธ์:

มาสร้างมันขึ้นมาเพื่อที่แทนที่จะแสดงบนหน้าจอ มันจะส่งคืนผลลัพธ์การดำเนินการ เมื่อต้องการทำเช่นนี้ ให้ใช้คีย์เวิร์ด return:

ผลลัพธ์:

ตอนนี้เราสามารถใช้สิ่งนี้ได้หลายวิธี:

//ส่งออกผลลัพธ์เสียงสะท้อน "
"; $num = getSquare(5); echo $num;

ผลลัพธ์:

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

echo "PHP จะไม่มีวันเข้าถึงฉัน:(";) สะท้อน getSquare(5); //ส่งออกผลลัพธ์เสียงสะท้อน "
"; $num = getSquare(5); // กำหนดผลลัพธ์ให้กับตัวแปรเสียงสะท้อน $num; // แสดงตัวแปรบนหน้าจอ

ผลลัพธ์:

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

ฟังก์ชันแบบเรียกซ้ำ

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

"; if($number< 20){ // เพื่อให้การเรียกซ้ำไม่สิ้นสุด countPlease(++$หมายเลข); // ฟังก์ชัน countPlease เรียกตัวเองว่า) ) นับได้โปรด(1);

ผลลัพธ์:

หากคุณรู้วิธีการทำโดยไม่เรียกซ้ำ ก็ควรทำเช่นนั้นดีกว่า

การพิมพ์ที่แข็งแกร่งใน PHP (การปรับแต่งประเภท)

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

ผลลัพธ์:

ข้อผิดพลาดร้ายแรงที่สามารถตรวจจับได้: อาร์กิวเมนต์ 1 ที่ส่งผ่านไปยัง countPlease() จะต้องเป็นอาร์เรย์ จำนวนเต็มที่กำหนด เรียกใน /home/index.php บนบรรทัด 7 และกำหนดใน /home/index.php บนบรรทัด 3

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

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

เรียกว่าฟังก์ชันgetEcho

การใช้อาร์กิวเมนต์ความยาวแปรผัน

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

ผลลัพธ์:

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

func_num_args()- ส่งกลับจำนวนอาร์กิวเมนต์ที่ส่งไปยังฟังก์ชัน
func_get_arg (หมายเลขลำดับ)- ส่งคืนองค์ประกอบจากรายการอาร์กิวเมนต์
func_get_args()- ส่งกลับอาร์เรย์ที่มีอาร์กิวเมนต์ของฟังก์ชัน

"; echo func_get_arg(0) ; ) $age = 22; getEcho("Rud Sergey", $age);

ผลลัพธ์:

บทสรุป

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

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

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

ตัวแปรที่กำหนดภายในรูทีนย่อย (ฟังก์ชันที่ผู้ใช้กำหนด) สามารถเข้าถึงได้ภายในฟังก์ชันที่กำหนดไว้เท่านั้น

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

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

ให้เราอธิบายข้อเท็จจริงนี้ด้วยตัวอย่างเฉพาะ:

$a = 100 ;

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

$ก

" ;
}
การทำงาน();
เสียงสะท้อน "

$ก

" ;
?>

สคริปต์จะพิมพ์ 70 ก่อนแล้วจึง 100:

70
100

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

$a = 1 ;
ทั่วโลก

ฟังก์ชันผลรวม()
{
ทั่วโลก $a, $b;

$ข=2 ;
}

ฟังก์ชันผลรวม()
เสียงสะท้อน $b ;
?>

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

วิธีที่สองในการเข้าถึงตัวแปรขอบเขตทั่วโลกคือการใช้อาร์เรย์พิเศษที่กำหนดโดย PHP $GLOBALS- ตัวอย่างก่อนหน้านี้สามารถเขียนใหม่ได้ดังนี้:

ใช้ $GLOBALS แทน global:

$a = 1 ;
ทั่วโลก

ฟังก์ชันผลรวม()
{
$GLOBALS [ "b" ] = $GLOBALS [ "a" ] + $GLOBALS [ "b" ];
}

ฟังก์ชันผลรวม()
เสียงสะท้อน $b ;
?>

$GLOBALSเป็นอาเรย์แบบเชื่อมโยงซึ่งมีคีย์คือชื่อและมีค่าเป็นเนื้อหาของตัวแปรโกลบอล โปรดทราบว่า $GLOBALS มีอยู่ในขอบเขตใดๆ เนื่องจากเป็นอาร์เรย์ ด้านล่างนี้เป็นตัวอย่างที่แสดงให้เห็นถึงความสามารถของ superglobals:

ตัวอย่าง #3 Superglobals และขอบเขต
{
ฟังก์ชั่น test_global()
// "ซุปเปอร์" และจะมีจำหน่ายในพื้นที่นั้น
// การมองเห็นฟังก์ชันจำเป็นต้องระบุ "ทั่วโลก"
// การมองเห็น ฟังก์ชั่นจำเป็นต้องระบุ "ทั่วโลก"

$HTTP_POST_VARS ทั่วโลก;

ก้อง $HTTP_POST_VARS["ชื่อ"];
// มองเห็นได้และไม่จำเป็นต้องระบุ "ทั่วโลก"
// Superglobals มีให้ใช้งานตั้งแต่ PHP 4.1.0
// การใช้ HTTP_POST_VARS เลิกใช้แล้ว
}
?>