Dieser Artikel ist eine detaillierte Analyse und Einführung in den PHP-Variablenbereich. Freunde, die ihn benötigen, können darauf verweisen.
Jede Variable in PHP hat einen Bereich dafür, was bedeutet, dass sie ein Feld sein kann, in dem Auf eine Variable (und damit auf ihren Wert) wird zugegriffen. Zunächst einmal ist der Umfang der Variablen die Seite, auf der sie sich befinden. Wenn Sie also $var definieren, kann der Rest der Seite auf $var zugreifen, andere Seiten können jedoch im Allgemeinen nicht darauf zugreifen (es sei denn, es werden spezielle Variablen verwendet).
Da eingebundene Dateien so funktionieren, als wären sie Teil des ursprünglichen (eingebundenen) Skripts, stehen den eingebundenen Dateien Variablen zur Verfügung, die vor der include()-Zeile definiert wurden. Darüber hinaus stehen in der Include-Datei definierte Variablen nach der include()-Zeile für das übergeordnete Skript (include) zur Verfügung.
All dies wird weniger offensichtlich, wenn Sie Ihre eigenen definierten Funktionen verwenden. Diese Funktionen haben ihren eigenen Gültigkeitsbereich, was bedeutet, dass innerhalb einer Funktion verwendete Variablen nicht außerhalb der Funktion verwendet werden können und außerhalb einer Funktion definierte Variablen nicht innerhalb der Funktion verwendet werden können. Aus diesem Grund können Variablen innerhalb einer Funktion denselben Namen haben wie Variablen außerhalb der Funktion, es handelt sich aber dennoch um völlig unterschiedliche Variablen mit unterschiedlichen Werten. Für die meisten unerfahrenen Programmierer ist dies ein verwirrendes Konzept.
Um den Umfang von Variablen innerhalb einer Funktion zu ändern, können Sie die globale Anweisung verwenden.
Der Code lautet wie folgt:
Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function function_name() {
global $var;
}
$var=20;
function_name(); // Function call.
?>Nach dem Login kopieren
In diesem Beispiel ist $var innerhalb der Funktion jetzt dasselbe wie $var außerhalb der Funktion. Das bedeutet, dass die Variable $var bereits den Wert 20 hat und wenn dieser Wert innerhalb der Funktion geändert wird, ändert sich auch der Wert von $var außerhalb.
Eine weitere Möglichkeit, den Variablenbereich zu vermeiden, ist die Verwendung von superglobalen Variablen: $_GET, $_POST, $_REQUEST usw. Auf diese Variablen kann innerhalb Ihrer Funktion automatisch zugegriffen werden (es handelt sich also um superglobale Variablen). Sie können dem $GLOBALS-Array auch Elemente hinzufügen, damit diese in Funktionen verwendet werden können.
Mit anderen Worten: Es ist am besten, keine globalen Variablen innerhalb von Funktionen zu verwenden. Beim Entwerfen von Funktionen sollten Sie dafür sorgen, dass diese bei Bedarf jeden Wert als Parameter akzeptieren und bei Bedarf jeden Wert zurückgeben. Sich auf globale Variablen innerhalb von Funktionen zu verlassen, würde sie kontextabhängiger und daher weniger nützlich machen.
Variablen in PHP umfassen hauptsächlich: integrierte superglobale Variablen, allgemeine Variablen, Konstanten, globale Variablen, statische Variablen usw.
Eingebaute superglobale Variablen können überall im Skript verwendet und sichtbar sein . Das heißt, wenn wir einen der Werte auf einer PHP-Seite ändern, ändert sich sein Wert auch, wenn er auf anderen PHP-Seiten verwendet wird.
• Sobald Konstanten deklariert sind, sind sie global sichtbar, d. h. sie können innerhalb und außerhalb von Funktionen verwendet werden, dies ist jedoch nur auf PHP-Skripte beschränkt, die in einer Seite enthalten sind (einschließlich PHP-Skripten, die wir über include und include_once einbinden). ), kann aber nicht auf anderen Seiten verwendet werden.
•In einem Skript deklarierte globale Variablen sind im gesamten Skript sichtbar, jedoch nicht innerhalb der Funktion. Wenn die Variable innerhalb der Funktion denselben Namen wie die globale Variable hat, hat die Variable innerhalb der Funktion Vorrang.
•Wenn eine innerhalb einer Funktion verwendete Variable als globale Variable deklariert wird, muss ihr Name mit dem Namen der globalen Variablen übereinstimmen. In diesem Fall können wir die globale Variable außerhalb der Funktion verwenden In der Funktion kann dadurch die vorherige Situation vermieden werden, in der die externe Variable überschrieben wird, da die Variable innerhalb der Funktion denselben Namen wie die externe globale Variable hat.
•Variablen, die innerhalb einer Funktion erstellt und als statisch deklariert wurden, sind außerhalb der Funktion nicht sichtbar, aber der Wert kann während mehrerer Ausführungen der Funktion beibehalten werden. Der häufigste Fall ist während der rekursiven Ausführung der Funktion.
•Variablen, die innerhalb einer Funktion erstellt werden, sind lokal für die Funktion und hören auf zu existieren, wenn die Funktion beendet wird.
Die vollständige Liste der superglobalen Variablen lautet wie folgt:
•.$GOBALS Array aller globalen Variablen
•.$_SERVER Array von Serverumgebungsvariablen
•.$_POST Variablenarray, das über die POST-Methode an das Skript übergeben wird
•.$_GET Variablenarray, das über die GET-Methode an das Skript übergeben wird
•.$_COOKIE Cookie-Variablenarray
•.$ _FILES Bezieht sich auf das Hochladen von Dateien. Variablenarray
•.$_ENV Umgebungsvariablenarray
•.$_REQUEST Von allen Benutzern eingegebenes Variablenarray, einschließlich Eingabeinhalt, der in $_GET $_POST $_COOKIE
•.$_SESSION Sitzungsvariable enthalten ist Array
Instanzerklärung:
Der Code lautet wie folgt:
Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
$a = 4;
function sendValue($x)
{
echo $x;
}
sendValue($a);
?>Nach dem Login kopieren
Erklärung: $a ist außerhalb der Funktion definiert, die Funktion definiert Parameter, und wenn die Funktion aufgerufen wird, wird $a als Parameter übergeben. Der obige Code kann also normal ausgeführt werden.
Der Code lautet wie folgt:
Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
$a = 4;
function sendValue()
{
echo $a;
}
sendValue();
?>Nach dem Login kopieren
讲解：当函数被调用时，$a不能以参数的形式被传递。所以上面代码不能够正常运行。
变量范围
变量的范围即它定义的上下文背景（译者:说白了，也就是它的生效范围）。大部分的 PHP 变量只有一个单独的范围。这个单独的范围跨度同样包含了 include 和 require 引入的文件。范例:
代码如下:
<?php
$a = 1;
include "b.inc";
?>
Nach dem Login kopieren
这里变量 $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();
?>Nach dem Login kopieren
这个脚本不会有任何输出，因为 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;
?>Nach dem Login kopieren
以上脚本的输出将是 "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;
?>Nach dem Login kopieren
在 $GLOBALS 数组中，每一个变量为一个元素，键名对应变量名，值变量的内容。$GLOBALS 之所以在全局范围内存在，是因为 $GLOBALS 是一个超全局变量。以下范例显示了超全局变量的用处：
例子 12-3. 演示超全局变量和作用域的例子
代码如下:
Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function test_global()
{
// 大多数的
预定义变量
并不 "super"，它们需要用 'global' 关键字来使它们在函数的本地区域中有效。
global $HTTP_POST_VARS;
print $HTTP_POST_VARS['name'];
// Superglobals 在任何范围内都有效，它们并不需要 'global' 声明。Superglobals 是在 PHP 4.1.0 引入的。
print $_POST['name'];
}
?>Nach dem Login kopieren
使用静态变量
变量范围的另一个重要特性是静态变量（static variable）。静态变量仅在局部函数域中存在，但当程序执行离开此作用域时，其值并不丢失。看看下面的例子：
例子 12-4. 演示需要静态变量的例子
代码如下:
Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?php
function Test ()
{
$a = 0;
echo $a;
$a++;
}
?>Nach dem Login kopieren
本函数没什么用处，因为每次调用时都会将 $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++;
}
?>Nach dem Login kopieren
现在，每次调用 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--;
}
?>Nach dem Login kopieren
注: 静态变量可以按照上面的例子声明。如果在声明中用表达式的结果对其赋值会导致解析错误。
例子 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;
}
?>Nach dem Login kopieren
全局和静态变量的引用
在 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);
?>Nach dem Login kopieren
执行以上例子会导致如下输出：
代码如下:
NULLobject(stdClass)(0) {}Nach dem Login kopieren
类似的行为也适用于 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();
?>Nach dem Login kopieren
执行以上例子会导致如下输出：
代码如下:
Static object: NULLStatic object: NULLStatic object: NULLStatic object: object(stdClass)(1) { ["property"]=> int(1)}Nach dem Login kopieren
上例演示了当把一个引用赋值给一个静态变量时，第二次调用 &get_instance_ref() 函数时其值并没有被记住。
Das obige ist der detaillierte Inhalt vonWas ist der PHP-Variablenbereich?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
