www.adminn.cn
站长正能量分享网!

PHP引用(&)各种使用方法实例详解

AD:阿里云服务器企业会员更优惠 腾讯云香港,韩国免备案服务器1.8折优惠

php的引用(就是在变量或者函数、对象等前面加上&符号),在PHP 中引用的意思是:不同的名字访问同一个变量内容。与C语言中的指针是有差别的.C语言中的指针里面存储的是变量的内容,在内存中存放的地址。

php的引用(就是在变量或者函数、对象等前面加上&符号),在PHP 中引用的意思是:不同的名字访问同一个变量内容。与C语言中的指针是有差别的.C语言中的指针里面存储的是变量的内容,在内存中存放的地址。

1.变量的引用

PHP 的引用允许你用两个变量来指向同一个内容,代码如下:

  1. <?php 
  2.     $a="ABC"
  3.     $b =&$a
  4.     echo $a;//这里输出:ABC 
  5.     echo $b;//这里输出:ABC 
  6.     $b="EFG"
  7.     echo $a;//这里$a的值变为EFG 所以输出EFG 
  8.     echo $b;//这里输出EFG 
  9. ?> 

2.函数的引用传递(传址调用)

传址调用我就不多说了 下面直接给出代码:

  1. <?php 
  2.  
  3.     function test(&$a
  4.     { 
  5.         $a=$a+100; 
  6.     } 
  7.     $b=1; 
  8.     echo $b;//输出1 
  9.     test($b);   //这里$b传递给函数的其实是$b的变量内容所处的内存地址,通过在函数里改变$a的值 就可以改变$b的值了 
  10.     echo "<br>"
  11.     echo $b;//输出101 
  12. ?> 

要注意的是,在这里test(1);的话就会出错,原因自己去想。

注意:上面的“ test($b); ” 中的$b前面不要加 & 符号,但是在函数“call_user_func_array”中,若要引用传参,就得需要 & 符号,如下代码所示:

  1. <?php 
  2. function a(&$b){ 
  3.     $b++; 
  4. $c=0; 
  5. call_user_func_array('a',array(&$c)); 
  6. echo $c
  7. //输出 1 
  8. ?> 

3.函数的引用返回

先看代码,代码如下:

  1. <?php 
  2. function &test() 
  3.     static $b=0;//申明一个静态变量 
  4.     $b=$b+1; 
  5.     echo $b
  6.     return $b
  7. $a=test();//这条语句会输出 $b的值 为1 
  8. $a=5; 
  9. $a=test();//这条语句会输出 $b的值 为2 
  10. $a=&test();//这条语句会输出 $b的值 为3 
  11. $a=5; 
  12. $a=test();//这条语句会输出 $b的值 为6 
  13. ?> 

下面解释下:

通过这种方式$a=test();得到的其实不是函数的引用返回,这跟普通的函数调用没有区别 至于原因: 这是PHP的规定

PHP规定通过$a=&test(); 方式得到的才是函数的引用返回

至于什么是引用返回呢(PHP手册上说:引用返回用在当想用函数找到引用应该被绑定在哪一个变量上面时。) 这句狗屁话 害我半天没看懂

用上面的例子来解释就是

$a=test()方式调用函数,只是将函数的值赋给$a而已, 而$a做任何改变 都不会影响到函数中的$b

而通过$a=&test()方式调用函数呢, 他的作用是 将return $b中的 $b变量的内存地址与$a变量的内存地址 指向了同一个地方

即产生了相当于这样的效果($a=&$b;) 所以改变$a的值 也同时改变了$b的值 所以在执行了

$a=&test();

$a=5;

以后,$b的值变为了5

这里是为了让大家理解函数的引用返回才使用静态变量的,其实函数的引用返回多用在对象中。

另附一个php官方例子:

  1. This is the way how we use pointer to access variable inside the class
  2. <?php 
  3. class talker{ 
  4.     private $data = 'Hi'
  5.     public function & get(){ 
  6.         return $this->data; 
  7.     } 
  8.  
  9.     public function out(){ 
  10.         echo $this->data; 
  11.     }    
  12. $aa = new talker(); 
  13. $d = &$aa->get(); 
  14. $aa->out(); 
  15. $d = 'How'
  16. $aa->out(); 
  17. $d = 'Are'
  18. $aa->out(); 
  19. $d = 'You'
  20. $aa->out(); 
  21. ?> 
  22. //the output is "HiHowAreYou" 

4.对象的引用,代码如下:

  1. <?php 
  2.     class a{ 
  3.         var $abc="ABC"
  4.     } 
  5.     $b=new a; 
  6.     $c=$b
  7.     echo $b->abc;//这里输出ABC 
  8.     echo $c->abc;//这里输出ABC 
  9.     $b->abc="DEF"
  10.     echo $c->abc;//这里输出DEF 
  11. ?> 

上代码是在PHP5中的运行效果

在PHP5中 对象的赋值是个引用的过程。上列中$b=new a; $c=$b; 其实等效于$b=new a; $c=&$b;

PHP5中默认就是通过引用来调用对象, 但有时你可能想建立一个对象的副本,并希望原来的对象的改变不影响到副本 . 为了这样的目的,PHP5定义了一个特殊的方法,称为__clone。

自 PHP 5 起,new 自动返回引用,因此在此使用 =& 已经过时了并且会产生 E_STRICT 级别的消息。

在php4中,对象的赋值是个拷贝过程,如:$b=new a,其中new a产生的是一个匿名的a对象实例,而此时的$b是对这个匿名对象的拷贝。同理$c=$b,也是对$b内容的一个拷贝。所以在php4中,为了节省内存空间,$b=new a 一般会改成引用的模式,即 $b=& new a。

下面再来个 官方 提供的例子:

在php5中,你不需要额外添加什么东西就可到达“对象引用”的功能:

  1. <?php 
  2. class foo{ 
  3.         protected $name
  4.         function __construct($str){ 
  5.                 $this->name = $str
  6.         } 
  7.         function __toString(){ 
  8.                 return  'my name is "'$this->name .'" and I live in "' . __CLASS__ . '".' . "\n"
  9.         } 
  10.         function setName($str){ 
  11.                 $this->name = $str
  12.         } 
  13. class MasterOne{ 
  14.         protected $foo
  15.         function __construct($f){ 
  16.                 $this->foo = $f
  17.         } 
  18.         function __toString(){ 
  19.                 return 'Master: ' . __CLASS__ . ' | foo: ' . $this->foo . "\n"
  20.         } 
  21.         function setFooName($str){ 
  22.                 $this->foo->setName( $str ); 
  23.         } 
  24. class MasterTwo{ 
  25.         protected $foo
  26.         function __construct($f){ 
  27.                 $this->foo = $f
  28.         } 
  29.         function __toString(){ 
  30.                 return 'Master: ' . __CLASS__ . ' | foo: ' . $this->foo . "\n"
  31.         } 
  32.         function setFooName($str){ 
  33.                 $this->foo->setName( $str ); 
  34.         } 
  35. $bar = new foo('bar'); 
  36. print("\n"); 
  37. print("Only Created \$bar and printing \$bar\n"); 
  38. print( $bar ); 
  39. print("\n"); 
  40. print("Now \$baz is referenced to \$bar and printing \$bar and \$baz\n"); 
  41.  
  42. $baz =& $bar
  43. print( $bar ); 
  44. print("\n"); 
  45. print("Now Creating MasterOne and Two and passing \$bar to both constructors\n"); 
  46.  
  47. $m1 = new MasterOne( $bar ); 
  48. $m2 = new MasterTwo( $bar ); 
  49. print( $m1 ); 
  50. print( $m2 ); 
  51. print("\n"); 
  52. print("Now changing value of \$bar and printing \$bar and \$baz\n"); 
  53.  
  54. $bar->setName('baz'); 
  55. print( $bar ); 
  56. print( $baz ); 
  57. print("\n"); 
  58. print("Now printing again MasterOne and Two\n"); 
  59. print( $m1 ); 
  60. print( $m2 ); 
  61. print("\n"); 
  62. print("Now changing MasterTwo's foo name and printing again MasterOne and Two\n"); 
  63.  
  64. $m2->setFooName( 'MasterTwo\'s Foo' ); 
  65. print( $m1 ); 
  66. print( $m2 ); 
  67. print("Also printing \$bar and \$baz\n"); 
  68. print( $bar ); 
  69. print( $baz ); 
  70. ?> 

输出:

  1. Only Created $bar and printing $bar 
  2. my name is "bar" and I live in "foo"
  3. Now $baz is referenced to $bar and printing $bar and $baz 
  4. my name is "bar" and I live in "foo"
  5. Now Creating MasterOne and Two and passing $bar to both constructors 
  6. Master: MasterOne | foo: my name is "bar" and I live in "foo"
  7. Master: MasterTwo | foo: my name is "bar" and I live in "foo"
  8. Now changing value of $bar and printing $bar and $baz 
  9. my name is "baz" and I live in "foo"
  10. my name is "baz" and I live in "foo"
  11. Now printing again MasterOne and Two 
  12. Master: MasterOne | foo: my name is "baz" and I live in "foo"
  13. Master: MasterTwo | foo: my name is "baz" and I live in "foo"
  14. Now changing MasterTwo's foo name and printing again MasterOne and Two 
  15. Master: MasterOne | foo: my name is "MasterTwo's Foo" and I live in "foo"
  16. Master: MasterTwo | foo: my name is "MasterTwo's Foo" and I live in "foo"
  17. Also printing $bar and $baz 
  18. my name is "MasterTwo's Foo" and I live in "foo"
  19. my name is "MasterTwo's Foo" and I live in "foo"

上个例子解析:

  1. $bar = new foo('bar'); 
  2. $m1 = new MasterOne( $bar ); 
  3. $m2 = new MasterTwo( $bar ); 

实例对象$m1与$m2中的$bar是对实例$bar的引用,而非拷贝,这是php5中,对象引用的特点,也就是说。

1.$m1或$m2内部,任何对$bar的操作都会影响外部对象实例$bar的相关值。

2.外部对象实例$bar的改变也会影响$m1和$m2内部的$bar的引用相关值。

在php4中,要实现如上述的 用一个对象实例去当着另外一个对象的属性时,其等价代码(即引用调用)类似如下:

  1. class foo{ 
  2.    var $bar
  3.    function setBar(&$newBar){ 
  4.       $this->bar =& newBar; 
  5.    } 

5.引用的作用

如果程序比较大,引用同一个对象的变量比较多,并且希望用完该对象后手工清除它,个人建议用 "&" 方式,然后用$var=null的方式清除. 其它时候还是用php5的默认方式吧. 另外, php5中对于大数组的传递,建议用 "&" 方式, 毕竟节省内存空间使用。

6.取消引用

当你 unset 一个引用,只是断开了变量名和变量内容之间的绑定。这并不意味着变量内容被销毁了。例如: 

  1. <?php 
  2.     $a = 1; 
  3.     $b =& $a
  4.     unset ($a); 
  5. ?> 

不会 unset $b,只是 $a。

7.global 引用

当用 global $var 声明一个变量时实际上建立了一个到全局变量的引用。也就是说和这样做是相同的: 

  1. <?php 
  2.     $var =& $GLOBALS["var"]; 
  3. ?> 

这意味着,例如,unset $var 不会 unset 全局变量。

如果在一个函数内部给一个声明为 global 的变量赋于一个引用,该引用只在函数内部可见。可以通过使用 $GLOBALS 数组避免这一点。

Example  在函数内引用全局变量,代码如下:

  1. <?php 
  2. $var1 = "Example variable"
  3. $var2 = ""
  4. function global_references($use_globals
  5.     global $var1$var2
  6.     if (!$use_globals) { 
  7.         $var2 =& $var1// visible only inside the function 
  8.     } else { 
  9.         $GLOBALS["var2"] =& $var1// visible also in global context 
  10.     } 
  11. global_references(false); 
  12. echo "var2 is set to '$var2'\n"// var2 is set to '' 
  13. global_references(true); 
  14. echo "var2 is set to '$var2'\n"// var2 is set to 'Example variable' 
  15. ?> 

把 global $var; 当成是 $var =& $GLOBALS['var']; 的简写。从而将其它引用赋给 $var 只改变了本地变量的引用。

8.$this

在一个对象的方法中,$this 永远是调用它的对象的引用。

下面再来个小插曲

php中对于地址的指向(类似指针)功能不是由用户自己来实现的,是由Zend核心实现的,php中引用采用的是“写时拷贝”的原理,就是除非发生写操作,指向同一个地址的变量或者对象是不会被拷贝的。

通俗的讲

1:如果有下面的代码

  1. <? 
  2.     $a="ABC"
  3.     $b=&$a
  4. ?> 

其实此时 $a与$b都是指向同一内存地址 而并不是$a与$b占用不同的内存

2:如果在上面的代码基础上再加上如下代码:

  1. <?php 
  2.   $a="EFG"
  3. ?> 

由于$a与$b所指向的内存的数据要重新写一次了,此时Zend核心会自动判断 自动为$b生产一个$a的数据拷贝,重新申请一块内存进行存储

php的引用(就是在变量或者函数、对象等前面加上&符号)是个高级话题,新手多注意,正确的理解php的引用很重要,对性能有较大影响,而且理解错误可能导致程序错误!

很多人误解php中的引用跟C当中的指针一样,事实上并非如此,而且很大差别。C语言中的指针除了在数组传递过程中不用显式申明外,其他都需要使用*进行定 义,而php中对于地址的指向(类似指针)功能不是由用户自己来实现的,是由Zend核心实现的,php中引用采用的是“写时拷贝”的原理,就是除非发生 写操作,指向同一个地址的变量或者对象是不会被拷贝的,比如下面的代码:

$a = array('a','c'…'n');

$b = $a;

如果程序仅执行到这里,$a和$b是相同的,但是并没有像C那样,$a和$b占用不同的内存空间,而是指向了同一块内存,这就是php和c的差别,并不需要 写成$b=&$a才表示$b指向$a的内存,zend就已经帮你实现了引用,并且zend会非常智能的帮你去判断什么时候该这样处理,什么时候不 该这样处理。

如果在后面继续写如下代码,增加一个函数,通过引用的方式传递参数,并打印输出数组大小,代码如下:

  1. function printArray(&$arr//引用传递 
  2.    print(count($arr)); 
  3.  
  4.  
  5. printArray($a); 

上面的代码中,我们通过引用把$a数组传入printArray()函数,zend引擎会认为printArray()可能会导致对$a的改变,此时就会自动为$b生产一个$a的数据拷贝,重新申请一块内存进行存储。这就是前面提到的“写时拷贝”概念。

如果我们把上面的代码改成下面这样:

  1. function printArray($arr)   //值传递 
  2.    print(count($arr)); 
  3. printArray($a); 

上面的代码直接传递$a值到printArray()中,此时并不存在引用传递,所以没有出现写时拷贝。

大家可以测试一下上面两行代码的执行效率,比如外面加入一个循环1000次,看看运行的耗时,结果会让你知道不正确使用引用会导致性能下降30%以上。

自我理解:按传值的话是与函数内的参数无关,相当于局部变量的作用,而按传址(引用)的话却与函数内的参数有关,相当于全局变量的作用.而从性能方面来说,看上面分析就够..

模板优惠价: (点击购买)
版权声明:本文采用知识共享 署名4.0国际许可协议 [BY-NC-SA] 进行授权
文章名称:《PHP引用(&)各种使用方法实例详解》
文章链接:https://www.adminn.cn/news/8596.html
本站资源模板仅供个人学习交流,请于下载后24小时内删除,不允许用于商业用途,否则法律问题自行承担。2021.5月起,网站调整,暂不再分享免费模板。谢谢理解

扫码支付后请联系右侧QQ发送下载地址!!

源码请勿用于任何涉灰站点!净化网络,站长更有责!

支付宝扫一扫打赏