Qu’est-ce que la portée des variables php ?

Cet article est une analyse détaillée et une introduction à la portée des variables PHP. Les amis qui en ont besoin peuvent s'y référer

Chaque variable en PHP a une portée, ce qui signifie qu'elle peut être un champ dans lequel on accède à une variable (et donc à sa valeur). Pour commencer, la portée des variables est la page sur laquelle elles résident. Par conséquent, si vous définissez $var, le reste de la page peut accéder à $var, mais les autres pages ne peuvent généralement pas y accéder (sauf si des variables spéciales sont utilisées).

Étant donné que les fichiers inclus fonctionnent comme s'ils faisaient partie du script original (inclus), les variables définies avant la ligne include() sont disponibles pour les fichiers inclus. De plus, les variables définies dans le fichier d'inclusion sont disponibles pour le script parent (include) après la ligne include().

Tout cela deviendra moins évident lorsque vous utiliserez vos propres fonctions définies. Ces fonctions ont leur propre portée, ce qui signifie que les variables utilisées dans une fonction ne peuvent pas être utilisées en dehors de celle-ci et que les variables définies en dehors d'une fonction ne peuvent pas être utilisées à l'intérieur de celle-ci. Pour cette raison, les variables à l’intérieur d’une fonction peuvent avoir le même nom que les variables à l’extérieur, mais ce sont toujours des variables complètement différentes avec des valeurs différentes. C'est un concept déroutant pour la plupart des programmeurs débutants.
Pour modifier la portée des variables au sein d'une fonction, vous pouvez utiliser l'instruction globale.

Le code est le suivant :

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function function_name() {
    global $var;
}
$var=20;
function_name(); // Function call.
?>

Dans cet exemple, $var à l'intérieur de la fonction est maintenant le même que $var à l'extérieur de la fonction. Cela signifie que la variable $var a déjà une valeur de 20, et si cette valeur est modifiée à l'intérieur de la fonction, la valeur de $var à l'extérieur changera également.
Une autre façon d'éviter la portée des variables est d'utiliser des variables superglobales : $_GET, $_POST, $_REQUEST, etc. Ces variables sont automatiquement accessibles au sein de votre fonction (ce sont donc des variables superglobales). Vous pouvez également ajouter des éléments au tableau $GLOBALS afin qu'ils puissent être utilisés dans les fonctions.

En d’autres termes, il est préférable de ne pas utiliser de variables globales dans les fonctions. Lors de la conception de fonctions, vous devez leur faire accepter chaque valeur comme paramètre selon les besoins et renvoyer n'importe quelle valeur selon les besoins. S'appuyer sur des variables globales au sein des fonctions les rendrait plus dépendantes du contexte et donc moins utiles.
Les variables en PHP incluent principalement : les variables super globales intégrées, les variables générales, les constantes, les variables globales, les variables statiques, etc.

Les variables super globales intégrées peuvent être utilisées et visibles n'importe où dans le script . Autrement dit, si nous modifions l'une des valeurs d'une page PHP, sa valeur changera également lorsqu'elle sera utilisée dans d'autres pages PHP.

• Une fois déclarées, les constantes seront globalement visibles, c'est-à-dire qu'elles pourront être utilisées à l'intérieur et à l'extérieur des fonctions, mais cela n'est limité qu'aux scripts PHP inclus dans une page (y compris les scripts PHP que nous incluons via include et include_once ), mais il ne peut pas être utilisé dans d’autres pages.
•Les variables globales déclarées dans un script sont visibles dans tout le script, mais pas à l'intérieur de la fonction. Si la variable à l'intérieur de la fonction a le même nom que la variable globale, la variable à l'intérieur de la fonction prévaudra.
•Lorsqu'une variable utilisée à l'intérieur d'une fonction est déclarée comme variable globale, son nom doit être cohérent avec le nom de la variable globale. Dans ce cas, on peut utiliser la variable globale en dehors de la fonction . dans la fonction, cela peut éviter la situation précédente où la variable externe est écrasée car la variable à l'intérieur de la fonction a le même nom que la variable globale externe.
•Les variables créées et déclarées comme statiques à l'intérieur d'une fonction ne peuvent pas être visibles à l'extérieur de la fonction, mais la valeur peut être conservée lors de plusieurs exécutions de la fonction. Le cas le plus courant est lors de l'exécution récursive de la fonction.
•Les variables créées à l'intérieur d'une fonction sont locales à la fonction et cessent d'exister lorsque la fonction se termine.
La liste complète des variables super globales est la suivante :
•.$GOBALS Tableau de toutes les variables globales
•.$_SERVER Tableau de variables d'environnement du serveur
•. $_POST Tableau de variables transmis au script via la méthode POST
•.$_GET Tableau de variables transmis au script via la méthode GET
•.$_Tableau de variables de cookie COOKIE
•.$ _FILES Lié au téléchargement de fichiers Tableau de variables
•.$_ENV Tableau de variables d'environnement
•.$_REQUEST Tableau de variables saisi par tous les utilisateurs, y compris le contenu d'entrée contenu dans $_GET $_POST $_COOKIE
•.$_SESSION Variable de session array
Explication de l'instance :

Le code est le suivant :

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php 
   $a = 4;
   function sendValue($x)
     {
        echo $x;
     }
    sendValue($a);
?>

Explication : $a est défini en dehors de la fonction, la fonction définit paramètres, et lorsque la fonction est appelée, $a sera passé en paramètre. Le code ci-dessus peut donc s'exécuter normalement.

Le code est le suivant :

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php 
    $a = 4;
    function sendValue()
     {
       echo $a;
    }
    sendValue();
?>

讲解：当函数被调用时，$a不能以参数的形式被传递。所以上面代码不能够正常运行。
变量范围
变量的范围即它定义的上下文背景（译者:说白了，也就是它的生效范围）。大部分的 PHP 变量只有一个单独的范围。这个单独的范围跨度同样包含了 include 和 require 引入的文件。范例:

代码如下:

<?php
  $a = 1;
  include "b.inc";
?>

这里变量 $a 将会在包含文件 b.inc 中生效。但是，在用户自定义函数中，一个局部函数范围将被引入。任何用于函数内部的变量按缺省情况将被限制在局部函数范围内。范例：

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
$a = 1; /* global scope */
function Test()
{
   echo $a; /* reference to local scope variable */
}
Test();
?>

这个脚本不会有任何输出，因为 echo 语句引用了一个局部版本的变量 $a，而且在这个范围内，它并没有被赋值。你可能注意到 PHP 的全局变量和 C 语言有一点点不同，在 C 语言中，全局变量在函数中自动生效，除非被局部变量覆盖。这可能引起一些问题，有些人可能漫不经心的改变一个全局变量。PHP 中全局变量在函数中使用时必须申明为全局。
The global keyword
首先，一个使用 global 的例子：
例子 12-1. 使用 global

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
$a = 1;
$b = 2;
function Sum()
{
   global $a, $b;
   $b = $a + $b;
}
Sum();
echo $b;
?>

以上脚本的输出将是 "3"。在函数中申明了全局变量 $a 和 $b，任何变量的所有引用变量都会指向到全局变量。对于一个函数能够申明的全局变量的最大个数，PHP 没有限制。
在全局范围内访问变量的第二个办法，是用特殊的 PHP 自定义 $GLOBALS 数组。前面的例子可以写成：
例子 12-2. 使用 $GLOBALS 替代 global

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
$a = 1;
$b = 2;
function Sum()
{
   $GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
}
Sum();
echo $b;
?>

在 $GLOBALS 数组中，每一个变量为一个元素，键名对应变量名，值变量的内容。$GLOBALS 之所以在全局范围内存在，是因为 $GLOBALS 是一个超全局变量。以下范例显示了超全局变量的用处：
例子 12-3. 演示超全局变量和作用域的例子

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function test_global()
{
   // 大多数的
预定义变量
并不 "super"，它们需要用 &#39;global&#39; 关键字来使它们在函数的本地区域中有效。
   global $HTTP_POST_VARS;
   print $HTTP_POST_VARS[&#39;name&#39;];
   // Superglobals 在任何范围内都有效，它们并不需要 &#39;global&#39; 声明。Superglobals 是在 PHP 4.1.0 引入的。
   print $_POST[&#39;name&#39;];
}
?>

使用静态变量
变量范围的另一个重要特性是静态变量（static variable）。静态变量仅在局部函数域中存在，但当程序执行离开此作用域时，其值并不丢失。看看下面的例子：
例子 12-4. 演示需要静态变量的例子

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function Test ()
{
   $a = 0;
   echo $a;
   $a++;
}
?>

本函数没什么用处，因为每次调用时都会将 $a 的值设为 0 并输出 "0"。将变量加一的 $a++ 没有作用，因为一旦退出本函数则变量 $a 就不存在了。要写一个不会丢失本次计数值的计数函数，要将变量 $a 定义为静态的：
例子 12-5. 使用静态变量的例子

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function Test()
{
   static $a = 0;
   echo $a;
   $a++;
}
?>

现在，每次调用 Test() 函数都会输出 $a 的值并加一。
静态变量也提供了一种处理递归函数的方法。递归函数是一种调用自己的函数。写递归函数时要小心，因为可能会无穷递归下去。必须确保有充分的方法来中止递归。一下这个简单的函数递归计数到 10，使用静态变量 $count 来判断何时停止：
例子 12-6. 静态变量与递归函数

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function Test()
{
   static $count = 0;
   $count++;
   echo $count;
   if ($count < 10) {
   Test ();
   }
   $count--;
}
?>

注: 静态变量可以按照上面的例子声明。如果在声明中用表达式的结果对其赋值会导致解析错误。
例子 12-7. 声明静态变量

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function foo(){
   static $int = 0; // correct
   static $int = 1+2; // wrong (as it is an expression)
   static $int = sqrt(121); // wrong (as it is an expression too)
   $int++;
   echo $int;
}
?>

全局和静态变量的引用
在 Zend 引擎 1 代，驱动了 PHP4，对于变量的 static 和 global 定义是以 references 的方式实现的。例如，在一个函数域内部用 global 语句导入的一个真正的全局变量实际上是建立了一个到全局变量的引用。这有可能导致预料之外的行为，如以下例子所演示的：

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function test_global_ref() {
   global $obj;
   $obj = &new stdclass;
}
function test_global_noref() {
   global $obj;
   $obj = new stdclass;
}
test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>

执行以上例子会导致如下输出：

代码如下:

NULLobject(stdClass)(0) {}

类似的行为也适用于 static 语句。引用并不是静态地存储的：

代码如下:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function &get_instance_ref() {
   static $obj;
   echo "Static object: ";
   var_dump($obj);
   if (!isset($obj)) {
   // 将一个引用赋值给静态变量
   $obj = &new stdclass;
   }
   $obj->property++;
   return $obj;
}
function &get_instance_noref() {
   static $obj;
   echo "Static object: ";
   var_dump($obj);
   if (!isset($obj)) {
   // 将一个对象赋值给静态变量
   $obj = new stdclass;
   }
   $obj->property++;
   return $obj;
}
$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>

执行以上例子会导致如下输出：

代码如下:

Static object: NULLStatic object: NULLStatic object: NULLStatic object: object(stdClass)(1) { ["property"]=> int(1)}

上例演示了当把一个引用赋值给一个静态变量时，第二次调用 &get_instance_ref() 函数时其值并没有被记住。

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!