(PHP 5 >= 5.3.0, PHP 7)

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

ขั้นแรกคำถามทั่วไป

1. หากฉันไม่ใช้เนมสเปซ สิ่งเหล่านี้ควรถือว่าสำคัญหรือไม่
2. ฉันจะใช้คลาสภายในหรือระดับโลกในเนมสเปซได้อย่างไร
3. ฉันจะใช้ฟังก์ชันคลาสในเนมสเปซหรือค่าคงที่ในเนมสเปซของตัวเองได้อย่างไร
4. ชื่อแบบนั้นเป็นยังไงบ้าง. \ของฉัน\ชื่อหรือ \ชื่อเปลี่ยนใจเลื่อมใส?
5. เหมือนชื่อเหมือน \ชื่อของฉันเปลี่ยนใจเลื่อมใส?
6. เหมือนชื่อคลาสที่ไม่เข้าเงื่อนไขเช่น ชื่อเปลี่ยนใจเลื่อมใส?
7. เช่นเดียวกับชื่อฟังก์ชันที่ไม่มีเงื่อนไขหรือชื่อคงที่ที่ไม่มีเงื่อนไขเช่น ชื่อเปลี่ยนใจเลื่อมใส?

รายละเอียดการใช้งานเนมสเปซบางส่วนที่เป็นประโยชน์ในการทำความเข้าใจ

1. ชื่อที่นำเข้าต้องไม่ขัดแย้งกับคลาสที่กำหนดไว้ในไฟล์เดียวกัน
2. ไม่สามารถนำเข้าฟังก์ชันหรือค่าคงที่โดยใช้ตัวดำเนินการ ใช้.
3. ชื่อเนมสเปซแบบไดนามิก (ตัวระบุที่อยู่ในเครื่องหมายคำพูด) จะต้องหลีกอักขระแบ็กสแลช
4. คุณไม่สามารถอ้างถึงค่าคงที่ที่ไม่ได้กำหนดโดยใช้แบ็กสแลช มีข้อผิดพลาดร้ายแรงปรากฏขึ้น
5. ไม่สามารถแทนที่ค่าคงที่พิเศษ เช่น NULL, TRUE, FALSE, ZEND_THREAD_SAFE หรือ ZEND_DEBUG_BUILD

หากฉันไม่ใช้เนมสเปซ สิ่งเหล่านี้ควรถือว่าสำคัญหรือไม่

เลขที่ เนมสเปซไม่มีผลกระทบต่อโค้ดที่มีอยู่ในรูปแบบใดๆ หรือโค้ดใดๆ ที่เขียนโดยไม่มีเนมสเปซ คุณสามารถเขียนโค้ดเช่นนี้ได้หากต้องการ:

ตัวอย่างที่ 1 การเข้าถึงคลาสระดับโลกภายนอกเนมสเปซ

$a = ใหม่ \ stdClass ;
?>

นี่คือฟังก์ชันการทำงานที่เทียบเท่ากับสิ่งต่อไปนี้:

ตัวอย่างที่ 2 การเข้าถึงคลาสระดับโลกภายนอกเนมสเปซ

$a = stdClass ใหม่ ;
?>

ฉันจะใช้คลาสภายในหรือระดับโลกในเนมสเปซได้อย่างไร

ตัวอย่าง #3 การเข้าถึงคลาสภายในในเนมสเปซ

เนมสเปซ foo ;
$a = ใหม่ \ stdClass ;

การทดสอบฟังก์ชัน (\ArrayObject $type Hintexample = null ) ()

$a = \ DirectoryIterator :: CURRENT_AS_FILEINFO ;

// ส่วนขยายของคลาสภายในหรือระดับโลก
คลาส MyException ขยาย\ข้อยกเว้น()
?>

ฉันจะใช้ฟังก์ชันคลาสในเนมสเปซหรือค่าคงที่ในเนมสเปซของตัวเองได้อย่างไร

ตัวอย่างที่ 4 การเข้าถึงคลาสภายใน ฟังก์ชัน หรือค่าคงที่ในเนมสเปซ

เนมสเปซ foo ;

คลาส MyClass()

// ใช้คลาสจากเนมสเปซปัจจุบัน
การทดสอบฟังก์ชัน (MyClass $type Hintexample = null ) ()
// อีกวิธีหนึ่งในการใช้คลาสจากเนมสเปซปัจจุบัน
การทดสอบฟังก์ชัน(\foo\MyClass $typehintexample = null)()

// ขยายคลาสจากเนมสเปซปัจจุบัน
คลาสขยายขยาย MyClass()

// เข้าถึงฟังก์ชันโกลบอล
$a = \globalfunc();

// เข้าถึงค่าคงที่ทั่วโลก
$ข = \INI_ALL ;
?>

ชื่อแบบนั้นเป็นยังไงบ้าง. \ของฉัน\ชื่อหรือ \ชื่อเปลี่ยนใจเลื่อมใส?

ชื่อที่ขึ้นต้นด้วย \ จะถูกแปลงเป็นสิ่งที่พวกเขาดูเหมือนเสมอเช่น \ของฉัน\ชื่อ- นี่คืออันที่จริง \ชื่อของฉัน, และ \ข้อยกเว้น- นี้ ข้อยกเว้น.

ตัวอย่างที่ 5 ชื่อสัมบูรณ์

เนมสเปซ foo ;
$a = ใหม่ \ ฉัน \ ชื่อ (); // สร้างอินสแตนซ์ของคลาส "my\name"
echo\strlen("สวัสดี"); // เรียกใช้ฟังก์ชัน "strlen"
$a = \INI_ALL ; // ตัวแปร $a ถูกกำหนดให้เป็นค่าคงที่ "INI_ALL"
?>

เหมือนชื่อเหมือน \ชื่อของฉันเปลี่ยนใจเลื่อมใส?

ชื่อที่มีแบ็กสแลชแต่ไม่ได้ขึ้นต้นด้วย เช่น \ชื่อของฉัน

ของฉันชื่ออื่น ดังนั้นคำพ้องความหมายนี้จึงมีผลกับ ของฉันวี \ชื่อของฉัน.

\ชื่อของฉัน.

ตัวอย่างที่ 6 ชื่อเต็ม

เนมสเปซ foo ;
ใช้ blah \ blah เป็น foo ;

$a = ใหม่ ฉัน\ชื่อ(); // สร้างอินสแตนซ์ของคลาส "foo\my\name"
foo\bar::name(); // เรียกเมธอดสแตติก "ชื่อ" ในคลาส "blah\blah\bar"
ของฉัน\บาร์(); // เรียกใช้ฟังก์ชัน "foo\my\bar"
$a = ของฉัน\BAR; // กำหนดตัวแปร $a เป็นค่าคงที่ "foo\my\BAR"
?>

เหมือนชื่อชั้นที่ไม่เข้าเงื่อนไขเช่น ชื่อเปลี่ยนใจเลื่อมใส?

ชื่อคลาสที่ไม่มีแบ็กสแลช เช่น ชื่อสามารถแปลงได้สองวิธี

หากมีการนำเข้านิพจน์ที่สร้างคำพ้องความหมาย ชื่อชื่ออื่นจึงใช้คำพ้องความหมายนี้

มิฉะนั้น ชื่อเนมสเปซปัจจุบันจะกลายเป็นคำนำหน้า \ชื่อของฉัน.

ตัวอย่างที่ 7 ชื่อชั้นเรียนที่ไม่มีเงื่อนไข

เนมสเปซ foo ;
ใช้ blah \ blah เป็น foo ;

$a = ชื่อใหม่(); // สร้างอินสแตนซ์ของคลาส "foo\name"
ฟู::ชื่อ(); // เรียกเมธอดสแตติก "name" ในคลาส "blah\blah"
?>

เช่นเดียวกับชื่อฟังก์ชันที่ไม่มีเงื่อนไขหรือชื่อคงที่ที่ไม่มีเงื่อนไขเช่น ชื่อเปลี่ยนใจเลื่อมใส?

ชื่อของฟังก์ชันหรือค่าคงที่ที่ไม่มีเครื่องหมายแบ็กสแลช เช่น ชื่อสามารถแปลงได้สองวิธี

ขั้นแรก ชื่อเนมสเปซปัจจุบันจะขึ้นต้นด้วย ชื่อ.

แล้วถ้าค่าคงที่หรือฟังก์ชัน ชื่อไม่มีอยู่ในเนมสเปซปัจจุบัน โดยใช้ค่าคงที่หรือฟังก์ชันโกลบอล ชื่อถ้ามันมีอยู่จริง

ตัวอย่างที่ 8 ฟังก์ชันที่ไม่สมบูรณ์หรือชื่อคงที่

เนมสเปซ foo ;
ใช้ blah \ blah เป็น foo ;

ค่า FOO = 1 ;

ฟังก์ชั่น my()()
ฟังก์ชั่นฟู()()
การเรียงลำดับฟังก์ชัน (& $a )
{
\sort($a); // เรียกฟังก์ชันโกลบอลว่า "sort"
$a = array_flip($a);
กลับ $a;
}

ของฉัน(); // เรียก "foo\my"
$a = strlen("สวัสดี"); // เรียกฟังก์ชันโกลบอล "strlen" เพราะไม่มี "foo\strlen"
$arr = อาร์เรย์(1, 3, 2);
$b = เรียงลำดับ($arr); // เรียกใช้ฟังก์ชัน "foo\sort"
$c = ฟู(); // เรียกใช้ฟังก์ชัน "foo\foo" - ไม่มีการนำเข้า

$a = FOO ; // กำหนดตัวแปร $a เป็นค่าคงที่ "foo\FOO" - ไม่มีการนำเข้า
$b = INI_ALL ; // กำหนดตัวแปร $b ​​ให้มีค่าคงที่โกลบอล "INI_ALL"
?>

ชื่อที่นำเข้าต้องไม่ขัดแย้งกับคลาสที่กำหนดไว้ในไฟล์เดียวกัน

การรวมสคริปต์ต่อไปนี้ถูกต้อง:

เนมสเปซของฉัน\stuff;
คลาส MyClass()
?>

เนมสเปซอื่น ;
เรื่องของคลาส()
?>

เนมสเปซของฉัน\stuff;
รวม "file1.php" ;
รวม "another.php" ;

$a = MyClass ใหม่ ; // สร้างอินสแตนซ์ของคลาส "สิ่ง" จากเนมสเปซ "อีกอัน"
?>

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

เนมสเปซของฉัน\stuff;
ใช้ \ สิ่งอื่นเป็น MyClass ;
คลาส MyClass() // ข้อผิดพลาดร้ายแรง: MyClass ขัดแย้งกับนิพจน์การนำเข้า
$a = MyClass ใหม่ ;
?>

ไม่อนุญาตให้ใช้เนมสเปซที่ซ้อนกัน

PHP ไม่อนุญาตให้เนมสเปซซ้อนกัน

เนมสเปซของฉัน\สิ่งของ(
เนมสเปซซ้อนกัน (
คลาสฟู()
}
}
?>

อย่างไรก็ตาม หากต้องการจำลองเนมสเปซที่ซ้อนกันเช่นนี้:

เนมสเปซ my\stuff\nested (
คลาสฟู()
}
?>

ก่อน PHP 5.6 ไม่สามารถนำเข้าฟังก์ชันและค่าคงที่โดยใช้ตัวดำเนินการได้ ใช้.

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

เหมืองเนมสเปซ ;
ใช้ชื่อพิเศษ \ ยาว \ ns \;

$a = ชื่อ \ คงที่ ;
ชื่อ\ฟังก์ชั่น();
?>

ตั้งแต่ PHP 5.6 เป็นต้นมา สามารถนำเข้าและสร้างนามแฝงสำหรับฟังก์ชันและชื่อคงที่ได้

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

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

ตัวอย่าง #9 ข้อผิดพลาดเมื่อใช้ชื่อเนมสเปซภายในสตริงที่มีเครื่องหมายคำพูดคู่

$a = "อันตราย\ชื่อ" ; // \n เป็นการขึ้นบรรทัดใหม่ภายในสตริงที่มีเครื่องหมายคำพูดคู่!
$obj = ใหม่ $a ;

$a = "ไม่\at\all\dangerous" ; // ไม่มีปัญหาที่นี่
$obj = ใหม่ $a ;
?>

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

คุณไม่สามารถอ้างถึงค่าคงที่ที่ไม่ได้กำหนดโดยใช้แบ็กสแลช มีข้อผิดพลาดร้ายแรงปรากฏขึ้น

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

ตัวอย่าง #10 ค่าคงที่ที่ไม่ได้กำหนด

แถบเนมสเปซ ;
$a = FOO ; // แสดงคำเตือน: ค่าคงที่ที่ไม่ได้กำหนด "FOO" ถือว่า "FOO";
$a = \FOO ; // ข้อผิดพลาดร้ายแรง: ค่าคงที่เนมสเปซที่ไม่ได้กำหนด FOO
$a = บาร์\FOO; // ข้อผิดพลาดร้ายแรง: ค่าคงที่เนมสเปซที่ไม่ได้กำหนด bar\Bar\FOO
$a = \บาร์ \FOO ; // ข้อผิดพลาดร้ายแรง: ค่าคงที่เนมสเปซที่ไม่ได้กำหนด Bar\FOO
?>

ไม่สามารถแทนที่ค่าคงที่พิเศษ เช่น NULL, TRUE, FALSE, ZEND_THREAD_SAFE หรือ ZEND_DEBUG_BUILD

ความพยายามใดๆ ในการกำหนดค่าคงที่เนมสเปซที่ตรงกับชื่อของค่าคงที่บิวท์อินแบบพิเศษจะส่งผลให้เกิดข้อผิดพลาดร้ายแรง

ตัวอย่าง #11 ค่าคงที่ที่ไม่ได้กำหนด

แถบเนมสเปซ ;
ค่าคอนทราสต์เป็นโมฆะ = 0 ; // ข้อผิดพลาดร้ายแรง;
const จริง = "โง่" ; // ข้อผิดพลาดร้ายแรงเช่นกัน;
// ฯลฯ
?>

7 ปีที่แล้ว

มีวิธีกำหนดค่าคงที่เนมสเปซที่เป็นค่าคงที่พิเศษในตัว โดยใช้ฟังก์ชันกำหนดและตั้งค่าพารามิเตอร์ตัวที่สาม case_insensitive เป็นเท็จ:

เนมสเปซ foo ;
กำหนด (__NAMESPACE__ . "\NULL" , 10 ); // กำหนดค่า NULL คงที่ในเนมสเปซปัจจุบัน


?>

ไม่จำเป็นต้องระบุเนมสเปซในการเรียกของคุณเพื่อกำหนด () เหมือนที่เกิดขึ้นตามปกติ
เนมสเปซ foo ;
กำหนด(INI_ALL, "บาร์"); // สร้างการแจ้งเตือน - ค่าคงที่ INI_ALL ที่กำหนดไว้แล้ว แต่:

กำหนด (__NAMESPACE__ . "\INI_ALL" , "bar" ); // กำหนดค่าคงที่ INI_ALL ในเนมสเปซปัจจุบัน
var_dump(INI_ALL); // จะแสดง string(3)"bar". ไม่มีอะไรที่ไม่ได้รับการตรวจสอบจนถึงตอนนี้ แต่:

กำหนด ("NULL", 10); // กำหนดค่า NULL คงที่ในเนมสเปซปัจจุบัน...
var_dump(โมฆะ); // จะแสดง 10
var_dump(null); // จะแสดงค่า NULL
?>

หากพารามิเตอร์ case_insensitive ถูกตั้งค่าเป็นจริง
เนมสเปซ foo ;
กำหนด (__NAMESPACE__ . "\NULL" , 10 , จริง ); // สร้างการแจ้งเตือน - ค่าคงที่คงที่ถูกกำหนดไว้แล้ว
?>

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

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

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

เนมสเปซ foo ;
คลาสบาร์(
การทดสอบฟังก์ชันคงที่สาธารณะ () (
กลับ get_call_class();
}
}

เนมสเปซ Foo\Foo;
คลาส Bar ขยาย \Foo \Bar (
}

Var_dump(แถบ::ทดสอบ()); // string(11) "Foo\Foo\Bar"

$bar = "ฟู\บาร์" ;
var_dump($bar::test()); // string(7) "Foo\Bar"

$บาร์ = __NAMESPACE__ "\บาร์" ;
var_dump($bar::test()); // string(11) "Foo\Foo\Bar"

$บาร์ = "บาร์" ;
var_dump($bar::test()); // ข้อผิดพลาดร้ายแรง: ไม่พบคลาส "Bar" หรือใช้คลาส \Bar ไม่ถูกต้อง

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

เป็นค่าที่ตั้งชื่อไว้ซึ่งจะไม่เปลี่ยนแปลงระหว่างการทำงานของโปรแกรม (สคริปต์)

ใน PHP ค่าคงที่ถูกกำหนดโดยฟังก์ชัน กำหนด()- ฟังก์ชันนี้มีรูปแบบดังต่อไปนี้:

กำหนด ($ชื่อ, $value, $case_sen), ที่ไหน:

$ชื่อ- ชื่อของค่าคงที่;
$value- ค่าคงที่;
$case_sen- พารามิเตอร์ทางเลือกของประเภทลอจิคัล
ระบุว่าตัวอักษรควรคำนึงถึงขนาดตัวพิมพ์ (จริง) หรือไม่ (เท็จ)

ตัวอย่างการกำหนดและการใช้ค่าคงที่ใน PHP:

เอคโค่ ไพ ;
// เอาท์พุต 3.14
?>

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

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

ค่าคงที่ไม่มีเครื่องหมายดอลลาร์นำหน้า ( $ );

ค่าคงที่สามารถกำหนดค่าได้โดยใช้ฟังก์ชันเท่านั้น กำหนด()ไม่ใช่โดยการกำหนดค่า

สามารถกำหนดและเข้าถึงค่าคงที่ได้ทุกที่โดยไม่คำนึงถึงขอบเขต

ค่าคงที่ไม่สามารถกำหนดหรือทำให้เป็นโมฆะได้หลังจากการประกาศครั้งแรก

ค่าคงที่จะมีได้เฉพาะค่าสเกลาร์เท่านั้น

การตรวจสอบการมีอยู่ของค่าคงที่

หากต้องการตรวจสอบการมีอยู่ของค่าคงที่ คุณสามารถใช้ฟังก์ชันได้ กำหนด()- ฟังก์ชันนี้ส่งคืน จริงถ้ามีการประกาศค่าคงที่ นี่คือตัวอย่าง:

// ประกาศค่าคงที่ pi
กำหนด ("pi" , 3.14 , จริง );
ถ้า (กำหนด ("pi" )== true ) echo "ค่าคงที่ pi ได้รับการประกาศแล้ว!";
// สคริปต์จะพิมพ์ "Constant pi ประกาศ!"
?>

PHP ค่าคงที่ที่กำหนดไว้ล่วงหน้า

ค่าคงที่ที่กำหนดไว้ล่วงหน้าต่อไปนี้มีอยู่ใน PHP:

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

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

ชื่อ	คำอธิบาย
__เส้น__	บรรทัดปัจจุบันในไฟล์
__ไฟล์__	เส้นทางแบบเต็มและชื่อของไฟล์ปัจจุบัน
__ผบ.__	ไดเร็กทอรีของไฟล์ หากใช้ภายในการรวม ไดเร็กทอรีของไฟล์ที่รวมไว้จะถูกส่งกลับ นี่เทียบเท่ากับ dirname(__FILE__) ชื่อไดเร็กทอรีนี้ไม่มีเครื่องหมายทับต่อท้าย เว้นแต่จะเป็นไดเร็กทอรีราก
__การทำงาน__	ชื่อฟังก์ชัน (เพิ่มใน PHP 4.3.0)
__ระดับ__	ชื่อชั้นเรียน (เพิ่มใน PHP 4.3.0)
__ลักษณะ__	ชื่อลักษณะ. ชื่อคุณลักษณะจะรวมถึงเนมสเปซที่ถูกประกาศไว้ด้วย (เช่น Foo\Bar)
__วิธี__	ชื่อของวิธีการเรียน (เพิ่มใน PHP 5.0.0)
__เนมสเปซ__	ชื่อของเนมสเปซปัจจุบัน

นอกจากนี้

ในโพสต์นี้ เราจะมาดูความแตกต่างในการประกาศค่าคงที่ PHP โดยใช้คีย์เวิร์ด const และฟังก์ชัน Defin()

ค่าคงที่ใน PHP คือ "ค่าคงที่" ซึ่งระบุค่าเพียงครั้งเดียวแล้วไม่สามารถเปลี่ยนแปลงได้ หากคุณพยายามเปลี่ยนค่า ค่านั้นจะไม่เปลี่ยนแปลงและข้อความ PHP จะปรากฏขึ้น: “กำหนดไว้แล้วคงที่”:

Define("FOO", "val"); กำหนด("FOO", "val2"); // หมายเหตุ: ค่าคงที่ที่กำหนดไว้แล้ว echo FOO; //>วาล

มีสองวิธีในการประกาศค่าคงที่ใน PHP:

// 1 กำหนด ("NAME", "VALUE"); // 2 const NAME = "ค่า";

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

วิธีการสร้างค่าคงที่

PHP น้อยกว่า 5.3

ก่อนเวอร์ชัน 5.3 ใน PHP ค่าคงที่สามารถกำหนดค่าได้โดยใช้ Defin() เท่านั้น คำสำคัญ const ปรากฏในเวอร์ชัน 5.3

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

// สเกลาร์กำหนด ("FOO", 10); กำหนด("FOO", 10.9); กำหนด("FOO", "val"); กำหนด("FOO", จริง); // ไม่ใช่สเกลาร์กำหนด ("FOO", อาร์เรย์ (1)); // ไม่ได้ตั้งค่าคงที่และเราได้รับคำเตือนกำหนด ("FOO", (วัตถุ) อาร์เรย์ (1)); // ไม่ได้ตั้งค่าคงที่และเราได้รับคำเตือน

จาก PHP 5.3

คีย์เวิร์ด const ปรากฏขึ้นแล้ว และตอนนี้ก็สามารถกำหนดค่าคงที่ได้โดยใช้คีย์เวิร์ดนั้น

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

ค่าคงที่ FOO = "val"; // ไม่มีข้อผิดพลาด const FOO = $var; // ข้อผิดพลาดในการแยกวิเคราะห์ const FOO = home_url(); // ข้อผิดพลาดในการแยกวิเคราะห์ const FOO = 5 + 10; // ข้อผิดพลาดในการแยกวิเคราะห์ const FOO = "foo"."bar"; // แยกวิเคราะห์ข้อผิดพลาด

ในขณะที่ Defin() ไม่มีข้อจำกัดดังกล่าว...

Define("FOO", "val"); // ไม่มีข้อผิดพลาดที่กำหนด ("FOO", $var); // ไม่มีข้อผิดพลาดกำหนด ("FOO", home_url()); // ไม่มีข้อผิดพลาดกำหนด ("FOO", 5 + 10); // ไม่มีข้อผิดพลาดกำหนด ("FOO", "foo"."bar"); //ไม่มีข้อผิดพลาด

พีเอชพี 5.6

มีความเป็นไปได้ที่จะระบุนิพจน์ PHP ดั้งเดิม (นิพจน์จากสเกลาร์) เป็นค่า const:

ค่าคงที่ FOO = 1 + 2; const FOO = "foo" "บาร์";

เป็นไปได้ที่จะจัดเก็บอาร์เรย์เป็นค่าคงที่:

ค่าคงที่ FOO = ; // งานกำหนด ("FOO", ); // ไม่ทำงานใน PHP 5.6 แต่ทำงานใน PHP 7.0

ความแตกต่างระหว่างกำหนด () และ const

ต้องประกาศ #1 const ในขอบเขตบนสุด

ไม่เหมือนกับกำหนด () ตรงที่ const จะต้องถูกประกาศที่ด้านบนสุดของขอบเขต เนื่องจากถูกกำหนดไว้เมื่อคอมไพล์สคริปต์ ซึ่งหมายความว่าไม่สามารถประกาศภายในคำสั่ง function/loops/if หรือ try/catch บล็อกได้

ถ้า (1) ( const NAME = "VALUE"; // ไม่ทำงาน ) // แต่ถ้า (1) ( กำหนด("NAME", "VALUE"); // ทำงาน )

#2 const จะคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่เสมอ

const จะคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่เสมอ ในขณะที่ Defin() ให้คุณสร้างค่าคงที่ที่ไม่คำนึงถึงตัวพิมพ์เล็กและใหญ่:

Define("NAME", "VALUE", จริง); สะท้อนชื่อ; // ชื่อเสียงสะท้อนมูลค่า; // ค่า

#3 const เข้าใจเฉพาะสเกลาร์เท่านั้น

สิ่งนี้ใช้ได้กับ PHP เวอร์ชัน 5.6 และต่ำกว่าเท่านั้น...

const ไม่สามารถส่งผ่านไปยังตัวแปร ฟังก์ชัน นิพจน์ได้ แต่กำหนด () สามารถเป็น:

ค่าคงที่ FOO = $var; // ข้อผิดพลาดในการแยกวิเคราะห์ const FOO = home_url(); // ข้อผิดพลาดในการแยกวิเคราะห์กำหนด ("FOO", $var); // ไม่มีข้อผิดพลาดกำหนด ("FOO", home_url()); //ไม่มีข้อผิดพลาด

#4 const สามารถจัดเก็บอาร์เรย์ตั้งแต่ PHP 5.6 และกำหนดตั้งแต่ PHP 7.0

const FOO = ; // ทำงานใน PHP 5.6 กำหนด ("FOO", ); // ไม่ทำงานใน PHP 5.6 แต่ทำงานใน PHP 7.0

ผลการเปรียบเทียบ

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

ค่าคงที่คลาส PHP

มีการประกาศโดยใช้ const เท่านั้น กฎสำหรับสิ่งเหล่านี้เป็นไปตามที่อธิบายไว้ข้างต้น: ยอมรับเฉพาะสเกลาร์เท่านั้น ไม่เข้าใจตัวแปร PHP ฟังก์ชัน นิพจน์...

ค่าคงที่ของคลาสจะเป็นสาธารณะเสมอ - ไม่มีสถานะส่วนตัวหรือสถานะที่ได้รับการคุ้มครอง

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

Class My_Class ( const NAME = "VALUE"; // เริ่มต้นด้วย PHP 5.6 คุณสามารถใช้นิพจน์ทางคณิตศาสตร์ const SEC_PER_DAY = 60 * 60 * 24; function print_name() ( // เข้าถึงค่าคงที่ของคลาสภายในเมธอดผ่าน self (คลาสนั้นเอง ) echo self ::NAME; ) ) // การเข้าถึงค่าคงที่ภายนอกคลาส // สามารถเรียกได้จากขอบเขตส่วนกลางโดยไม่ต้องเริ่มต้นอินสแตนซ์ของคลาส echo My_Class::NAME;

ค่าคงที่ของคลาสจะคล้ายกับคุณสมบัติของคลาสแบบคงที่มาก

คลาส My_Class ( const NAME = "VALUE"; static $name = "VALUE";; ) echo My_Class::NAME; เสียงสะท้อน My_Class::$name;

ค่าคงที่ "เวทมนตร์"

และโดยสรุป เรามาจำเกี่ยวกับค่าคงที่ PHP พิเศษกัน...

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

คงที่	คำอธิบาย
__เส้น__	หมายเลขบรรทัดปัจจุบันในไฟล์
__ไฟล์__	เส้นทางแบบเต็มและชื่อของไฟล์ปัจจุบันที่มีการเรียกค่าคงที่
__ผบ.__	พีเอชพี 5.3.0 ไดเร็กทอรีของไฟล์ที่ใช้ค่าคงที่ เช่นเดียวกับ dirname(__FILE__) ไม่มีเครื่องหมายทับต่อท้าย ยกเว้นในไดเร็กทอรีราก
__การทำงาน__	ชื่อฟังก์ชัน
__ระดับ__	ชื่อชั้นเรียน ชื่อนี้ประกอบด้วยชื่อของเนมสเปซซึ่งมีการประกาศคลาส (เช่น Foo\Bar) ยังทำงานในลักษณะ เมื่อใช้ในวิธีลักษณะ นี่คือชื่อของคลาสที่ใช้วิธีการเหล่านี้
__ลักษณะ__	พีเอชพี 5.4.0 ชื่อลักษณะ. ชื่อนี้ประกอบด้วยชื่อของเนมสเปซซึ่งมีการประกาศลักษณะ (เช่น Foo\Bar)
__วิธี__	ชื่อของวิธีการเรียน
__เนมสเปซ__	พีเอชพี 5.3.0 ชื่อของเนมสเปซปัจจุบัน
ชื่อคลาส::คลาส	พีพี 5.5.0 ชื่อคลาสเต็ม (รวมถึงเนมสเปซ) ดูเพิ่มเติมที่::คลาส

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

ไปกับคุณกันเถอะ มาสร้างค่าคงที่กันดีกว่าตัวเลข n:

กำหนด (PI, 3.1415926);
เสียงสะท้อน PI;
?>

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

แน่นอนในภายหลัง เปลี่ยนค่าคงที่ PI จะไม่ได้รับอนุญาต (นั่นเป็นสาเหตุที่เธอ คงที่).

ตอนนี้เรามาดูฟังก์ชันหนึ่งที่ตรวจสอบ: " ค่าคงที่ที่กำหนดถูกกำหนดไว้หรือไม่?". มาเขียนสคริปต์นี้:

ถ้า (!กำหนด("PI")) กำหนด(PI, 3.1415926);
เสียงสะท้อน PI;
?>

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

อย่างที่คุณเห็นสร้างและใช้ของคุณ ค่าคงที่ใน PHP- มันง่ายมาก

และสุดท้ายนี้ผมอยากจะพูดถึง ค่าคงที่ PHP ในตัว- มาเขียนสคริปต์ง่ายๆ:

phpinfo();
?>

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

เสียงสะท้อน $_SERVER["REMOTE_ADDR"];
เสียงสะท้อน "
";
เสียงสะท้อน $_SERVER["QUERY_STRING"];
?>

ในสคริปต์นี้เราส่งออก ที่อยู่ IP ของผู้ใช้ซึ่งเปิดตัวสคริปต์ และในบรรทัดถัดไป เราจะแสดงสตริงการสืบค้น (เช่น " index.php?id=7") มองไปข้างหน้าอีกหน่อย ฉันบอกว่าที่นี่เรากำลังทำงานร่วมกับระดับโลก อาร์เรย์ $_SERVER- เราจะมาทำความรู้จักกับอาร์เรย์ในภายหลัง แต่ฉันคิดว่าผู้ที่เคยทำงานกับอาร์เรย์ในภาษาการเขียนโปรแกรมอื่นจะจดจำไวยากรณ์ได้โดยไม่มีปัญหาใด ๆ สำหรับคนอื่นๆ ค่าคงที่จากนั้นการทำงานร่วมกับพวกเขาก็เกิดขึ้นในลักษณะเดียวกัน

ในบันทึกนี้เราจะพูดถึงค่าคงที่ ตามปกติเรามาดูแนวคิดเรื่องค่าคงที่ในภาษาการเขียนโปรแกรมและดูวิธีการประกาศและใช้งาน ค่าคงที่ใน PHP.

แนวคิดเรื่องค่าคงที่และค่าคงที่ใน PHP

คำว่าคงที่น่าจะคุ้นเคยกับคุณจากคณิตศาสตร์แล้ว:

“ค่าคงที่ทางคณิตศาสตร์- ปริมาณที่มูลค่าไม่เปลี่ยนแปลง”

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

หากต้องการประกาศค่าคงที่ (กำหนดค่าให้) ให้ใช้ฟังก์ชัน กำหนด- ตัวอย่างการประกาศอย่างต่อเนื่อง:

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

ชื่อคงที่ต้องขึ้นต้นด้วยตัวอักษรหรือขีดล่าง “_” และประกอบด้วยตัวอักษร ตัวเลข และขีดล่างได้

ลองดูตัวอย่างง่ายๆ ของการใช้ค่าคงที่:

ในตัวอย่างนี้ เราประกาศค่าคงที่และใช้ในโปรแกรม

ค่าคงที่มีไว้เพื่ออะไร และการใช้ตัวแปรง่ายกว่าไหม?

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

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

การใช้ค่าคงที่ช่วยให้แน่ใจว่าค่าที่คุณระบุเมื่อประกาศค่าคงที่จะไม่เปลี่ยนแปลง