เนมสเปซ PHP (เนมสเปซ) ถูกเพิ่มเข้ามาใน PHP 5.3 หากคุณได้ศึกษา C# และ Java แล้ว เนมสเปซก็ไม่มีอะไรใหม่ อย่างไรก็ตาม มันยังคงมีความสำคัญอย่างมากใน PHP
เนมสเปซ PHP สามารถแก้ปัญหาได้สองประเภทต่อไปนี้:
ชื่อขัดแย้งกันระหว่างโค้ดที่ผู้ใช้เขียนกับคลาส/ฟังก์ชัน/ค่าคงที่ภายใน PHP หรือคลาส/ฟังก์ชัน/ค่าคงที่ของบุคคลที่สาม
สร้างชื่อนามแฝง (หรือชื่อสั้น) สำหรับชื่อตัวระบุที่ยาวมาก (โดยปกติจะกำหนดไว้เพื่อบรรเทาปัญหาประเภทแรก) เพื่อปรับปรุงความสามารถในการอ่านซอร์สโค้ด
ตามค่าเริ่มต้น ชื่อค่าคงที่ คลาส และฟังก์ชันทั้งหมดจะถูกวางไว้ในพื้นที่โกลบอล เช่นเดียวกับก่อนหน้าเนมสเปซที่รองรับ PHP
เนมสเปซถูกประกาศโดยใช้เนมสเปซคำหลัก หากไฟล์มีเนมสเปซ มันจะต้องประกาศเนมสเปซก่อนโค้ดอื่นทั้งหมด รูปแบบไวยากรณ์มีดังนี้
<?php // กำหนดโค้ดในเนมสเปซ 'MyProject' MyProject; // ... code...
คุณยังสามารถกำหนดรหัสเนมสเปซที่แตกต่างกันในไฟล์เดียวกันได้ เช่น:
<?php เนมสเปซ MyProject;const CONNECT_OK = 1;การเชื่อมต่อคลาส { /* ... */ }ฟังก์ชัน เชื่อมต่อ() { /* ... */ }เนมสเปซ AnotherProject;const CONNECT_OK = 1;การเชื่อมต่อคลาส { /* .. . */ }ฟังก์ชั่นเชื่อมต่อ() { /* ... */ }?>ไม่แนะนำให้ใช้ไวยากรณ์นี้เพื่อกำหนดเนมสเปซหลายรายการในไฟล์เดียว ขอแนะนำให้ใช้รูปแบบวงเล็บปีกกาต่อไปนี้
<?phpnamespace MyProject { const CONNECT_OK = 1; class Connection { /* ... */ } ฟังก์ชั่นเชื่อมต่อ() { /* ... */ }}namespace AnotherProject { const CONNECT_OK = 1; . */ } ฟังก์ชั่นเชื่อมต่อ() { /* ... */ }}?>หากต้องการรวมโค้ดที่ไม่ใช่เนมสเปซส่วนกลางเข้ากับโค้ดเนมสเปซ คุณสามารถใช้ได้เฉพาะไวยากรณ์วงเล็บปีกกาเท่านั้น รหัสสากลจะต้องอยู่ในคำสั่งเนมสเปซที่ไม่มีชื่อตามด้วยเครื่องหมายปีกกา ตัวอย่างเช่น:
<?phpnamespace MyProject {const CONNECT_OK = 1;class Connection { /* ... */ }function เชื่อมต่อ() { /* ... */ }}namespace { // Global code session_start();$a = MyProject เชื่อมต่อ();echo MyProjectConnection::start();}?>รหัสทางกฎหมายเพียงอย่างเดียวก่อนที่จะประกาศเนมสเปซคือคำสั่งประกาศที่กำหนดการเข้ารหัสของไฟล์ต้นฉบับ โค้ดที่ไม่ใช่ PHP ทั้งหมด รวมถึงช่องว่าง ไม่สามารถปรากฏก่อนการประกาศเนมสเปซ
<?phpdeclare(encoding='UTF-8'); //กำหนดเนมสเปซหลายอันและเนมสเปซโค้ดที่ไม่รวมอยู่ในเนมสเปซ MyProject {const CONNECT_OK = 1;class Connection { /* ... */ }function เชื่อมต่อ () { / * ... */ }}namespace { // รหัสสากล session_start();$a = MyProjectconnect();echo MyProjectConnection::start();}?>รหัสต่อไปนี้จะทำให้เกิดข้อผิดพลาดทางไวยากรณ์:
<html><?phpnamespace MyProject; // "<html>" ปรากฏขึ้นก่อนเนมสเปซจะทำให้เกิดข้อผิดพลาดร้ายแรง - เนมสเปซจะต้องเป็นคำสั่งแรกของสคริปต์โปรแกรม?>
เช่นเดียวกับความสัมพันธ์ระหว่างไดเร็กทอรีและไฟล์ เนมสเปซ PHP ยังช่วยให้คุณสามารถระบุชื่อเนมสเปซแบบลำดับชั้นได้ ดังนั้น ชื่อเนมสเปซสามารถกำหนดได้ในลักษณะลำดับชั้น:
<?phpnamespace MyProjectSubLevel; // ประกาศเนมสเปซเดี่ยวแบบมีลำดับชั้น const CONNECT_OK = 1;class Connection { /* ... */ }function Connect() { /* ... */ }?>ตัวอย่างข้างต้นสร้างค่าคงที่ MyProjectSubLevelCONNECT_OK คลาส MyProjectSubLevelConnection และฟังก์ชัน MyProjectSubLevelConnect
ชื่อคลาสในเนมสเปซ PHP สามารถอ้างอิงได้สามวิธี:
ชื่อที่ไม่เข้าเกณฑ์ หรือชื่อคลาสที่ไม่มีคำนำหน้า เช่น $a=new foo(); หรือ foo::staticmethod(); หากเนมสเปซปัจจุบันคือ currentnamespace foo จะได้รับการแก้ไขเป็น currentnamespacefoo หากโค้ดที่ใช้ foo เป็นโค้ดสากลและไม่มีโค้ดในเนมสเปซใดๆ foo จะได้รับการแก้ไขเป็น foo คำเตือน: หากไม่ได้กำหนดฟังก์ชันหรือค่าคงที่ในเนมสเปซ ฟังก์ชันหรือชื่อคงที่ที่ไม่เข้าเกณฑ์จะได้รับการแก้ไขเป็นฟังก์ชันโกลบอลหรือชื่อคงที่
ชื่อที่ผ่านการรับรอง หรือชื่อที่มีคำนำหน้า เช่น $a = new subnamespacefoo(); หรือ subnamespacefoo::staticmethod(); หากเนมสเปซปัจจุบันคือ currentnamespace foo จะได้รับการแก้ไขเป็น currentnamespacesubnamespacefoo หากโค้ดที่ใช้ foo เป็นโค้ดสากล โค้ดไม่มีอยู่ในเนมสเปซใดๆ foo จะถูกแก้ไขเป็น subnamespacefoo
ชื่อแบบเต็ม หรือชื่อที่มีตัวดำเนินการคำนำหน้าส่วนกลาง เช่น $a = new currentnamespacefoo(); หรือ currentnamespacefoo::staticmethod(); ในกรณีนี้ foo จะได้รับการแก้ไขเป็นชื่อตามตัวอักษร currentnamespacefoo ในโค้ดเสมอ
นี่คือตัวอย่างการใช้ทั้งสามวิธีนี้:
รหัสไฟล์ file1.php
<?phpnamespace FooBarsubnamespace; const FOO = 1;function foo() {}class foo{ ฟังก์ชันคงที่ staticmethod() {}}?>รหัสไฟล์ file2.php
<?phpnamespace FooBar;include 'file1.php';const FOO = 2;function foo() {}class foo{ static function staticmethod() {}}/* ชื่อที่ไม่มีเงื่อนไข*/foo(); // แยกวิเคราะห์ เป็นฟังก์ชัน FooBarfoofoo::staticmethod(); // มันถูกแยกวิเคราะห์เป็นคลาส FooBarfoo และวิธีการคือ staticmethodecho FOO; แก้ไขเป็นค่าคงที่ FooBarFOO/* ชื่อที่ผ่านการรับรอง*/subnamespacefoo(); // แก้ไขเป็นฟังก์ชัน FooBarsubnamespacefoosubnamespacefoo::staticmethod(); // แก้ไขเป็นคลาส FooBarsubnamespace foo, // และวิธีการเรียน staticmethodecho subnamespaceFOO; // แยกวิเคราะห์เป็นค่าคงที่ FooBarsubnamespaceFOO /* ชื่อที่มีคุณสมบัติครบถ้วน */FooBarfoo(); // แก้ไขเป็นฟังก์ชัน FooBarfooFooBarfoo::staticmethod(); // แก้ไขเป็นคลาส FooBarfoo และของคลาส วิธี staticmethodecho FooBarFOO; // แก้ไขเป็นค่าคงที่ FooBarFOO?>โปรดทราบว่าในการเข้าถึงคลาส ฟังก์ชัน หรือค่าคงที่ส่วนกลาง คุณสามารถใช้ชื่อแบบเต็มได้ เช่น strlen() หรือ Exception หรือ INI_ALL
เข้าถึงคลาส ฟังก์ชัน และค่าคงที่ส่วนกลางภายในเนมสเปซ:
<?phpnamespace Foo;function strlen() {}const INI_ALL = 3;class Exception {}$a = strlen('hi'); // เรียกฟังก์ชันโกลบอล strlen$b = INI_ALL; // เข้าถึงค่าคงที่โกลบอล INI_ALL$ c = new Exception('error'); // สร้างอินสแตนซ์ของข้อยกเว้นคลาสสากล?>การใช้งานเนมสเปซ PHP ได้รับผลกระทบจากลักษณะไดนามิกของภาษานั้นเอง ดังนั้นหากคุณต้องการแปลงโค้ดด้านล่างเป็นเนมสเปซ ให้เข้าถึงองค์ประกอบต่างๆ แบบไดนามิก
รหัสไฟล์ example1.php:
<?phpclass classname{ function __construct() { echo __METHOD__,"n"; }}function funcname(){ echo __FUNCTION__,"n";}const constname = "global";$a = 'classname';$obj = ใหม่ $a; // พิมพ์ classname::__construct$b = 'funcname';$b(); // พิมพ์ funcnameecho ค่าคงที่('constname'), "n"; // พิมพ์ทั่วโลก?>คุณต้องใช้ชื่อแบบเต็ม (ชื่อคลาสรวมถึงคำนำหน้าเนมสเปซ) โปรดทราบว่าเครื่องหมายแบ็กสแลชนำหน้าไม่จำเป็น เนื่องจากไม่มีความแตกต่างระหว่างชื่อที่ผ่านการรับรองและชื่อเต็มในชื่อคลาสไดนามิก ชื่อฟังก์ชัน หรือชื่อคงที่
เข้าถึงองค์ประกอบของเนมสเปซแบบไดนามิก
<?phpnamespace namespacename;class classname{ function __construct() { echo __METHOD__,"n"; }}function funcname(){ echo __FUNCTION__,"n";}const constname = "namespaced";include 'example1.php' ;$a = 'ชื่อคลาส';$obj = ใหม่ $a; // ชื่อคลาสเอาท์พุต::__construct$b = 'funcname';$b(); // ชื่อฟังก์ชันเอาท์พุต echo Constant('constname'), "n"; // Output global/* หากใช้เครื่องหมายคำพูดคู่ วิธีการใช้งานคือ "\namespacename\classname "* /$a = 'namespacenameclassname';$obj = new $a; // เอาต์พุต namespacenameclassname::__construct$a = 'namespacenameclassname';$obj = new $a; // เอาต์พุต namespacenameclassname::__construct$b = 'namespacenamefuncname';$b(); // เอาต์พุต namespacenamefuncname$b = 'namespacenamefuncname';$b(); // เอาต์พุต namespacenamefuncnameecho คงที่( 'namespacenameconstname'), "n"; // ค่าคงที่ namespacedecho เอาท์พุต('namespacenameconstname'), "n"; เนมสเปซเอาต์พุต?>PHP รองรับวิธีนามธรรมสองวิธีในการเข้าถึงองค์ประกอบภายในเนมสเปซปัจจุบัน ได้แก่ ค่าคงที่เวทย์มนตร์ __NAMESPACE__ และคีย์เวิร์ดเนมสเปซ
ค่าของค่าคงที่ __NAMESPACE__ คือสตริงที่มีชื่อของเนมสเปซปัจจุบัน ในโค้ดสากลที่ไม่รวมอยู่ในเนมสเปซใดๆ จะมีสตริงว่าง
ตัวอย่าง __NAMESPACE__ โค้ดในเนมสเปซ
<?phpnamespace MyProject;echo '"', __NAMESPACE__, '"'; // เอาท์พุต "MyProject"?>
ตัวอย่าง __NAMESPACE__ รหัสสากล
<?phpecho '"', __NAMESPACE__, '"'; // เอาท์พุต ""?>
ค่าคงที่ __NAMESPACE__ มีประโยชน์เมื่อสร้างชื่อแบบไดนามิก ตัวอย่างเช่น:
สร้างชื่อแบบไดนามิกโดยใช้ __NAMESPACE__
<?phpnamespace MyProject;function get($classname){ $a = __NAMESPACE__ . $classname; กลับใหม่ $a;}?>เนมสเปซคำหลักสามารถใช้เพื่อเข้าถึงองค์ประกอบในเนมสเปซปัจจุบันหรือเนมสเปซย่อยได้อย่างชัดเจน มันเทียบเท่ากับตัวดำเนินการตนเองในชั้นเรียน
ตัวดำเนินการเนมสเปซ รหัสในเนมสเปซ
<?phpnamespace MyProject;use blahblahmine()namespaceblahmine(); // ฟังก์ชันการโทร MyProjectblahmine()namespacefunc(); // ฟังก์ชันการโทร MyProjectfunc()namespacesubfunc(); MyProjectsubfunc()namespacecname::method(); // เรียกเมธอดแบบคงที่ "method" ของคลาส MyProjectcname$a = new namespacesubcname(); // สร้างอินสแตนซ์อ็อบเจ็กต์ของคลาส MyProjectsub cname$b = namespaceCONSTANT; // กำหนดค่าคงที่ MyProjectCONSTANT ให้กับ $b?>
ตัวดำเนินการเนมสเปซ รหัสโกลบอล
<?phpnamespacefunc(); // เรียกใช้ฟังก์ชัน func()namespacesubfunc(); // เรียกใช้ฟังก์ชัน subfunc()namespacecname::method(); class cname$a = new namespacesubcname(); // สร้างอินสแตนซ์อ็อบเจ็กต์ของคลาส subcname$b = namespaceCONSTANT; // กำหนดค่าคงที่ CONSTANT ให้กับ $b?>
การสนับสนุน PHP เนมสเปซมีสองวิธีในการใช้นามแฝงหรือการนำเข้า: การใช้นามแฝงสำหรับชื่อคลาส หรือใช้นามแฝงสำหรับชื่อเนมสเปซ
ใน PHP การใช้นามแฝงจะดำเนินการผ่านตัวดำเนินการการใช้งาน นี่คือตัวอย่างโดยใช้วิธีการนำเข้าที่เป็นไปได้ทั้งสามวิธี:
1. ใช้โอเปอเรเตอร์การใช้งานเพื่อนำเข้า/ใช้นามแฝง
<?phpnamespace foo;use MyFullClassname as Another;// ตัวอย่างต่อไปนี้เหมือนกับการใช้ MyFullNSname เป็น NSname use MyFullNSname;// Import a global class use ArrayObject;$obj = เนมสเปซใหม่Another; // สร้างอินสแตนซ์ fooAnother object $obj = new Another; // สร้างอินสแตนซ์ MyFullClassname object NSnamesubnsfunc(); เรียกใช้ฟังก์ชัน MyFullNSnamesubnsfunc$a = new ArrayObject(array(1)); // สร้างอินสแตนซ์ของวัตถุ ArrayObject // หากคุณไม่ได้ใช้ "use ArrayObject" ให้สร้างอินสแตนซ์ของ fooArrayObject object? >
2. หนึ่งบรรทัดประกอบด้วยคำสั่งการใช้งานหลายรายการ
<?phpuse MyFullClassname as Another, MyFullNSname;$obj = new Another; // สร้างอินสแตนซ์ MyFullClassname object NSnamesubnsfunc(); // ฟังก์ชันการโทร MyFullNSname ย่อยfunc?>
การดำเนินการนำเข้าจะดำเนินการในระหว่างการคอมไพล์ แต่ไม่มีชื่อคลาสไดนามิก ชื่อฟังก์ชัน หรือชื่อคงที่
3. นำเข้าและชื่อแบบไดนามิก
<?phpuse MyFullClassname as Another, MyFullNSname;$obj = new Another; // สร้างอินสแตนซ์ของวัตถุ MyFullClassname $a = 'Another';$obj = new $a; วัตถุอื่น?>
นอกจากนี้ การดำเนินการนำเข้าจะมีผลกับชื่อที่ไม่ผ่านการรับรองและมีคุณสมบัติเหมาะสมเท่านั้น ชื่อที่มีคุณสมบัติครบถ้วนจะไม่ได้รับผลกระทบจากการนำเข้าเนื่องจากเป็นชื่อที่กำหนดได้
4. นำเข้าและชื่อที่มีคุณสมบัติครบถ้วน
<?phpuse MyFullClassname as Another, MyFullNSname;$obj = new Another; // ยกตัวอย่างคลาส MyFullClassname $obj = new Another; // สร้างอินสแตนซ์คลาสอื่น $obj = new Another สิ่ง; // สร้างอินสแตนซ์คลาสของฉัน เต็ม ชื่อคลาส $ obj = ใหม่ อื่น สิ่ง; // สร้างอินสแตนซ์คลาสอื่น สิ่ง?>
ภายในเนมสเปซ เมื่อ PHP พบคลาส ฟังก์ชัน หรือชื่อคงที่ที่ไม่เข้าเกณฑ์ PHP จะใช้กลยุทธ์ลำดับความสำคัญที่แตกต่างกันเพื่อแก้ไขชื่อ ชื่อคลาสจะเป็นชื่อในเนมสเปซปัจจุบันเสมอ ดังนั้น เมื่อเข้าถึงชื่อคลาสที่อยู่ภายในระบบหรือไม่มีอยู่ในเนมสเปซ คุณต้องใช้ชื่อแบบเต็ม ตัวอย่างเช่น:
1. เข้าถึงคลาสระดับโลกในเนมสเปซ
<?phpnamespace ABC;class Exception ขยาย Exception {}$a = new Exception('hi'); // $a เป็นวัตถุของคลาส ABCException $b = new Exception( 'สวัสดี'); // $b เป็นวัตถุของคลาส ข้อยกเว้น $c = new ArrayObject; // ข้อผิดพลาดร้ายแรง ไม่พบคลาส ABCArrayObject?>สำหรับฟังก์ชันและค่าคงที่ หากไม่มีฟังก์ชันหรือค่าคงที่ในเนมสเปซปัจจุบัน PHP จะถอยกลับไปใช้ฟังก์ชันหรือค่าคงที่ในโกลบอลสเปซ
2. สำรองฟังก์ชัน/ค่าคงที่ส่วนกลางในเนมสเปซ
<?phpnamespace ABC;const E_ERROR = 45;function strlen($str){ return strlen($str) - 1;}echo E_ERROR, "n"; // เอาท์พุต "45"echo INI_ALL, " n"; // เอาท์พุต "7" - ใช้ค่าคงที่โกลบอล INI_ALLecho strlen('hi'), "n"; // เอาท์พุต "2"if (is_array('hi')) { // เอาต์พุต "is not array" echo "is arrayn";} else { echo "is not arrayn";}?>หากไม่มีการกำหนดเนมสเปซ คลาสและฟังก์ชันทั้งหมดจะถูกกำหนดในโกลบอลสเปซ เช่นเดียวกับก่อนที่ PHP จะนำแนวคิดเนมสเปซมาใช้ การเติมชื่อด้วย นำหน้าแสดงว่าชื่อนั้นอยู่ในโกลบอลสเปซ แม้ว่าชื่อนั้นจะอยู่ในเนมสเปซอื่นก็ตาม
ใช้คำแนะนำเกี่ยวกับอวกาศ
<?phpnamespace ABC;/* ฟังก์ชั่นนี้คือ ABCfopen */function fopen() { /* ... */ $f = fopen(...); // โทรทั่วโลก ฟังก์ชัน fopen ส่งคืนค่า $f;} ?>นับตั้งแต่มีการเปิดตัวเนมสเปซ สิ่งที่เกิดข้อผิดพลาดได้ง่ายที่สุดคือเมื่อใช้คลาส อะไรคือเส้นทางการค้นหาสำหรับคลาสนี้
<?phpnamespace A;ใช้ BD, CE เป็น F;// การเรียกใช้ฟังก์ชัน foo(); // ขั้นแรกให้ลองเรียกใช้ฟังก์ชัน foo() ที่กำหนดไว้ในเนมสเปซ "A" // จากนั้นให้ลองเรียกใช้ฟังก์ชัน global function" foo"foo(); // เรียกฟังก์ชัน global space "foo" myfoo(); // เรียกฟังก์ชัน "foo" ที่กำหนดไว้ในเนมสเปซ "Amy" F(); ขั้นแรกให้ลองเรียกใช้ฟังก์ชัน "F" ที่กำหนดในเนมสเปซ "A" // จากนั้นลองเรียกใช้ฟังก์ชันโกลบอล "F" // การอ้างอิงคลาสใหม่ B(); // สร้างคลาส "B" ที่กำหนดในเนมสเปซ "A" วัตถุของ คลาส "AB" new D(); // หากไม่พบ ให้ลองโหลดคลาส "AB" new D(); // ใช้กฎการนำเข้า สร้างอ็อบเจ็กต์ของคลาส "D" ที่กำหนดในเนมสเปซ "B " // หากไม่พบ หากพบให้ลองโหลดคลาส "BD" ใหม่โดยอัตโนมัติ F(); // ใช้กฎการนำเข้า สร้างอ็อบเจ็กต์ของคลาส "E" ที่กำหนดในเนมสเปซ "C" // หากไม่พบ ให้ลองโหลดคลาส "CE" ใหม่ B(); ของคลาส "B" ที่กำหนดในโกลบอลสเปซ // หากไม่พบ ให้ลองโหลดคลาส "B" ใหม่ D(); // สร้างอ็อบเจ็กต์ของคลาส "D" ที่กำหนดในโกลบอลสเปซ // หากไม่พบ ให้ลอง โหลดคลาสอัตโนมัติ "D" ใหม่ F(); // สร้างอ็อบเจ็กต์ของคลาส "F" ที่กำหนดในโกลบอลสเปซ // หากไม่พบ ให้ลองโหลดคลาส "F" อัตโนมัติ // เรียกใช้เมธอดสแตติกหรือฟังก์ชันเนมสเปซในเนมสเปซอื่น Bfoo() ; // ฟังก์ชันการโทร "foo" ในเนมสเปซ "AB" B::foo(); // วิธีการเรียก "foo" ของคลาส "B" ที่กำหนดในเนมสเปซ "A" // ถ้าคลาส "AB" คือ ไม่พบ จากนั้นลองโหลดคลาส "AB" D::foo(); // ใช้กฎการนำเข้าเพื่อเรียกเมธอด "foo" ของคลาส "D" ที่กำหนดในเนมสเปซ "B" // ถ้าคลาส "BD " " หากไม่พบ ให้ลองโหลดคลาส "BD"Bfoo(); // เรียกใช้ฟังก์ชัน "foo" ในเนมสเปซ "B" B::foo(); ทำหน้าที่ในอวกาศคลาส "B" วิธีการ "foo" // หากไม่พบคลาส "B" ให้ลองโหลดคลาส "B" โดยอัตโนมัติ // วิธีการหรือฟังก์ชันคงที่ในเนมสเปซปัจจุบัน AB::foo(); // เรียกเนมสเปซ "A" วิธีการ "foo" ของคลาส "B" ที่กำหนดไว้ใน A" // หากไม่พบคลาส "AAB" ให้ลองโหลดคลาส "AAB"AB::foo() โดยอัตโนมัติ // เรียกเมธอด "foo" ของคลาส "B" ที่กำหนดไว้ในเนมสเปซ "A" // หากไม่พบคลาส "AB" ให้ลองโหลดคลาส "AB" โดยอัตโนมัติ?>
การจำแนกชื่อเป็นไปตามกฎต่อไปนี้:
การเรียกชื่อฟังก์ชัน คลาส และค่าคงที่ที่มีคุณสมบัติครบถ้วนได้รับการแก้ไข ณ เวลาคอมไพล์ ตัวอย่างเช่น new AB แก้ไขเป็นคลาส AB
ชื่อที่ไม่ผ่านการรับรองและชื่อที่ผ่านการรับรองทั้งหมด (ชื่อที่ผ่านการรับรองไม่ครบถ้วน) จะถูกแปลง ณ เวลารวบรวมตามกฎการนำเข้าปัจจุบัน ตัวอย่างเช่น หากนำเข้าเนมสเปซ ABC เป็น C ดังนั้นการเรียกไปยัง CDe() จะถูกแปลเป็น ABCDe()
ภายในเนมสเปซ ชื่อที่ผ่านการรับรองทั้งหมดที่ไม่ได้แปลงตามกฎการนำเข้าจะมีชื่อเนมสเปซปัจจุบันอยู่ข้างหน้า ตัวอย่างเช่น หาก CDe() ถูกเรียกภายในเนมสเปซ AB CDe() จะถูกแปลงเป็น ABCDe()
ชื่อคลาสที่ไม่ผ่านการรับรองจะถูกแปลงในเวลาคอมไพล์ตามกฎการนำเข้าปัจจุบัน (ใช้ชื่อเต็มแทนชื่อการนำเข้าแบบสั้น) ตัวอย่างเช่น หากนำเข้าเนมสเปซ ABC เป็น C แล้ว new C() จะถูกแปลงเป็น ABC() ใหม่
ภายในเนมสเปซ (เช่น AB) การเรียกใช้ฟังก์ชันไปยังชื่อที่ไม่เข้าเกณฑ์จะได้รับการแก้ไขขณะรันไทม์ ตัวอย่างเช่น การเรียกใช้ฟังก์ชัน foo() จะถูกแยกวิเคราะห์ดังนี้:
ค้นหาฟังก์ชันชื่อ ABfoo() ในเนมสเปซปัจจุบัน
ลองค้นหาและเรียกใช้ฟังก์ชัน foo() ใน โกลบอล สเปซ
การเรียกไปยังชื่อที่ไม่ผ่านการรับรองหรือคลาสชื่อที่ผ่านการรับรอง (ชื่อที่ไม่ครบถ้วน) ภายในเนมสเปซ (เช่น AB ) ได้รับการแก้ไขเมื่อรันไทม์ ต่อไปนี้เป็นกระบวนการแยกวิเคราะห์ของการเรียก new C() และ new DE() : การแยกวิเคราะห์ new C() :
ค้นหาคลาส ABC ในเนมสเปซปัจจุบัน
ลองโหลดคลาส ABC อัตโนมัติ
วิเคราะห์ DE() ใหม่ :นำหน้าชื่อคลาสด้วยชื่อเนมสเปซปัจจุบันให้เป็น: ABDE จากนั้นค้นหาคลาสนั้น
ลองโหลดคลาส ABDE อัตโนมัติ
ในการอ้างถึงคลาสโกลบอลในเนมสเปซโกลบอล ต้องใช้ชื่อแบบเต็ม C() ใหม่