PHP static 静态变量和属性方法使用说明

变量与其它变量明确区别的,下面我来给各位介绍 static 静态变量和属性方法及静态变量的引用与静态函数的用法,各位有需要了解的同学可参考.

静态变量:变量范围的另一个重要特性是静态变量(static variable),静态变量仅在局部函数域中存在,但当程序执行离开此作用域时,其值并不丢失,看看下面的例子.

例子 7-4.演示需要静态变量的例子,代码如下:

1. <?php 
2. function Test () 
3. { 
4. $a = 0; 
5. echo $a; 
6. $a++; 
7. } 
8. ?> 

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

例子 7-5. 使用静态变量的例子,代码如下:

1. <?php 
2. function Test() 
3. { 
4. static $a = 0; 
5. echo $a; 
6. $a++; 
7. } 
8. ?> 

现在,每次调用 Test() 函数都会输出 $a 的值并加一.

静态变量也提供了一种处理递归函数的方法,递归函数是一种调用自己的函数,写递归函数时要小心,因为可能会无穷递归下去,必须确保有充分的方法来中止递归,一下这个简单的函数递归计数到 10,使用静态变量 $count 来判断何时停止.

例子 7-6,静态变量与递归函数,代码如下:

1. <?php 
2. function Test() 
3. { 
4. static $count = 0; 
5.  
6. $count++; 
7. echo $count; 
8. if ($count < 10) { 
9. Test (); 
10. } 
11. $count--; 
12. } 
13. ?> 

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

例子 7-7.声明静态变量,代码如下:

1. <?php 
2. function foo(){ 
3. static $int = 0; // correct 
4. static $int = 1+2; // wrong  (as it is an expression) 
5. static $int = sqrt(121); // wrong  (as it is an expression too) 
6. $int++; 
7. echo $int; 
8. } 
9. ?> 

全局和静态变量的引用

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

1. <?php 
2. function test_global_ref() { 
3. global $obj; 
4. $obj = &new stdclass; 
5. } 
6.  
7. function test_global_noref() { 
8. global $obj; 
9. $obj = new stdclass; 
10. } 
11.  
12. test_global_ref(); 
13. var_dump($obj); 
14. test_global_noref(); 
15. var_dump($obj); 
16. ?>  

执行以上例子会导致如下输出,代码如下:

1. NULL 
2. object(stdClass)(0) { 
3. } 

类似的行为也适用于 static 语句,引用并不是静态地存储的,代码如下:

1. <?php 
2. function &get_instance_ref() { 
3. static $obj; 
4.  
5. echo "Static object: "; 
6. var_dump($obj); 
7. if (!isset($obj)) { 
8. // 将一个引用赋值给静态变量 
9. $obj = &new stdclass; 
10. } 
11. $obj->property++; 
12. return $obj; 
13. } 
14.  
15. function &get_instance_noref() { 
16. static $obj; 
17.  
18. echo "Static object: "; 
19. var_dump($obj); 
20. if (!isset($obj)) { 
21. // 将一个对象赋值给静态变量 
22. $obj = new stdclass; 
23. } 
24. $obj->property++; 
25. return $obj; 
26. } 
27.  
28. $obj1 = get_instance_ref(); 
29. $still_obj1 = get_instance_ref(); 
30. echo "n"; 
31. $obj2 = get_instance_noref(); 
32. $still_obj2 = get_instance_noref(); 
33. ?> 

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

1. Static object: NULL 
2. Static object: NULL 
3.  
4. Static object: NULL 
5. Static object: object(stdClass)(1) { 
6.   ["property"]=> 
7.   int(1) 
8. } 

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

注:

1.函数外部声明静态变量意义不大,函数内部声明静态变量受限于作用域,函数外部不能修改函数内部静态变量.

2.引用变量,也是变量,只不过它的值是变量的内存地址.

php保留字 global和static,代码如下:

1. <?php 
2. $i = $j = 8; 
3. function global_var() { 
4.    global $j, $b; 
5.    $c = $j = $b = $i = 4; 
6. } 
7. global_var(); 
8. echo "i:$i, j:$j b:$b c:$c n"; //i:8, j:4 b:4 c: 
9. ?> 

函数外和内都有变量$i,但是他们二个是完全不同的变量,函数外的$i是全局变量,该内存空间直到脚本运行结束后才会被释放,函数内的$i是局部变量,程序流经过函数的时候,初始化,退出函数的时候,内存被系统回收,再次调用函数,则再次分配内存空间和回收内存空间,二次分配的内存空间有可能是同一内存地址,也有可能不能同一内存地址.

与$i不同的是$j,通过关键字global将局部变量”转为”全局变量,当调用函数global_var()的时候,并不会重新给$j分配内存空间,同样的,可以在函数外打印$b,却不能打印$c是因为$b是全局变量,不会被销毁,而$c则不能打印,$c已经不存在了,在退出函数就给销毁了,代码如下:

1. <?php 
2. $a = 2; 
3. static $b = 2; 
4. static $c = 3; 
5. function global_var() { 
6.     static $i, $c; 
7.     global $j, $a; 
8.     $c = $a = $b = $i = $j = 4; 
9. } 
10. global_var(); 
11. echo "a:$a b:$b c:$c i:$i j:$j"; //a:4 b:2 c:3 i: j:4 
12. ?> 

首先,我们看函数外的$b和$c,即是全局变量又是static变量,这里static修饰没有太大的意义,因为他们都存放在数据段(data-segment),直到脚本运行完了之后才会被回收,然后,我们再看函数里面的$i和$c，函数调用后,$i和$c其实都没有被回收,但是$i输出是NULL和$c输出是3,这是因为他们的作用域是函数内部,不是函数外部,也就是说$i和$c在函数外是不可见的,函数内static变量的意义就在于此,仅函数内部可见且不会被销毁,也就是说,保证函退出函数,变量也不会被回收,但又不会被其它函数修改.(注:函数外和函数内的$c是二个不同的变量)

代码如下:

1. <?php 
2. function global_var() { 
3.    static $i; 
4.    ++$j; 
5.    ++$i; 
6.    echo "j:$j i:$i n"; 
7. } 
8. global_var(); //j:1 i:1  
9. global_var();  //j:1 i:2 
10. global_var();  //j:1 i:3 
11. ?> 

上例中,变量$j一直都是1,而$i每调用一次就累加1,这是因为,局部变量存放在堆段,每次退出函数时都会被回收,而$i存放在存放在数据段(data-segment),直到程序执行完毕才会被回收,我们平常说的static变量,如果没有特别指明,都说的是函数内部的static变量.

引用函数与static变量

既然static变量要直到脚本执行结束,才会被销毁,那么,有没有办法访问该变量的值呢？我们来看看下面的示例,代码如下:

1. <?php 
2. get_local_static_var(); 
3. $ptr = &get_local_static_var(); 
4. get_local_static_var(); 
5. ++$ptr; 
6. get_local_static_var(); 
7. what_i($ptr); 
8. get_local_static_var();  //?? 
9. what_p($ptr); 
10. get_local_static_var();  //?? 
11.  
12. function &get_local_static_var() { 
13.     static $i; 
14.     ++$i; 
15.     echo "i:$i n"; 
16.     return $i; 
17. } 
18.  
19. function what_i($ptr) { 
20.    $i = &get_local_static_var(); 
21.    ++$i; 
22.    ++$ptr; 
23. } 
24.  
25. function what_p(&$ptr) { 
26.    $i = &get_local_static_var(); 
27.    ++$i; 
28.    ++$ptr; 
29. } 
30. ?> 

二个凝问号处,分别输出是8和12,这就说明了只要变量没有被销毁,还是可以被访问,我们可以通过引用函数将static变量的地址返回其它函数,其它函数则可通过static变量的地址访问并且修改它的值.

上例第一处??，为什么是8,而不是9,这是因为what_i($ptr)函数，要求参数是按值传递，即此处的$ptr实参值是5，且参数$ptr和全局变量$ptr是二个不同的变量。第二处??的值是12，为什么不是11的道理亦是如此。what_p(&$ptr)函数，要求参数是按引用传递，即此处的$ptr是指向static变量$i的地址，需要注意的是参数$ptr和全局变量$ptr也是二个不同的变量，只不过他们都指向同一个地方.