PHP 引用变量总结

变量引用对比赋值操作

赋值操作:
// 定义一个变量
$a = range(0, 1000);  // 在内存中申请空间来存储变量a对应的值
var_dump(memory_get_usage());

// 定义变量b,将a变量的值赋值给b
$b = $a;
// 由于PHP的COW,(Copy On Write,只有在变量发生“写”操作之后,系统才会申请新的内存空间)所以,此时,变量a与变量b会指向同一个内存地址。
var_dump(memory_get_usage());

// 对a进行修改
$a = range(0, 1000);
// 变量a发生了“写”操作,系统将在内存中申请新的空间,保存新的值,同时变量a指向原内存地址的指针将会移除,并指向新的内存地址。
var_dump(memory_get_usage());
引用变量

PHP的引用变量定义符为 &
该操作将会将原有变量的指向的内存地址传递给新的变量。

如:

$a = range(0, 1000);   //在内存中开辟空间用于保存 $a 对应的值
$b = &$a;              //将 $a 对应的值在内存中的地址空间传递给 $b , 此时 $a 与 $b 共用同一块内存空间。此时,如果对 $a 或者 $b 进行修改,则 $a 与 $b 的值将同时修改。

两者区别

引用变量传递了内存地址,如果有一个变量的值发生修改,那么两个变量的值都会发生变化;
变量赋值变量修改只会修改发生变化的那个变量的值;在未发生修改之前,与引用变量一样,两者都会指向同一个内存地址

zval变量容器变化

赋值操作
// zval变量容器
$a = range(0, 3);
xdebug_debug_zval('a');
/***
  * 输出结果
  * a: (refcount=1, is_ref=0)=array(4) {   // refcount=1:引用计数为1,只有变量a;is_ref=0:是否引用变量:false
  *     [0] =>(refcount=0, is_ref=0)=int(0)
  *     [1] =>(refcount=0, is_ref=0)=int(1)
  *     [2] =>(refcount=0, is_ref=0)=int(2)
  *     [3] =>(refcount=0, is_ref=0)=int(3)
  * }
  ***/
// 定义变量b,把a的值赋值给b
$b = $a;
xdebug_debug_zval('a');
/***
  * 输出结果
  * a: (refcount=2, is_ref=0)=array(4) {   // refcount=2:引用次数为2,变量a与变量b同时指向a对应的内存空间;is_ref=0:是否引用变量:false
  *     [0] =>(refcount=0, is_ref=0)=int(0)
  *     [1] =>(refcount=0, is_ref=0)=int(1)
  *     [2] =>(refcount=0, is_ref=0)=int(2)
  *     [3] =>(refcount=0, is_ref=0)=int(3)
  * }
  ***/
// 修改a
$a = range(0, 3);
xdebug_debug_zval('a');
/***
  * 输出结果
  * a: (refcount=1, is_ref=0)=array(4) {   // refcount=1:引用计数为1,由于COW原则,变量a指向了新的内存地址,所以只有变量a;is_ref=0:是否引用变量:false
  *     [0] =>(refcount=0, is_ref=0)=int(0)
  *     [1] =>(refcount=0, is_ref=0)=int(1)
  *     [2] =>(refcount=0, is_ref=0)=int(2)
  *     [3] =>(refcount=0, is_ref=0)=int(3)
  * }
  ***/

引用变量

$a = range(0, 3);
xdebug_debug_zval('a');
/***
  * 输出结果
  * a: (refcount=1, is_ref=0)=array(4) {   // refcount=1:引用计数为1,只有变量a;is_ref=0:是否引用变量:false
  *     [0] =>(refcount=0, is_ref=0)=int(0)
  *     [1] =>(refcount=0, is_ref=0)=int(1)
  *     [2] =>(refcount=0, is_ref=0)=int(2)
  *     [3] =>(refcount=0, is_ref=0)=int(3)
  * }
  ***/
// 引用变量
$b = &$a;
xdebug_debug_zval('a');
/***
  * 输出结果
  * a: (refcount=2, is_ref=1)=array(4) {   // refcount=2:引用计数为2,变量a与变量b同时指向a对应的内存空间;is_ref=1:是否引用变量:true
  *     [0] =>(refcount=0, is_ref=0)=int(0)
  *     [1] =>(refcount=0, is_ref=0)=int(1)
  *     [2] =>(refcount=0, is_ref=0)=int(2)
  *     [3] =>(refcount=0, is_ref=0)=int(3)
  * }
  ***/
// 修改变量a
$a = range(0, 3);
xdebug_debug_zval('a');
/***
  * 输出结果
  * a: (refcount=2, is_ref=1)=array(4) {   // refcount=2:引用计数为2,变量a与变量b同时指向a对应的内存空间;is_ref=1:是否引用变量:true;并未受到修改操作的影响
  *     [0] =>(refcount=0, is_ref=0)=int(0)
  *     [1] =>(refcount=0, is_ref=0)=int(1)
  *     [2] =>(refcount=0, is_ref=0)=int(2)
  *     [3] =>(refcount=0, is_ref=0)=int(3)
  * }
  ***/

unset操作

unset操作仅会取消引用,而不会销毁内存空间.

$a = 1;
$b = &$a;
unset($b);  // 此时只取消了变量b的引用,而不会销毁内存空间,变量a不受影响
echo $a;

对象操作

对象本身就是引用传递!!!!如果需要复制,参考 clone

class Person
{
    public $name = "zhangsan";
}

$p1 = new Person;
xdebug_debug_zval('p1');
/***
  * p1: (refcount=1, is_ref=0)=class Person#1 (1) {
  *     public $name =>(refcount=2, is_ref=0)=string(8) "zhangsan"
  * }
 ***/
$p2 = $p1;
xdebug_debug_zval('p1');
/***
  * p1: (refcount=2, is_ref=0)=class Person#1 (1) {
  *     public $name =>(refcount=2, is_ref=0)=string(8) "zhangsan"
  * }
 ***/
$p2->name = "lisi";
xdebug_debug_zval('p1');
/***
  * p1: (refcount=2, is_ref=0)=class Person#1 (1) {
  *     public $name =>(refcount=2, is_ref=0)=string(8) "lisi"
  * }
 ***/

Example

$data = ['a', 'b', 'c'];

foreach ($data as $key=>$val)
{
    $val = &$data[$key];
}

var_dump($data);  // 输出['b', 'c', 'c']
/***
  * 分析:
  * foreach循环中,
  * 第一次循环:
  *     $data as $key => $val: $val = $data[0] (即'a'), $key = 0, 进入循环体;
  *     由于是引用变量操作,所以 $val 与 $data[0] 均会指向 ‘a’,第一次循环结束;
  * 第二次循环:
  *     $data as $key => $val: $val = $data[1] (即'b'),由于上一步循环中,$val 与 $data[0]是指向的同一个内存地址,且为引用变量,所以,此时$data[0]值则变为了‘b’,进入循环体
  *     由于是引用变量操作,所以 $val 与 $data[1] 均会指向 ‘b’,第二次循环结束;
  * 第三次循环:
  *     $data as $key => $val: $val = $data[2] (即'c'),由于上一步循环中,$val 与 $data[1]是指向的同一个内存地址,且为引用变量,所以,此时$data[1]值则变为了‘c’,进入循环体
  *     由于是引用变量操作,所以 $val 与 $data[1] 均会指向 ‘c’,第三次循环结束;
  * 循环结束后,$data[0] = 'b',$data[1] = 'C',$data[2] = 'c',
  * 所以最后输出结果为['b', 'c', 'c']
 ***/

发表评论