Editor akan mengajar anda urutan panggilan ruang nama

Dalam artikel sebelumnya, kami belajar tentang mengakses elemen dalaman ruang nama Jika anda memerlukannya, sila baca "Editor akan menunjukkan kepada anda cara mengakses elemen dalaman ruang nama (versi php) ". Kali ini kami akan memperkenalkan susunan ruang nama kepada anda, anda boleh merujuknya jika perlu.

Mula-mula mari kita lihat contoh kecil.

<?php
namespace A;
use B\D, C\E as F;

// 函数调用

foo();      // 首先尝试调用定义在命名空间"A"中的函数foo()
            // 再尝试调用全局函数 "foo"

\foo();     // 调用全局空间函数 "foo" 

my\foo();   // 调用定义在命名空间"A\my"中函数 "foo" 

F();        // 首先尝试调用定义在命名空间"A"中的函数 "F" 
            // 再尝试调用全局函数 "F"

// 类引用

new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象
            // 如果未找到，则尝试自动装载类 "A\B"

new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象
            // 如果未找到，则尝试自动装载类 "B\D"

new F();    // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象
            // 如果未找到，则尝试自动装载类 "C\E"

new \B();   // 创建定义在全局空间中的类 "B" 的一个对象
            // 如果未发现，则尝试自动装载类 "B"

new \D();   // 创建定义在全局空间中的类 "D" 的一个对象
            // 如果未发现，则尝试自动装载类 "D"

new \F();   // 创建定义在全局空间中的类 "F" 的一个对象
            // 如果未发现，则尝试自动装载类 "F"

// 调用另一个命名空间中的静态方法或命名空间函数

B\foo();    // 调用命名空间 "A\B" 中函数 "foo"

B::foo();   // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
            // 如果未找到类 "A\B" ，则尝试自动装载类 "A\B"

D::foo();   // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法
            // 如果类 "B\D" 未找到，则尝试自动装载类 "B\D"

\B\foo();   // 调用命名空间 "B" 中的函数 "foo" 

\B::foo();  // 调用全局空间中的类 "B" 的 "foo" 方法
            // 如果类 "B" 未找到，则尝试自动装载类 "B"

// 当前命名空间中的静态方法或函数

A\B::foo();   // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法
              // 如果类 "A\A\B" 未找到，则尝试自动装载类 "A\A\B"

\A\B::foo();  // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
              // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"
?>

Melihat dengan teliti contoh kecil di atas, apakah yang boleh kita perhatikan? Dangdang, kami akan berikan jawapannya sekarang.

Apabila memanggil fungsi, jika kita hanya menulis "

", fungsi dalam ruang nama akan dipanggil dahulu, dan kemudian fungsi global akan dipanggil tetapi jika ia adalah "foo()", ini hanya akan Fungsi global dipanggil. foo()

Apabila menggunakan kelas, jika kita menulis "

", objek kelas "B" yang ditakrifkan dalam ruang nama akan dicipta, tetapi jika ia tidak dijumpai, ia akan cuba memuatkan kelas secara automatik "new B();". AB

Apabila memanggil kaedah statik atau fungsi ruang nama dalam ruang nama lain, kami menulis "

", yang menunjukkan bahawa kami akan memanggil fungsi "Bfoo()" dalam ruang nama tetapi berbeza jika anda menulis "; foo()". Dia mula-mula memanggil fungsi "foo()" dalam ruang nama, tetapi jika ia tidak dijumpai, ia cuba memuatkan kelas "AB" secara automatik. B::foo();

Apabila kami menulis kaedah atau fungsi statik dalam ruang nama semasa, kami menulis "

", yang menunjukkan bahawa kami akan memanggil "foo" kelas "B" yang ditakrifkan dalam ruang nama Kaedah "AA" untuk secara automatik muatkan kelas "AAB" jika tidak dijumpai. AB::foo();

Sekarang mari kita ringkaskan.

• Panggilan ke fungsi, kelas dan pemalar yang layak sepenuhnya akan diselesaikan pada masa penyusunan. Sebagai contoh, newaB memutuskan kepada kelas aB.

• Semua nama tidak layak dan nama layak (nama tidak layak sepenuhnya) ditukar pada masa penyusunan mengikut peraturan import semasa. Sebagai contoh, jika ruang nama ABC diimport sebagai C, maka panggilan ke CDe() ditukar kepada ABCDe().

• Semua nama yang tidak layak dan layak (nama tidak layak sepenuhnya) ditukar pada masa penyusunan mengikut peraturan import semasa. Sebagai contoh, jika ruang nama aBC diimport sebagai C, panggilan ke CDe() akan ditukar kepada aBCDe().

• Nama kelas yang tidak layak ditukar pada masa penyusunan mengikut peraturan import semasa (menggantikan nama import pendek dengan nama penuh). Contohnya, jika ruang nama aBC diimport sebagai C, C() baharu akan ditukar kepada aBC() baharu.

• Dalam ruang nama (cth., ab), panggilan fungsi kepada nama yang tidak layak diselesaikan semasa masa jalan. Sebagai contoh, panggilan ke fungsi foo() dihuraikan seperti berikut:

• Mencari fungsi bernama ABfoo() dalam ruang nama semasa

• Cuba cari dan panggil function foo() dalam ruang global.

• Panggilan kepada nama yang tidak layak atau kelas nama yang layak (nama tidak layak sepenuhnya) dalam ruang nama (seperti ab) diselesaikan pada masa jalan. Berikut ialah proses penghuraian untuk memanggil new c() dan new de(): Parse new c():

• Cari kelas ABC dalam ruang nama semasa.

• Cuba muatkan kelas ABC secara automatik.

• Penghuraian DE():

• Menambah nama ruang nama semasa di hadapan nama kelas menjadi: ABDE dan kemudian cari kelas.

• Cuba muatkan kelas ABDE secara automatik.

• Untuk merujuk kepada kelas global dalam ruang nama global, nama C() baharu yang layak sepenuhnya mesti digunakan.

Itu sahaja jika anda ingin tahu apa-apa lagi, anda boleh klik di sini. → →

tutorial video php

Atas ialah kandungan terperinci Editor akan mengajar anda urutan panggilan ruang nama. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!