Vollständige Nutzung des PHP-Befehlsraums

Wir wissen, dass einer der klarsten Zwecke des Namespace darin besteht, das Problem doppelter Namen zu lösen. Daher dürfen in PHP zwei Funktionen oder Klassen nicht denselben Namen haben, da andernfalls ein schwerwiegender Fehler auftritt geschehen. . In diesem Fall kann das Problem gelöst werden, solange Sie eine doppelte Benennung vermeiden. Die häufigste Methode besteht darin, sich auf ein Präfix zu einigen.

Der Zweck der Verwendung von Namespace:

Bei der Arbeit in einem Team Vermeiden Sie bei der Arbeit an einem Projekt Konflikte mit Klassen, die von anderen Teammitgliedern erstellt wurden, wenn Einzelpersonen sind für das Projekt verantwortlich, vermeiden Sie es, vorher und nachher neue Klassen zu erstellen.

Nach meinem persönlichen Verständnis muss die erforderliche Klasse zuerst durch „require“ oder „include“ eingeführt werden Die Voraussetzung für das Auftreten eines Klassenneudefinitionsfehlers ist: Es wurden zwei Klassen mit demselben Namen eingeführt. Derzeit laden einige PHP-Frameworks alle neuen Modellklassen automatisch (d. h. schließen sie ein). Um Namenskonflikte zwischen Ihren neuen Modellklassen und den nativen Kernklassen des Projekt-Frameworks zu vermeiden, wird daher ein Namespace verwendet. (Nachdem man darüber nachgedacht hat, sollten Konflikte mit neuen Klassen, die von Teammitgliedern erstellt wurden, durch Kommunikation vermieden werden. Auch nach dem Vorfall sollte der Klassenname sofort neu angepasst und beibehalten werden, um eine erhöhte Wartungskomplexität zu vermeiden, die später durch Verwirrung im Verständnis der Klasse verursacht wird. )

Kombiniert mit den Verwendungsmethoden, um seinen Zweck besser zu verstehen.

So verwenden Sie den Namespace:

Zum Testen erstelle ich drei Dateien: 1.php und name.php (diese Datei wird zum Testen verwendet), die später nicht erläutert werden. Bitte beachten Sie, dass sich der Code selbst ändert.

1. Bei der Definition des Namens nach dem Namespace wird die Groß-/Kleinschreibung nicht beachtet.

Namespace eins; (Ich werde im folgenden Code die erste Methode zum Testen verwenden)

2. Wenn kein Namespace definiert ist, wird davon ausgegangen, dass der Namespace der obersten Ebene verwendet wird. Beim Erstellen einer neuen Klasse können Sie vor der Klasse einen Backslash hinzufügen oder nicht.

3. Beim Hinzufügen eines Namespace zu einer neuen Klasse müssen Backslash-Zeichen anstelle von Schrägstrichen verwendet werden.

Speichermethode: Finden Sie die Schrägstriche in % in der Reihenfolge, um sie als Schrägstriche zu verstehen. (Wenn ich über Backslashes spreche, weiß ich manchmal nicht einmal, welche Richtung es ist. Früher habe ich mich daran erinnert, dass die Richtung von links nach rechts aufsteigend ist, aber jetzt habe ich das Gefühl, dass das zu unzuverlässig ist)

//1.php
class Person{
 function construct(){
  echo 'I am one!';
 }
}
//name.php
require_once './1.php';
new Person(); //输出 I am one!;
new \Person(); //输出 I am one!;

4. Kategorie Unter dem angegebenen Namespace muss bei der neuen Klasse unbedingt der angegebene Namespace mitgebracht werden.

bringt den angegebenen Namespace nicht mit, PHP findet diese Klasse aus dem Top-Level-Namespace. Denken Sie daran: Dies kann nicht verstanden werden, da der Namespace der obersten Ebene alle anderen Namespaces umfasst. Stattdessen sollten Namespaces der obersten Ebene vollständig von anderen Namespaces getrennt sein.

//name.php
require_once './1.php';
new /Person(); // 代码报错：Parse error: syntax error, unexpected '/'

Sie können dieses beliebte Beispiel verwenden, um zu verstehen: Das Nehmen des angegebenen Namespace stellt die Äpfel einer Person (in seiner Hand) dar, und der Namespace der obersten Ebene stellt die Äpfel in der Apfelbox (in der Box) dar. Wenn Sie nun den Apfel einer anderen Person finden möchten, müssen Sie den Namensraum einer anderen Person mitbringen. Andernfalls suchen Sie den Apfel einer anderen Person aus der Kiste und können ihn natürlich nicht finden.

5. Der Code nach der Namespace-Deklaration gehört zu diesem Namespace, selbst wenn include oder require vorhanden ist, wird er nicht beeinflusst (der Schwerpunkt liegt auf dem Verständnis der zweiten Satzhälfte, siehe Code). für Einzelheiten).

/1.php
namespace one;
class Person{
 function construct(){
  echo 'I am one!';
 }
}
//name.php
require_once './1.php';
new \one\Person(); //输出 I am one!;
new \Person(); //代码报错：Fatal error: Class 'Person' not found

Die letzte Zeile führt zu einem Fehler:

Vergleichen Sie dies zunächst mit Punkt 2:

//1.php
namespace one;
class Person{
 function construct(){
  echo 'I am one!';
 }
}
//name.php
namespace test;
require './1.php';
new \one\Person(); //输出 I am one!;
new Person(); //这里结果会是什么呢，猜猜看

Punkt 2, sagte ich, als ich dort war ist kein Namespace. In der neuen Klasse ist die Bedeutung dieselbe, unabhängig davon, ob ein Backslash vorhanden ist oder nicht.

Fatal error: Class 'test\Person' not found

Beim Namespace ist die Bedeutung von Backslashes unterschiedlich. Ersetzen Sie die letzte Zeile von

durch

und das Ergebnis ist ein Fehler:

Als Nächstes sprechen wir über den aktuellen Punkt.

new \Person();

Wir können feststellen, dass der Namespace, der der letzten Codezeile entspricht, ein Test ist und nicht vom Namespace in der Anforderungsdatei betroffen ist.

Fatal error: Class 'Person' not found

Um die Überprüfung weiter zu stärken, habe ich die Datei name.php wie folgt geändert:

Schließlich hat dieses Beispiel mein Verständnis von require aufgefrischt.

Nach meinem bisherigen Verständnis von require: Bevor das PHP-Programm ausgeführt wird, liest es zunächst die durch require angegebene Datei ein und macht sie so zu einem Teil der PHP-Programm-Webseite. Deshalb verstehe ich es oft einfach als Ersatz, bei dem der extrahierte Code einfach wieder an seinen ursprünglichen Platz zurückgebracht wird. Dann habe ich versucht, den Inhalt der 1.php-Datei in name.php einzufügen:

//name.php
namespace test;
require './1.php';
class Person{
 function construct(){
  echo 'I am test!';
 }
}
new \one\Person(); //输出 I am one!;
new Person(); //这里结果会是什么，自己猜猜看

Ohne die neue Klasse meldet die Datei einen Fehler:

Schwerwiegender Fehler: Neudeklaration nicht möglich Klasse einsPerson

//name.php
namespace test;
namespace one;
class Person{
 function construct(){
  echo 'I am one!';
 }
}
class Person{
 function construct(){
  echo 'I am test!';
 }
}

Es scheint, dass das bloße Verstehen von require als Ersatz hier nicht funktioniert.

6. Der Namespace enthält nicht den Klassennamen. Auch wenn es einen Teil mit demselben Namen wie den Klassennamen gibt, repräsentiert er nicht die Klasse. Neue Klasse, diesen Teil musst du noch mitbringen.

}new testpersonPerson(); //person kann den Klassennamen nicht im Namespace darstellen

Aber das ist völlig überflüssig, schließen Sie den Klassennamen einfach nicht in den Namespace ein.

//name.php
namespace test\person;
class Person{
 function construct(){
  echo 'I am test!';
 }

7. In einer PHP-Datei können mehrere Namespaces vorhanden sein, und vor dem ersten Namespace darf kein Code vorhanden sein.

Es heißt lediglich, dass vor dem ersten Namespace kein Code vorhanden sein darf und dass vor nachfolgenden Namespaces Code vorhanden sein kann. Sie können dies selbst testen.

//name.php
namespace test;
echo 'zhai14';
namespace zhai;
require './1.php';

PHP-Namespace

Der Namespace ist zu Ende. Lassen Sie uns über die Verwendung sprechen.

使用use的目的：

在命名空间字符串过长时，使用use可以相应的缩短命名空间。

use的使用方法：

1.new类时，最前面无需用反斜杠。此外，use后没有as时，缩短的命名空间默认为最后一个反斜杠后的内容。

//name.php
namespace animal\dog;
class Life{
 function construct(){
  echo 'dog life!';
 }
}
namespace animal\cat;
class Life{
 function construct(){
  echo 'cat life!';
 }
}
new Life(); //按照代码执行顺序，这里默认animal\cat这个命名空间
new \animal\dog\Life(); //A
use animal\dog; //a
new dog\Life(); //B
use animal\dog as d; //b
new d\Life();

 通过A、B行代码比较，需要注意：

使用use后，new类时，最前面没有反斜杠。

没使用use时，命名空间最前面有反斜杠

通过a、b行代码比较，可以理解：

use后没有as时，缩短的命名空间默认为最后一个反斜杠后的内容。如上的:

use animal\dog;

相当于

use animal\dog as dog;

2.namespace后面不建议加类名，但use后可以。

//name.php
namespace animal\dog;
class Life{
 function construct(){
  echo 'dog life!';
 }
}
namespace animal\cat;
class Life{
 function construct(){
  echo 'cat life!';
 }
}
use animal\dog\Life as dog;
new dog();

如上所示，use后加上类名后，就相当于把类改了个名称：由Life改为dog了。

上面不用as dog就会报错：

Fatal error:  Cannot use animal\dog\Life as Life because the name is already in use

因为cat下也有个一样名称的Life类。

可以理解为，使用use后，这个昵称对应的类只能归当前命名空间占有，其它命名空间下不允许存在该类。

//name.php
namespace animal\dog;
class Life{
 function construct(){
  echo 'dog life!';
 }
}
class Dog{
 function construct(){
  echo 'dog in dog!';
 }
}
namespace animal\cat;
// class Dog{
// function construct(){
//  echo 'dog in cat!';
//  }
// }
class Life{
 function construct(){
  echo 'cat life!';
 }
}
use animal\dog;
new dog\Dog();

如上，使用了

use animal\dog;
 cat

通过上面代码，我想使用use的目的效果（缩短命名空间名称）就很明显了。

简单总结一下：

namespace就是划分领域的作用，代表这些东西是属于某个命名空间下的。

相信看了这些案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

相关阅读：

php自定义函数生成笛卡尔积的方法

PHP自定义函数生成笛卡尔积

多个数组求笛卡尔积

Das obige ist der detaillierte Inhalt vonVollständige Nutzung des PHP-Befehlsraums. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!