Dieser Artikel ist eine detaillierte Analyse und Einführung in verschiedene Methoden zur Verwendung globaler Variablen in PHP. Freunde in Not können darauf verweisen
Einführung
Selbst wenn Sie ein neues umfangreiches PHP-Programm entwickeln, werden Sie zwangsläufig globale Daten verwenden, da einige Daten in verschiedenen Teilen Ihres Codes verwendet werden müssen. Zu den allgemeinen globalen Daten gehören: Programmeinstellungsklassen, Datenbankverbindungsklassen, Benutzerinformationen usw. Es gibt viele Möglichkeiten, diese Daten zu globalen Daten zu machen. Die am häufigsten verwendete Methode ist die Verwendung der Schlüsselwortdeklaration „global“, die wir später in diesem Artikel ausführlich erläutern werden.
Der einzige Nachteil der Verwendung des Schlüsselworts „global“ zum Deklarieren globaler Daten besteht darin, dass es sich tatsächlich um eine sehr schlechte Programmiermethode handelt, die später oft zu größeren Problemen im Programm führt, da globale Daten Sie in den Code einbinden Das Original Die einzelnen Codesegmente sind alle miteinander verknüpft. Wenn Sie einen Teil des Codes ändern, kann dies dazu führen, dass andere Teile fehlerhaft werden. Wenn Ihr Code also viele globale Variablen enthält, ist die Wartung Ihres gesamten Programms schwierig.
In diesem Artikel wird gezeigt, wie dieses Problem mit globalen Variablen durch verschiedene Techniken oder Entwurfsmuster verhindert werden kann. Schauen wir uns natürlich zunächst an, wie das Schlüsselwort „global“ für globale Daten verwendet wird und wie es funktioniert.
Verwenden Sie globale Variablen und das Schlüsselwort „global“
PHP definiert standardmäßig einige „Superglobals“-Variablen, die automatisch globalisiert werden und überall im Programm aufgerufen werden können , wie $_GET und $_REQUEST usw. Sie stammen in der Regel aus Daten oder anderen externen Daten und die Verwendung dieser Variablen bereitet in der Regel keine Probleme, da sie grundsätzlich nicht beschreibbar sind.
Aber Sie können Ihre eigenen globalen Variablen verwenden. Mit dem Schlüsselwort „global“ können Sie globale Daten in den lokalen Gültigkeitsbereich einer Funktion importieren. Wenn Sie den „Variablennutzungsbereich“ nicht verstehen, lesen Sie bitte die entsprechenden Anweisungen im PHP-Handbuch.
Hier ist ein Demonstrationsbeispiel mit dem Schlüsselwort „global“:
Der Code lautet wie folgt:
<?php
$my_var = 'Hello World';
test_global();
function test_global() {
// Now in local scope
// the $my_var variable doesn't exist
// Produces error: "Undefined variable: my_var"
echo $my_var;
// Now let's important the variable
global $my_var;
// Works:
echo $my_var;
}
?>Wie Sie im haben Beispiel oben Wie Sie sehen können, wird das Schlüsselwort „global“ zum Importieren globaler Variablen verwendet. Es sieht so aus, als ob es gut funktioniert und einfach ist. Warum machen wir uns also Gedanken darüber, das Schlüsselwort „global“ zum Definieren globaler Daten zu verwenden?
Hier sind drei gute Gründe:
1. Die Wiederverwendung von Code ist nahezu unmöglich.
Wenn eine Funktion von globalen Variablen abhängt, ist es nahezu unmöglich, diese Funktion in verschiedenen Umgebungen zu verwenden. Ein weiteres Problem besteht darin, dass Sie diese Funktion nicht extrahieren und in anderem Code verwenden können.
2. Das Debuggen und Lösen von Problemen ist sehr schwierig.
Das Verfolgen einer globalen Variablen ist viel schwieriger als das Verfolgen einer nicht-globalen Variablen. Eine globale Variable kann in einer unbekannten Include-Datei neu definiert werden, und selbst wenn Sie über einen sehr guten Programmeditor (oder eine IDE) verfügen, der Ihnen hilft, kann es mehrere Stunden dauern, bis Sie das Problem entdecken.
3. Es wird sehr schwierig sein, diese Codes zu verstehen.
Es ist für Sie schwierig herauszufinden, woher eine globale Variable kommt und wofür sie verwendet wird. Während des Entwicklungsprozesses kennen Sie möglicherweise alle globalen Variablen, aber nach etwa einem Jahr vergessen Sie möglicherweise zumindest einige davon. Zu diesem Zeitpunkt werden Sie es bereuen, so viele globale Variablen verwendet zu haben.
Was sollten wir also verwenden, wenn wir keine globalen Variablen verwenden? Schauen wir uns unten einige Lösungen an.
Funktionsparameter verwenden
Eine Möglichkeit, die Verwendung globaler Variablen zu beenden, besteht darin, die Variable einfach als Funktionsparameter zu übergeben, wie unten gezeigt:
Code wie folgt:
<?php
$var = 'Hello World';
test ($var);
function test($var) {
echo $var;
}
?>Wenn Sie nur eine globale Variable übergeben müssen, dann ist dies eine sehr gute oder sogar hervorragende Lösung, aber was ist, wenn Sie viele Werte übergeben möchten?
Wenn wir beispielsweise eine Datenbankklasse, eine Programmeinstellungsklasse und eine Benutzerklasse verwenden möchten. In unserem Code werden diese drei Klassen in allen Komponenten verwendet und müssen daher an jede Komponente übergeben werden. Wenn wir die Funktionsparametermethode verwenden, müssen wir Folgendes tun:
Der Code lautet wie folgt:
<?php
$db = new DBConnection;
$settings = new Settings_XML;
$user = new User;
test($db, $settings, $user);
function test(&$db, &$settings, &$user) {
// Do something
}
?>
Offensichtlich das lohnt sich nicht, und sobald wir neue Objekte hinzufügen müssen, müssen wir jeder Funktion einen weiteren Funktionsparameter hinzufügen. Wir müssen also einen anderen Weg finden, um es zu lösen.
Singletons verwenden Eine Möglichkeit, das Problem der Funktionsparameter zu lösen, besteht darin, Singletons zum Ersetzen von Funktionsparametern zu verwenden. Singletons sind eine spezielle Klasse von Objekten, die nur einmal instanziiert werden können und eine statische Methode enthalten, die die Schnittstelle des Objekts zurückgibt. Das folgende Beispiel zeigt, wie einen einfachen Singleton erstellt:
代码如下:
<?php
// Get instance of DBConnection
$db =& DBConnection::getInstance();
// Set user property on object
$db->user = 'sa';
// Set second variable (which points to the same instance)
$second =& DBConnection::getInstance();
// Should print 'sa'
echo $second->user;
Class DBConnection {
var $user;
function &getInstance() {
static $me;
if (is_object($me) == true) {
return $me;
}
$me = new DBConnection;
return $me;
}
function connect() {
// TODO
}
function query() {
// TODO
}
}
?>
上面例子中最重要的部分是函数getInstance()。这个函数通过使用一个静态变量$me来返回这个类的实例，从而确保了只有一个DBConnection类的实例。
使用单件的好处就是我们不需要明确的传递一个对象，而是简单的使用getInstance()方法来获取到这个对象，就好像下面这样：
代码如下:
<?php
function test() {
$db = DBConnection::getInstance();
// Do something with the object
}
?>
然而使用单件也存在一系列的不足。首先，如果我们如何在一个类需要全局化多个对象呢？因为我们使用单件，所以这个不可能的（正如它的名字是单件一样）。另外一个问题，单件不能使用个体测试来测试的，而且这也是完全不可能的，除非你引入所有的堆栈，而这显然是你不想看到的。这也是为什么单件不是我们理想中的解决方法的主要原因。
注册模式
让一些对象能够被我们代码中所有的组件使用到（译者注：全局化对象或者数据）的最好的方法就是使用一个中央容器对象，用它来包含我们所有的对象。通常这种容器对象被人们称为一个注册器。它非常的灵活而且也非常的简单。一个简单的注册器对象就如下所示：
代码如下:
<?php
Class Registry {
var $_objects = array();
function set($name, &$object) {
$this->_objects[$name] =& $object;
}
function &get($name) {
return $this->_objects[$name];
}
}
?>使用注册器对象的第一步就是使用方法set()来注册一个对象：
代码如下:
<?php $db = new DBConnection; $settings = new Settings_XML; $user = new User; // Register objects $registry =& new Registry; $registry->set ('db', $db); $registry->set ('settings', $settings); $registry->set ('user', $user); ?>
现在我们的寄存器对象容纳了我们所有的对象，我们指需要把这个注册器对象传递给一个函数（而不是分别传递三个对象）。看下面的例子：
代码如下:
<?php
function test(&$registry) {
$db =& $registry->get('db');
$settings =& $registry->get('settings');
$user =& $registry->get('user');
// Do something with the objects
}
?>注册器相比其他的方法来说，它的一个很大的改进就是当我们需要在我们的代码中新增加一个对象的时候，我们不再需要改变所有的东西（译者注：指程序中所有用到全局对象的代码），我们只需要在注册器里面新注册一个对象，然后它（译者注：新注册的对象）就立即可以在所有的组件中调用。
为了更加容易的使用注册器，我们把它的调用改成单件模式（译者注：不使用前面提到的函数传递）。因为在我们的程序中只需要使用一个注册器，所以单件模式使非常适合这种任务的。在注册器类里面增加一个新的方法，如下所示：
代码如下:
<?
function &getInstance() {
static $me;
if (is_object($me) == true) {
return $me;
}
$me = new Registry;
return $me;
}
?>这样它就可以作为一个单件来使用，比如：
代码如下:
<?php
$db = new DBConnection;
$settings = new Settings_XML;
$user = new User;
// Register objects
$registry =& Registry::getInstance();
$registry->set ('db', $db);
$registry->set ('settings', $settings);
$registry->set ('user', $user);
function test() {
$registry =& Registry::getInstance();
$db =& $registry->get('db');
$settings =& $registry->get('settings');
$user =& $registry->get('user');
// Do something with the objects
}
?>正如你看到的，我们不需要把私有的东西都传递到一个函数，也不需要使用“global”关键字。所以注册器模式是这个问题的理想解决方案，而且它非常的灵活。
请求封装器
虽然我们的注册器已经使“global”关键字完全多余了，在我们的代码中还是存在一种类型的全局变量：超级全局变量，比如变量$_POST,$_GET。虽然这些变量都非常标准，而且在你使用中也不会出什么问题，但是在某些情况下，你可能同样需要使用注册器来封装它们。
一个简单的解决方法就是写一个类来提供获取这些变量的接口。这通常被称为“请求封装器”，下面是一个简单的例子：
代码如下:
<?php
Class Request {
var $_request = array();
function Request() {
// Get request variables
$this->_request = $_REQUEST;
}
function get($name) {
return $this->_request[$name];
}
}
?>上面的例子是一个简单的演示，当然在请求封装器（request wrapper）里面你还可以做很多其他的事情（比如：自动过滤数据，提供默认值等等）。
下面的代码演示了如何调用一个请求封装器：
代码如下:
<?php
$request = new Request;
// Register object
$registry =& Registry::getInstance();
$registry->set ('request', &$request);
test();
function test() {
$registry =& Registry::getInstance();
$request =& $registry->get ('request');
// Print the 'name' querystring, normally it'd be $_GET['name']
echo htmlentities($request->get('name'));
}
?>正如你看到的，现在我们不再依靠任何全局变量了，而且我们完全让这些函数远离了全局变量。
结论
在本文中，我们演示了如何从根本上移除代码中的全局变量，而相应的用合适的函数和变量来替代。注册模式是我最喜欢的设计模式之一，因为它是非常的灵活，而且它能够防止你的代码变得一塌糊涂。
另外，我推荐使用函数参数而不是单件模式来传递注册器对象。虽然使用单件更加轻松，但是它可能会在以后出现一些问题，而且使用函数参数来传递也更加容易被人理解。
Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung zur Verwendung globaler Variablen in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
So öffnen Sie eine PHP-Datei
So entfernen Sie die ersten paar Elemente eines Arrays in PHP
Was tun, wenn die PHP-Deserialisierung fehlschlägt?
So verbinden Sie PHP mit der MSSQL-Datenbank
So verbinden Sie PHP mit der MSSQL-Datenbank
So laden Sie HTML hoch
So lösen Sie verstümmelte Zeichen in PHP
So öffnen Sie PHP-Dateien auf einem Mobiltelefon
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
