使用引用主要有三种基本操作：按引用赋值、按引用传递 和 按引用返回。本节将简要介绍这些操作，并提供进一步阅读的链接。
首先，PHP 引用允许你让两个变量指向相同的内容。这意味着，当你执行
<?php
$a =& $b;
?>注意:
$a 和 $b 在此处完全相等。$a 并不指向 $b，反之亦然。$a 和 $b 指向同一个内存位置。
注意:
如果你按引用赋值、传递或返回一个未定义的变量，它将被创建。
示例 #1 使用引用和未定义变量
<?php
function foo(&$var) {}
foo($a); // $a 被“创建”并赋值为 null
$b = array();
foo($b['b']);
var_dump(array_key_exists('b', $b)); // bool(true)
$c = new stdClass();
foo($c->d);
var_dump(property_exists($c, 'd')); // bool(true)
?>
相同的语法可以用于返回引用的函数
<?php
$foo =& find_var($bar);
?>对不返回引用的函数使用相同的语法将导致错误，对new运算符的结果使用相同的语法也会导致错误。尽管对象作为指针传递，但这与引用不同，如对象和引用中所述。
如果将对在函数内声明为global的变量的引用赋值给另一个变量，则该引用仅在函数内部可见。可以使用$GLOBALS数组来避免这种情况。
示例 #2 在函数内部引用全局变量
<?php
$var1 = "Example variable";
$var2 = "";
function global_references($use_globals)
{
global $var1, $var2;
if (!$use_globals) {
$var2 =& $var1; // 仅在函数内部可见
} else {
$GLOBALS["var2"] =& $var1; // 也在全局上下文中可见
}
}
global_references(false);
echo "var2 is set to '$var2'\n"; // var2 is set to ''
global_references(true);
echo "var2 is set to '$var2'\n"; // var2 is set to 'Example variable'
?>global $var;视为$var =& $GLOBALS['var'];的快捷方式。因此，将另一个引用赋值给$var只会更改局部变量的引用。
注意:
如果在foreach语句中向带有引用的变量赋值，则引用也会被修改。
示例 #3 引用和 foreach 语句
<?php
$ref = 0;
$row =& $ref;
foreach (array(1, 2, 3) as $row) {
// 执行某些操作
}
echo $ref; // 3 - 迭代数组的最后一个元素
?>
虽然不严格是按引用赋值，但使用语言结构array()创建的表达式也可以通过在要添加的数组元素前加上&来实现类似的效果。示例
<?php
$a = 1;
$b = array(2, 3);
$arr = array(&$a, &$b[0], &$b[1]);
$arr[0]++;
$arr[1]++;
$arr[2]++;
/* $a == 2, $b == array(3, 4); */
?>但是，需要注意的是，数组中的引用可能会带来潜在的危险。对引用右边的值进行普通赋值（非引用赋值）不会使左边也变成引用，但数组内部的引用在这些普通赋值中会保留。这同样适用于按值传递数组的函数调用。示例
<?php
/* 标量变量的赋值 */
$a = 1;
$b =& $a;
$c = $b;
$c = 7; // $c 不是引用；不会改变 $a 或 $b
/* 数组变量的赋值 */
$arr = array(1);
$a =& $arr[0]; // $a 和 $arr[0] 在同一个引用集中
$arr2 = $arr; // 不是引用赋值！
$arr2[0]++;
/* $a == 2, $arr == array(2) */
/* 即使它不是引用，$arr 的内容也会改变！ */
?>引用的第二个作用是按引用传递变量。这是通过在函数中创建一个局部变量，并使该变量与调用范围中的变量引用相同的内容来实现的。示例
<?php
function foo(&$var)
{
$var++;
}
$a=5;
foo($a);
?>引用的第三个作用是按引用返回。
在使用 pbaltz at NO_SPAM dot cs dot NO_SPAM dot wisc dot edu 下面示例的扩展版本时，我遇到了一些问题。
这可能有点令人困惑，但如果您仔细阅读了手册，就会非常清楚。它清楚地说明了引用总是指向变量内容的事实（至少对我来说是这样）。
<?php
$a = 1;
$c = 2;
$b =& $a; // $b 指向 1
$a =& $c; // $a 现在指向 2，但 $b 仍然指向 1；
echo $a, " ", $b;
// 输出：2 1
?>使用引用还是值很重要
在这里我们使用的是值，因此对引用的操作也会更新原始变量；
$a = 1;
$c = 22;
$b = & $a;
echo "$a, $b"; //输出：1, 1
$b++;
echo "$a, $b";//输出：2, 2 两个值都已更新
$b = 10;
echo "$a, $b";//输出：10, 10 两个值都已更新
$b =$c; //这将值 2 赋值给 $b，这也更新了 $a
echo "$a, $b";//输出：22, 22
但是，如果您不使用 $b=$c，而是使用
$b = &$c; //只有 $b 的值被更新，$a 仍然指向 10，$b 现在充当变量 $c 的引用
echo "$a, $b"//输出：10, 22注意这一点
foreach ($somearray as &$i) {
// 更新一些 $i...
}
...
foreach ($somearray as $i) {
// $somearray 的最后一个元素被神秘地覆盖了！
}
问题是，在第一个 foreach 循环之后，$i 包含对 $somearray 最后一个元素的引用，第二个 foreach 循环会高兴地对其进行赋值！引用似乎会有副作用。下面是两个例子。两者都只是将一个数组复制到另一个数组。在第二个例子中，在复制之前，对第一个数组中的一个值进行了引用。在第一个例子中，索引 0 处的值指向两个不同的内存位置。在第二个例子中，索引 0 处的值指向同一个内存位置。
我不会说这是一个 bug，因为我不知道 PHP 的设计行为是什么，但我认为任何开发者都不会期望这种行为，所以要注意。
一个可能导致问题的例子是，如果在脚本中进行数组复制并期望某种行为，但随后在脚本中较早地向数组中的值添加引用，然后发现数组复制行为意外地发生了变化。
<?php
// 示例一
$arr1 = array(1);
echo "\nbefore:\n";
echo "\$arr1[0] == {$arr1[0]}\n";
$arr2 = $arr1;
$arr2[0]++;
echo "\nafter:\n";
echo "\$arr1[0] == {$arr1[0]}\n";
echo "\$arr2[0] == {$arr2[0]}\n";
// 示例二
$arr3 = array(1);
$a =& $arr3[0];
echo "\nbefore:\n";
echo "\$a == $a\n";
echo "\$arr3[0] == {$arr3[0]}\n";
$arr4 = $arr3;
$arr4[0]++;
echo "\nafter:\n";
echo "\$a == $a\n";
echo "\$arr3[0] == {$arr3[0]}\n";
echo "\$arr4[0] == {$arr4[0]}\n";
?>一些第一眼可能看不出来的地方
如果您想使用引用遍历数组，则不能使用简单的值赋值 foreach 控制结构。您必须使用扩展的键值赋值 foreach 或 for 控制结构。
简单的值赋值 foreach 控制结构会产生对象或值的副本。以下代码
$v1=0;
$arrV=array(&$v1,&$v1);
foreach ($arrV as $v)
{
$v1++;
echo $v."\n";
}
会产生
0
1
这意味着 foreach 中的 $v 不是对 $v1 的引用，而是数组中实际元素所引用的对象的副本。
代码
$v1=0;
$arrV=array(&$v1,&$v1);
foreach ($arrV as $k=>$v)
{
$v1++;
echo $arrV[$k]."\n";
}
和
$v1=0;
$arrV=array(&$v1,&$v1);
$c=count($arrV);
for ($i=0; $i<$c;$i++)
{
$v1++;
echo $arrV[$i]."\n";
}
都会产生
1
2
因此会遍历原始对象（都是 $v1），这正是我们想要的。
（使用 php 4.1.3 测试）回复 ' elrah [] polyptych [dot] com '，需要注意的一点是，数组（或类似的大型数据持有者）默认情况下是按引用传递的。因此，这种行为不是副作用。并且对于数组复制和在函数内部传递数组，总是按“按引用传递”方式进行……在 PHP 中，如果您想在程序中共享对象，实际上不再需要指针了
<?php
类 foo{
保护 $name;
函数 __construct($str){
$this->name = $str;
}
函数 __toString(){
返回 '我的名字是 "'. $this->name .'"，我住在 "' . __CLASS__ . '".' . "\n";
}
函数 setName($str){
$this->name = $str;
}
}
类 MasterOne{
保护 $foo;
函数 __construct($f){
$this->foo = $f;
}
函数 __toString(){
返回 'Master: ' . __CLASS__ . ' | foo: ' . $this->foo . "\n";
}
函数 setFooName($str){
$this->foo->setName( $str );
}
}
类 MasterTwo{
保护 $foo;
函数 __construct($f){
$this->foo = $f;
}
函数 __toString(){
返回 'Master: ' . __CLASS__ . ' | foo: ' . $this->foo . "\n";
}
函数 setFooName($str){
$this->foo->setName( $str );
}
}
$bar = new foo('bar');
print("\n");
print("只创建了 \$bar 并打印 \$bar\n");
print( $bar );
print("\n");
print("现在 \$baz 引用了 \$bar，并打印 \$bar 和 \$baz\n");
$baz =& $bar;
print( $bar );
print("\n");
print("现在创建 MasterOne 和 Two，并将 \$bar 传递给两个构造函数\n");
$m1 = new MasterOne( $bar );
$m2 = new MasterTwo( $bar );
print( $m1 );
print( $m2 );
print("\n");
print("现在更改 \$bar 的值，并打印 \$bar 和 \$baz\n");
$bar->setName('baz');
print( $bar );
print( $baz );
print("\n");
print("现在再次打印 MasterOne 和 Two\n");
print( $m1 );
print( $m2 );
print("\n");
print("现在更改 MasterTwo 的 foo 名称，并再次打印 MasterOne 和 Two\n");
$m2->setFooName( 'MasterTwo 的 Foo' );
print( $m1 );
print( $m2 );
print("也打印 \$bar 和 \$baz\n");
print( $bar );
print( $baz );
?>指向我下面发布的内容。
当你在循环中使用引用时，你需要 unset($var)。
例如
<?php
foreach($var as &$value)
{
…
}
unset($value);
?>关于数组引用的示例。
我认为这应该也写在数组章节中。
确实，如果你在某种程度上不熟悉编程语言，你应该注意数组是指向字节向量（Byte(s)）的指针。
<?php $arr = array(1); ?>
这里的 $arr 包含一个指向数组所在位置的引用。
编写
<?php echo $arr[0]; ?>
取消数组的引用以访问其第一个元素。
现在，你应该也注意到的（即使你不熟悉编程语言）是 PHP 使用引用来包含数组的不同值。这是有意义的，因为 PHP 数组元素的类型可以不同。
考虑以下示例
<?php
$arr = array(1, 'test');
$point_to_test =& $arr[1];
$new_ref = 'new';
$arr[1] =& $new_ref;
echo $arr[1]; // 输出 'new';
echo $point_to_test; // 输出 'test'！（仍然指向内存中的某个位置）
?>回复 lars at riisgaardribe dot dk,
当复制变量时，在修改副本之前，内部使用引用。因此，在你的情况下，你不应该使用引用，因为它不会节省任何内存，并且会增加逻辑错误的可能性，正如你发现的那样。针对帖子“php at hood dot id dot au 04-Mar-2007 10:56”的解决方案
<?php
$a1 = array('a'=>'a');
$a2 = array('a'=>'b');
foreach ($a1 as $k=>&$v)
$v = 'x';
echo $a1['a']; // 将输出 x
unset($GLOBALS['v']);
foreach ($a2 as $k=>$v)
{}
echo $a1['a']; // 将输出 x
?>我认为我的上一篇文章需要更正。
当有构造函数时，在我上一篇文章中提到的奇怪行为不会发生。我猜想 php 将 reftest() 当作构造函数（可能是因为它第一个函数？），并在实例化时运行它。
<?php
类 reftest
{
public $a = 1;
public $c = 1;
public function __construct()
{
return 0;
}
public function reftest()
{
$b =& $this->a;
$b++;
}
public function reftest2()
{
$d =& $this->c;
$d++;
}
}
$reference = new reftest();
$reference->reftest();
$reference->reftest2();
echo $reference->a; // 输出 2。
echo $reference->c; // 输出 2。
?>在这个例子中，类名与它的第一个函数名不同，但是没有构造函数。最终，正如你所猜到的，“a”和“c”是相等的。所以，如果同时没有构造函数且类名和它的第一个函数名相同，“a”和“c”将永远不相等。我认为，只要函数名与类名不同，PHP就不会寻找任何构造函数。
<?php
类 reftest_new
{
public $a = 1;
public $c = 1;
public function reftest()
{
$b =& $this->a;
$b++;
}
public function reftest2()
{
$d =& $this->c;
$d++;
}
}
$reference = new reftest_new();
$reference->reftest();
$reference->reftest2();
echo $reference->a; // 输出 2.
echo $reference->c; // 输出 2.
?>引用变量的顺序很重要。
<?php
$a1 = "One";
$a2 = "Two";
$b1 = "Three";
$b2 = "Four";
$b1 =& $a1;
$a2 =& $b2;
echo $a1; // 输出 "One"
echo $b1; // 输出 "One"
echo $a2; // 输出 "Four"
echo $b2; // 输出 "Four"
?>如果你在将变量传递给以引用方式接收变量的函数之前设置了该变量，那么在函数内编辑该变量将变得非常困难（如果不是不可能的话）。
示例
<?php
function foo(&$bar) {
$bar = "hello\n";
}
foo($unset);
echo($unset);
foo($set = "set\n");
echo($set);
?>
输出
hello
set
这让我很困惑，但事实就是这样。回复 Drewseph 使用 foo($a = 'set'); 其中 $a 是一个引用形式参数。
$a = 'set' 是一个表达式。表达式不能以引用方式传递，你难道不讨厌这个吗？我讨厌。
解决方法：$a = 'set'; foo($a); 这可以实现你的目的。这是一个关于引用的很好的小例子。这是我理解它的最佳方式，希望能帮助到其他人。
$b = 2;
$a =& $b;
$c = $a;
echo $c;
// 然后... $c = 2在类中使用引用时，可以引用 $this-> 变量。
<?php
类 reftest
{
public $a = 1;
public $c = 1;
public function reftest()
{
$b =& $this->a;
$b = 2;
}
public function reftest2()
{
$d =& $this->c;
$d++;
}
}
$reference = new reftest();
$reference->reftest();
$reference->reftest2();
echo $reference->a; // 输出 2。
echo $reference->c; // 输出 2。
?>
然而，这似乎并不完全可靠。在某些情况下，它可能会表现得很奇怪。
<?php
类 reftest
{
public $a = 1;
public $c = 1;
public function reftest()
{
$b =& $this->a;
$b++;
}
public function reftest2()
{
$d =& $this->c;
$d++;
}
}
$reference = new reftest();
$reference->reftest();
$reference->reftest2();
echo $reference->a; // 输出 3。
echo $reference->c; // 输出 2。
?>
在这个第二个代码块中，我已经修改了 reftest()，使 $b 增加而不是仅仅更改为 2。不知何故，它最终等于 3 而不是它应该的 2。我今天在 foreach 中使用引用时发现了一些东西。
<?php
$a1 = array('a'=>'a');
$a2 = array('a'=>'b');
foreach ($a1 as $k=>&$v)
$v = 'x';
echo $a1['a']; // 将输出 x
foreach ($a2 as $k=>$v)
{}
echo $a1['a']; // 将输出 b (!)
?>
阅读手册后，这看起来像是预期的行为。但这让我困惑了好几天！
（我使用的解决方案是将第二个 foreach 也转换为引用）引用的一种有趣但略显另类的用法：创建具有任意维度的数组。
例如，一个函数接收数据库的结果集并生成一个多维数组，其键根据一个（或多个）列进行索引。如果您希望以分层方式访问结果集，或者只是希望结果集以每一行主键/唯一键字段的值作为键，这将非常有用。
<?php
function array_key_by($data, $keys, $dupl = false)
/*
* $data - 要进行键索引的多维数组
* $keys - 包含要使用的索引/键的列表。
* $dupl - 如何处理包含相同值的行的处理方式。TRUE 存储为数组，FALSE 覆盖前一行。
*
* 返回一个由 $keys 索引的多维数组，如果出错则返回 NULL。
* 维数等于提供的 $keys 的数量（如果 $dupl=TRUE 则加 1）。
*/
{
// 健全性检查
if (!is_array($data)) return null;
// 允许将单个键作为标量传递
if (is_string($keys) or is_integer($keys)) $keys = Array($keys);
elseif (!is_array($keys)) return null;
// 输出数组
$out = Array();
// 循环遍历输入 $data 的每一行
foreach($data as $cx => $row) if (is_array($row))
{
// 循环遍历 $keys
foreach($keys as $key)
{
$value = $row[$key];
if (!isset($last)) // 只有第一个 $key
{
if (!isset($out[$value])) $out[$value] = Array();
$last =& $out; // 将 $last 绑定到 $out
}
else // 第二个和后续的 $key....
{
if (!isset($last[$value])) $last[$value] = Array();
}
// 将 $last 绑定到更深的一维。
// 第一轮：是 &$out，现在是 &$out[...]
// 第二轮：是 &$out[...]，现在是 &$out[...][...]
// 第三轮：是 &$out[...][...]，现在是 &$out[...][...][...]
// （等等）
$last =& $last[$value];
}
if (isset($last))
{
// 在这一点上，将 $row 复制到我们的输出数组中
if ($dupl) $last[$cx] = $row; // 保留之前的
else $last = $row; // 覆盖之前的
}
unset($last); // 打破引用
}
else return NULL;
// 完成
return $out;
}
// 用于测试函数的示例结果集
$data = Array(Array('name' => 'row 1', 'foo' => 'foo_a', 'bar' => 'bar_a', 'baz' => 'baz_a'),
Array('name' => 'row 2', 'foo' => 'foo_a', 'bar' => 'bar_a', 'baz' => 'baz_b'),
Array('name' => 'row 3', 'foo' => 'foo_a', 'bar' => 'bar_b', 'baz' => 'baz_c'),
Array('name' => 'row 4', 'foo' => 'foo_b', 'bar' => 'bar_c', 'baz' => 'baz_d')
);
// 首先，让我们按一列进行键索引（结果：二维数组）
print_r(array_key_by($data, 'baz'));
// 或者，按两列进行键索引（结果：三维数组）
print_r(array_key_by($data, Array('baz', 'bar')));
// 我们也可以按三列进行键索引（结果：四维数组）
print_r(array_key_by($data, Array('baz', 'bar', 'foo')));
?>因此，要创建一个按引用设置器函数，需要在参数列表和赋值中都指定引用语义，如下所示
class foo{
var $bar;
function setBar(&$newBar){
$this->bar =& $newBar;
}
}
忘记任何一个“&” ，$foo->bar 在调用 setBar 后将成为一个副本。这似乎是隐藏的行为：当类函数与类名相同时，在创建类的对象时，它似乎会被隐式调用。
例如，您可以查看函数“reftest()”的命名：它位于“reftest”类中。该行为可以如下测试
<?php
class reftest
{
public $a = 1;
public $c = 1;
public function reftest1()
{
$b =& $this->a;
$b++;
}
public function reftest2()
{
$d =& $this->c;
$d++;
}
public function reftest()
{
echo "REFTEST() called here!\n";
}
}
$reference = new reftest();
/*请注意，上面也会隐式调用 reference->reftest()*/
$reference->reftest1();
$reference->reftest2();
echo $reference->a."\n"; //输出 2，而不是之前注意到的 3。
echo $reference->c."\n"; //输出 2。
?>
以上输出
REFTEST() called here!
2
2
请注意，reftest() 似乎被调用了（尽管没有对其进行显式调用）！到目前为止尚未讨论的是引用的引用。
我需要一种快速简便的方法来为不正确的命名创建别名，直到可以进行适当的重写。
希望这能为其他人节省测试时间，因为它没有在“是/否/不是”页面中介绍。
远非最佳实践，但它有效。
<?php
$a = 0;
$b =& $a;
$a =& $b;
$a = 5;
echo $a . ', ' . $b;
//输出：5,5
echo ' | ';
$b = 6;
echo $a . ',' . $b;
//输出：6,6
echo ' | ';
unset( $a );
echo $a . ', ' . $b;
//输出： , 6
class Product {
public $id;
private $productid;
public function __construct( $id = null ) {
$this->id =& $this->productid;
$this->productid =& $this->id;
$this->id = $id;
}
public function getProductId() {
return $this->productid;
}
}
echo ' | ';
$Product = new Product( 1 );
echo $Product->id . ', ' . $Product->getProductId();
//输出 1, 1
$Product->id = 2;
echo ' | ';
echo $Product->id . ', ' . $Product->getProductId();
//输出 2, 2
$Product->id = null;
echo ' | ';
echo $Product->id . ', ' . $Product->getProductId();
//输出 , 