这篇文章主要介绍了PHP的中引用的概念，帮助大家更好的理解和学习使用PHP，感兴趣的朋友可以了解下。

什么是引用？

在 PHP 中引用意味着用不同的名字访问同一个变量内容。它不是C的指针，保存的并不是内存地址，无法进行指针运算。引用只是符号表的别名。就像 Unix 系统中的硬链接， Windows 系统中的快捷方式。

上面是官方手册中的原文，怎么说呢，引用其实和我们印象中的C里面的指针并不是相同的概念。指针是针对真实内存的操作，引用是针对指向这个内存的符号表的操作。还是从操作系统的快捷方式来说，快捷方式是可以删的，这就是PHP的引用。而C不仅删了快捷方式，还把原文件也给删了，这就是C的指针操作。

1. // 引用不是指针 
2. $a = 1; 
3. $b = &$a; 
4. echo $a, '===', $b, PHP_EOL; 
5. unset($b); 
6. echo $a, '===', $b, PHP_EOL; 

上面的代码是在PHP中，我们把b变量指向b变量指向a，作为a的引用变量。然后删除a的引用变量。然后删除b，对$a没有任何影响。

1. #include <stdio.h> 
2. #include <stdlib.h> 
3.  
4. int main() 
5. { 
6.     // C 中的指针和引用 
7.     int a = 1; 
8.     int* b = &a; 
9.     printf("%i\n", a); // 1 
10.     free(b); // free b 
11.     printf("%i\n", a); //get error: *** error for object 0x7fff6350da08: pointer being freed was not allocated 
12.     return 0; 
13. } 

而C中的引用指针就不行了，我们把b变量删掉后，再打印a变量就直接报错了。

虽然说PHP的底层也是C写得，但我们都知道C中的指针是出了名的变态，没有一定的功底非常容易出错。所以PHP的开发者没有暴露C的原始指针能力，而是采用了和Java之类的类似的引用能力。这也是现代语言的特性，不需要我们过多的关注过于底层的能力，而将更多的时间放在业务实现上。

引用在数组和对象中的使用

如果具有引用的数组被拷贝，其值不会解除引用。对于数组传值给函数也是如此。

1. $arr1 = ["a", "b"]; 
2. $t1 = &$arr1[1]; 
3. $arr2 = $arr1; 
4. $arr2[1] = "c"; 
5. var_dump($arr1); 
6.  
7. // array(2) { 
8. //     [0]=> 
9. //     string(1) "a" 
10. //     [1]=> 
11. //     &string(1) "c" 
12. // } 
13.  
14. $arr1 = ["a", "b"]; 
15. $t1 = &$arr1[1]; 
16. unset($t1); // unset 掉引用 
17. $arr2 = $arr1; 
18. $arr2[1] = "c"; 
19. var_dump($arr1); 
20.  
21. // array(2) { 
22. //     [0]=> 
23. //     string(1) "a" 
24. //     [1]=> 
25. //     string(1) "b" 
26. // } 

这个其实挺有意思的，我们对比这两个例子可以看出一个问题，t变量指向t变量指向arr[1]的引用。arr2直接=这个arr2直接=这个arr1，没有使用引用，然后arr2修改了arr2修改了arr2[1]的内容，arr1相应的内容也发生了改变，如果unset掉arr1相应的内容也发生了改变，如果unset掉t变量，则$arr1相应的内容就不会发生改变。对此，我在文档中找到了下面的解释：

由于PHP内部工作的特殊性，如果对数组的单个元素进行引用，然后复制数组，无论是通过赋值还是通过函数调用中的值传递，都会将引用复制为数组的一部分。这意味着对任一数组中任何此类元素的更改都将在另一个数组（和其他引用中）中重复，即使数组具有不同的作用域（例如，一个是函数内部的参数，另一个是全局的）！在复制时没有引用的元素，以及在复制数组后分配给其他元素的引用，将正常工作（即独立于其他数组）。

不仅仅是数组，对象的引用也会有一些好玩的问题。

1. $o1 = new stdClass(); 
2. $o1->a = 'a'; 
3. var_dump($o1); 
4. // object(stdClass)#1 (1) { 
5. //   ["a"]=> 
6. //   string(1) "a" 
7. // } 
8.  
9. $o2 = &$o1; 
10. $o3 = $o1; 
11.  
12. $o2->a = 'aa'; 
13.  
14. var_dump($o1); 
15. // object(stdClass)#1 (1) { 
16. //   ["a"]=> 
17. //   string(2) "aa" 
18. // } 
19.  
20. var_dump($o3); // $o2修改了$a为'aa'，$o3也变成了'aa' 
21. // object(stdClass)#1 (1) { 
22. //   ["a"]=> 
23. //   string(2) "aa" 
24. // } 
25.  
26. $o1->a = 'aaa'; 
27. $o1 = null; 
28. var_dump($o2); // $o2引用变成了null 
29. // NULL 
30.  
31. var_dump($o3); // $o3不仅引用还存在，并且$a变成了'aaa' 
32. // object(stdClass)#1 (1) { 
33. //   ["a"]=> 
34. //   string(3) "aaa" 
35. // } 

上面例子中有三个对象，o1、o1、o2、o3，其中，o3，其中，o2是对o1的引用，o1的引用，o3是直接赋值为o1。对o1。对o2属性的操作不仅会反映在o1中，也会反映到o1中，也会反映到o3中。其实我们之前专门有一篇文章就讲的这个问题，首先对象默认赋值就是引用，其次这个例子很好地证明了引用就是一个符号表的绑定。删除了快捷方式对原始对象和其他快捷方式没有任何影响。

引用的传递

关于引用在方法参数上的传递，最重要的是记住两点：一是方法内部修改了变量外部也会变，这是引用的特性嘛；二是只能传递变量、New 语句、从函数中返回的引用三种类型。

1. error_reporting(E_ALL); 
2. function foo(&$var) 
3. { 
4.     $var++; 
5.     echo 'foo：', $var; 
6. } 
7. function bar() // Note the missing & 
8. { 
9.     $a = 5; 
10.     return $a; 
11. } 
12. foo(bar()); // 自 PHP 5.0.5 起导致致命错误，自 PHP 5.1.1 起导致严格模式错误 
13.             // 自 PHP 7.0 起导致 notice 信息,Notice: Only variables should be passed by reference 
14. foo($a = 5); // 表达式，不是变量, Notice: Only variables should be passed by reference 
15. // foo(5); // 导致致命错误 !5是个常量! 
16.  
17. /////////////////////////////// 
18. // 正确的传递类型 
19. $a = 5; 
20. foo($a); // 变量 
21.  
22. function &baz() 
23. { 
24.     $a = 5; 
25.     return $a; 
26. } 
27. foo(baz()); // 从函数中返回的引用 
28.  
29. function foo1(&$var) 
30. { 
31.     print_r($var); 
32. } 
33. foo1(new stdClass()); // new 表达式 

引用的返回

引用的返回并不是经常使用的一个能力。文档中的原文是：不要用返回引用来增加性能，引擎足够聪明来自己进行优化。仅在有合理的技术原因时才返回引用！

1. $a = 1; 
2. function &test(){ 
3.     global $a; 
4.     return $a; 
5. } 
6.  
7. $b = &test($a); 
8. $b = 2; 
9. echo $a, PHP_EOL; 

引用的取消

取消引用其实就是直接unset掉变量就可以了。但是一定要记住，PHP中的引用是指向的符号表，对原始真实的值是不起作用的，所以即使unset掉了最原始的那个变量，对其它引用赋值的变量也不会有影响！！

1. $a = 1; 
2. $b = &$a; 
3. $c = &$b; 
4. $b = 2; 
5. echo '定义引用后：', $a, '===', $b, '===', $c, PHP_EOL; 
6.  
7. unset($b); 
8. $b = 3; 
9. echo '取消$b的引用，不影响$a、$c：', $a, '===', $b, '===', $c, PHP_EOL; 
10.  
11. $b = &$a; 
12. unset($a); 
13. echo '取消$a，不影响$b、$c：', $a, '===', $b, '===', $c, PHP_EOL; 
14.  
15. // 定义引用后：2===2===2 
16. // 取消$b的引用：2===3===2 
17. // 取消$a，不影响$c：===3===2 
18.  
19.  
20. $a = 1; 
21. $b = & $a; 
22. $c = & $b; // $a, $b, $c reference the same content '1' 
23.  
24. $a = NULL; // All variables $a, $b or $c are unset 
25. echo '所有引用成空：', $a, '===', $b, '===', $c, PHP_EOL; 

总结

这一次算是比较彻底的把引用说了个透。关于PHP的引用只要记住了它的定义就非常好理解了，最直观的就是当成是操作系统的快捷方式就好了，并没有我们想象中的那么难，和C的指针相比真的只是娃娃级别，多多练习多多复习自然就能很好地掌握使用啦！

测试代码： github.com/zhangyue050…

Tags: PHP引用的概念

分享到：