Cet article est une analyse détaillée et une introduction à plusieurs méthodes d'utilisation des variables globales en PHP. Les amis dans le besoin peuvent s'y référer
Introduction
Même si vous développez un nouveau programme PHP à grande échelle, vous utiliserez inévitablement des données globales, car certaines données doivent être utilisées dans différentes parties de votre code. Certaines données globales courantes incluent : les classes de paramètres de programme, les classes de connexion à la base de données, les informations utilisateur, etc. Il existe de nombreuses façons de rendre ces données globales, la plus couramment utilisée étant d'utiliser la déclaration de mot-clé « global », que nous expliquerons en détail plus loin dans l'article.
Le seul inconvénient de l'utilisation du mot-clé "global" pour déclarer des données globales est qu'il s'agit en fait d'une très mauvaise méthode de programmation, et conduit souvent à des problèmes plus importants dans le programme plus tard, car les données globales vous mettent dans le code d'origine. des segments de code distincts sont tous liés entre eux. La conséquence est que si vous modifiez une partie du code, d'autres parties peuvent mal fonctionner. Ainsi, s’il existe de nombreuses variables globales dans votre code, l’ensemble de votre programme sera difficile à maintenir.
Cet article montrera comment éviter ce problème de variable globale grâce à différentes techniques ou modèles de conception. Bien sûr, voyons d'abord comment utiliser le mot-clé « global » pour les données globales et comment il fonctionne.
Utilisez des variables globales et le mot-clé "global"
PHP définit par défaut certaines variables "Superglobals", qui sont automatiquement globalisées et peuvent être utilisées n'importe où dans le programme. , comme $_GET et $_REQUEST, etc. Elles proviennent généralement de données ou d'autres données externes, et l'utilisation de ces variables ne pose généralement pas de problèmes car elles ne sont fondamentalement pas accessibles en écriture.
Mais vous pouvez utiliser vos propres variables globales. En utilisant le mot-clé « global », vous pouvez importer des données globales dans la portée locale d'une fonction. Si vous ne comprenez pas le « portée d'utilisation variable », veuillez vous référer aux instructions pertinentes dans le manuel PHP.
Voici un exemple de démonstration utilisant le mot-clé "global" :
Le code est le suivant :
<?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;
}
?>Copier après la connexion
Comme vous l'avez dans le exemple ci-dessus Comme vous pouvez le constater, le mot-clé "global" est utilisé pour importer des variables globales. Cela semble bien fonctionner et c'est simple, alors pourquoi nous soucions-nous d'utiliser le mot-clé « global » pour définir des données globales ?
Voici trois bonnes raisons :
1. La réutilisation du code est presque impossible.
Si une fonction dépend de variables globales, il est quasiment impossible d'utiliser cette fonction dans différents environnements. Un autre problème est que vous ne pouvez pas extraire cette fonction et l'utiliser dans un autre code.
2. Le débogage et la résolution des problèmes sont très difficiles.
Tracer une variable globale est beaucoup plus difficile que suivre une variable non globale. Une variable globale peut être redéfinie dans un fichier d'inclusion obscur, et même si vous disposez d'un très bon éditeur de programme (ou IDE) pour vous aider, cela peut vous prendre plusieurs heures pour découvrir le problème.
3. Il sera très difficile de comprendre ces codes.
Il vous est difficile de comprendre d'où vient une variable globale et à quoi elle sert. Au cours du processus de développement, vous connaîtrez peut-être toutes les variables globales, mais après environ un an, vous risquez d'en oublier au moins certaines. À ce stade, vous regretterez d'avoir utilisé autant de variables globales.
Donc, si nous n’utilisons pas de variables globales, que devons-nous utiliser ? Examinons quelques solutions ci-dessous.
Utilisation des paramètres de fonction
Une façon d'arrêter d'utiliser des variables globales consiste simplement à transmettre la variable en tant que paramètre de fonction, comme indiqué ci-dessous :
Code comme suit :
<?php
$var = 'Hello World';
test ($var);
function test($var) {
echo $var;
}
?>Copier après la connexion
Si vous n'avez besoin de transmettre qu'une variable globale, alors c'est une très bonne solution, voire une excellente, mais que se passe-t-il si vous souhaitez transmettre plusieurs valeurs ?
Par exemple, si nous voulons utiliser une classe de base de données, une classe de paramètres de programme et une classe d'utilisateurs. Dans notre code, ces trois classes sont utilisées dans tous les composants, elles doivent donc être transmises à chaque composant. Si nous utilisons la méthode des paramètres de fonction, nous devons faire ceci :
Le code est le suivant :
<?php
$db = new DBConnection;
$settings = new Settings_XML;
$user = new User;
test($db, $settings, $user);
function test(&$db, &$settings, &$user) {
// Do something
}
?>Copier après la connexion
Évidemment, cela n'en vaut pas la peine, et une fois que nous avons de nouveaux objets à ajouter, nous devons ajouter un paramètre de fonction supplémentaire à chaque fonction. Nous devons donc utiliser un autre moyen pour le résoudre.
Utiliser des Singletons Une façon de résoudre le problème des paramètres de fonction consiste à utiliser des Singletons pour remplacer les paramètres de fonction. Les singletons sont une classe spéciale d'objets qui ne peuvent être instanciés qu'une seule fois et contiennent une méthode statique qui renvoie l'interface de l'objet. L'exemple suivant montre comment construit un singleton simple :
代码如下:
<?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
}
}
?>Copier après la connexion
上面例子中最重要的部分是函数getInstance()。这个函数通过使用一个静态变量$me来返回这个类的实例，从而确保了只有一个DBConnection类的实例。
使用单件的好处就是我们不需要明确的传递一个对象，而是简单的使用getInstance()方法来获取到这个对象，就好像下面这样：
代码如下:
<?php
function test() {
$db = DBConnection::getInstance();
// Do something with the object
}
?>Copier après la connexion
然而使用单件也存在一系列的不足。首先，如果我们如何在一个类需要全局化多个对象呢？因为我们使用单件，所以这个不可能的（正如它的名字是单件一样）。另外一个问题，单件不能使用个体测试来测试的，而且这也是完全不可能的，除非你引入所有的堆栈，而这显然是你不想看到的。这也是为什么单件不是我们理想中的解决方法的主要原因。
注册模式
让一些对象能够被我们代码中所有的组件使用到（译者注：全局化对象或者数据）的最好的方法就是使用一个中央容器对象，用它来包含我们所有的对象。通常这种容器对象被人们称为一个注册器。它非常的灵活而且也非常的简单。一个简单的注册器对象就如下所示：
代码如下:
<?php
Class Registry {
var $_objects = array();
function set($name, &$object) {
$this->_objects[$name] =& $object;
}
function &get($name) {
return $this->_objects[$name];
}
}
?>Copier après la connexion
使用注册器对象的第一步就是使用方法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);
?>
Copier après la connexion
现在我们的寄存器对象容纳了我们所有的对象，我们指需要把这个注册器对象传递给一个函数（而不是分别传递三个对象）。看下面的例子：
代码如下:
<?php
function test(&$registry) {
$db =& $registry->get('db');
$settings =& $registry->get('settings');
$user =& $registry->get('user');
// Do something with the objects
}
?>Copier après la connexion
注册器相比其他的方法来说，它的一个很大的改进就是当我们需要在我们的代码中新增加一个对象的时候，我们不再需要改变所有的东西（译者注：指程序中所有用到全局对象的代码），我们只需要在注册器里面新注册一个对象，然后它（译者注：新注册的对象）就立即可以在所有的组件中调用。
为了更加容易的使用注册器，我们把它的调用改成单件模式（译者注：不使用前面提到的函数传递）。因为在我们的程序中只需要使用一个注册器，所以单件模式使非常适合这种任务的。在注册器类里面增加一个新的方法，如下所示：
代码如下:
<?
function &getInstance() {
static $me;
if (is_object($me) == true) {
return $me;
}
$me = new Registry;
return $me;
}
?>Copier après la connexion
这样它就可以作为一个单件来使用，比如：
代码如下:
<?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
}
?>Copier après la connexion
正如你看到的，我们不需要把私有的东西都传递到一个函数，也不需要使用“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];
}
}
?>Copier après la connexion
上面的例子是一个简单的演示，当然在请求封装器（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'));
}
?>Copier après la connexion
正如你看到的，现在我们不再依靠任何全局变量了，而且我们完全让这些函数远离了全局变量。
结论
在本文中，我们演示了如何从根本上移除代码中的全局变量，而相应的用合适的函数和变量来替代。注册模式是我最喜欢的设计模式之一，因为它是非常的灵活，而且它能够防止你的代码变得一塌糊涂。
另外，我推荐使用函数参数而不是单件模式来传递注册器对象。虽然使用单件更加轻松，但是它可能会在以后出现一些问题，而且使用函数参数来传递也更加容易被人理解。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
