references.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<!-- EN-Revision: f4f96ef8b2a95283c92ea2183fe1dedf06f3ad22 Maintainer: Altair Status: ready -->
<!-- CREDITS: dallas, Luffy -->
<chapter xml:id="language.references" xmlns="http://docbook.org/ns/docbook">
 <title>引用的解释</title>

 <sect1 xml:id="language.references.whatare">
  <title>引用是什么</title>
  <simpara>
   在 PHP 中引用意味着用不同的名字访问同一个变量内容。这并不像 C
   的指针：例如你不能对他们做指针运算，他们并不是实际的内存地址……
   查看<xref linkend="language.references.arent" />了解更多信息。
   替代的是，引用是<link linkend="features.gc.refcounting-basics">符号表</link>别名。
   注意在PHP 中，变量名和变量内容是不一样的，
   因此同样的内容可以有不同的名字。最接近的比喻是
   Unix 的文件名和文件本身——变量名是目录条目，而变量内容则是文件本身。引用可以被看作是
   Unix 文件系统中的硬链接。
  </simpara>
 </sect1>

 <sect1 xml:id="language.references.whatdo">
  <title>引用做什么</title>
  <para>
     使用引用执行有三种基本操作： <link linkend="language.references.whatdo.assign">引用赋值</link> 、
     <link linkend="language.references.whatdo.pass">传引用</link> 、
     <link linkend="language.references.whatdo.return">引用返回</link> 。
     本节介绍这些操作，并提供进一步阅读的链接。
  </para>
  <sect2 xml:id="language.references.whatdo.assign">
    <title>引用赋值</title>
    <para>
     PHP 的引用允许用两个变量来指向同一个内容。意思是，当这样做时：
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php

$a =& $b;

?>
]]>
      </programlisting>
     </informalexample>
     这意味着 <varname>$a</varname> 和 <varname>$b</varname> 指向了同一个变量。
     <note>
      <para>
       <varname>$a</varname> 和 <varname>$b</varname> 在这里是完全相同的，这并不是
       <varname>$a</varname> 指向了 <varname>$b</varname> 或者相反，而是
       <varname>$a</varname> 和 <varname>$b</varname> 指向了同一个地方。
      </para>
     </note>
    </para>
   <note>
    <para>
    如果对一个未定义的变量进行引用赋值、引用参数传递或引用返回，则会自动创建该变量。
     <example>
      <title>对未定义的变量使用引用</title>
      <programlisting role="php">
<![CDATA[
<?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)

?>
]]>
      </programlisting>
     </example>
    </para>
   </note>  
  <para>
   同样的语法可以用在返回引用的函数中：
   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php

$foo =& find_var($bar);

?>
]]>
    </programlisting>
   </informalexample>
  </para>
  <para>
     在函数内使用相同的语法 <emphasis>不</emphasis> 通过引用返回将会产生错误，
     就像将它与 <link linkend="language.oop5.basic.new">new</link> 运算符的结果一起使用一样。
     正如
     <link linkend="language.oop5.references">对象和引用</link> 中所述，
     尽管对象是通过指针传递的，但是它们与引用不同。
    </para>
  <warning>
   <para>
    如果在一个函数内部给一个声明为 <literal>global</literal>
    的变量赋于一个引用，该引用只在函数内部可见。可以通过使用
    <varname>$GLOBALS</varname> 数组避免这一点。
    <example>
     <title>在函数内引用全局变量</title>
     <programlisting role="php">
<![CDATA[
<?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'

?>
]]>
     </programlisting>
    </example>
    把 <literal>global $var;</literal> 当成是 <literal>$var
    =&amp; $GLOBALS['var'];</literal> 的简写。从而将其它引用赋给
    <literal>$var</literal> 只改变了本地变量的引用。
   </para>
  </warning>
  <note>
   <para>
    如果在 &foreach;
    语句中给一个具有引用的变量赋值，被引用的对象也被改变。
    <example>
     <title>引用与 foreach 语句</title>
     <programlisting role="php">
<![CDATA[
<?php

$ref = 0;
$row =& $ref;

foreach (array(1, 2, 3) as $row) {
    // 做点什么
}

echo $ref; // 3 - 迭代数组的最后一个元素

?>
]]>
     </programlisting>
    </example>
   </para>
  </note>
    <para>
      虽然不是严格意义上的引用赋值，但使用语言构造
      <link linkend="function.array"><literal>array()</literal></link>
      创建的表达式也可以通过在要添加的数组元素加上 <literal>&amp;</literal> 
      前缀来表现为这样。例如：
      <informalexample>
        <programlisting role="php">
          <![CDATA[
<?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); */

?>
]]>
        </programlisting>
      </informalexample>
    </para>
    <para>
      但是请注意，数组内的引用具有潜在的危险。
      在右侧引用正常的赋值（不是通过引用）不会将左侧变为引用，
      但是数组内部的引用会保留在这些正常赋值中。
      这也适用于调用函数时按值传递数组的情况。例如：
      <informalexample>
        <programlisting role="php">
          <![CDATA[
<?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 不是引用，但是它的内容已经更改！ */

?>
]]>
        </programlisting>
      </informalexample>
      换句话说，数组的引用行为是在逐个元素的基础上定义；
      单个元素的引用行为与数组容器的引用状态分离。
    </para>
  </sect2>
  <sect2 xml:id="language.references.whatdo.pass">
  <title>传引用</title>
  <para>
   引用做的第二件事是用引用传递变量。这是通过在函数内建立一个本地变量并且该变量在呼叫范围内引用了同一个内容来实现的。例如：
   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var++;
}

$a=5;
foo($a);

?>
]]>
    </programlisting>
   </informalexample>
   将使 <varname>$a</varname> 变成 6。这是因为在 <varname>foo</varname> 函数中变量
   <varname>$var</varname> 指向了和 <varname>$a</varname> 指向的同一个内容。更多详细解释见<link
   linkend="language.references.pass">引用传递</link>。
  </para>
  </sect2>
  <sect2 xml:id="language.references.whatdo.return">
   <title>引用返回</title>
  <para>
   引用做的第三件事是<link linkend="language.references.return">引用返回</link>。
  </para>
  </sect2>
 </sect1>

 <sect1 xml:id="language.references.arent">
  <title>引用不是什么</title>
  <para>
   如前所述，引用不是指针。这意味着下面的结构不会产生预期的效果：
   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var =& $GLOBALS["baz"];
}

foo($bar);

?>
]]>
    </programlisting>
   </informalexample>
  </para>
  <simpara>
   这将使 <varname>foo</varname> 函数中的 <varname>$var</varname> 变量在函数调用时和
   <varname>$bar</varname> 绑定在一起，但接着又被重新绑定到了
   <varname>$GLOBALS["baz"]</varname> 上面。不可能通过引用机制将 <varname>$bar</varname>
   在函数调用范围内绑定到别的变量上面，因为在函数 <varname>foo</varname> 中并没有变量
   <varname>$bar</varname>（它被表示为 <varname>$var</varname>，但是 <varname>$var</varname>
   只有变量内容而没有调用<link linkend="features.gc.refcounting-basics">符号表</link>中的名字到值的绑定）。可以使用<link
   linkend="language.references.return">引用返回</link>来引用被函数选择的变量。
  </simpara>
 </sect1>

 <sect1 xml:id="language.references.pass">
  <title>引用传递</title>
  <para>
   可以将一个变量通过引用传递给函数，这样该函数就可以修改其参数的值。语法如下：
   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var++;
}

$a=5;

foo($a);
// 这里 $a 是 6

?>
]]>
    </programlisting>
   </informalexample>
   注意在函数调用时没有引用符号——只有函数定义中有。光是函数定义就足够使参数通过引用来正确传递了。
  </para>
  <para>
  以下内容可以通过引用传递：
   <itemizedlist>
    <listitem>
     <simpara>
      变量，例如 <literal>foo($a)</literal>
     </simpara>
    </listitem>
    <listitem>
     <para>
      从函数中返回的引用，例如：
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var++;
}

function &bar()
{
    $a = 5;
    return $a;
}

foo(bar());

?>
]]>
     </programlisting>
    </informalexample>
    详细解释见<link linkend="language.references.return">引用返回</link>。
     </para>
    </listitem>
  </itemizedlist>
  </para>
  <para>
  任何其它表达式都不能通过引用传递，结果未定义。例如下面引用传递的例子是无效的：
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var++;
}

function bar() // 注意缺少 &
{
    $a = 5;
    return $a;
}

foo(bar()); // 导致 notice 信息

foo($a = 5) // 表达式，不是变量
foo(5) // 导致致命错误

class Foobar {}

foo(new Foobar()) // 自 PHP 7.0.7 起生成通知
                  // 注意：只有变量应该通过引用传递

?>
]]>
     </programlisting>
    </informalexample>
  </para>
 </sect1>

 <sect1 xml:id="language.references.return">
  <title>引用返回</title>
  <para>
   引用返回用在当想用函数找到引用应该被绑定在哪一个变量上面时。
    <emphasis>不要</emphasis>用返回引用来增加性能，引擎足够聪明来自己进行优化。
    仅在有合理的技术原因时才返回引用！
    使用此语法返回引用：
   <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
class Foo
{
    public $value = 42;

    public function &getValue()
    {
        return $this->value;
    }
}

$obj = new Foo();
$myValue = &$obj->getValue(); // $myValue 是对 $obj->value 的引用，即 42
$obj->value = 2;
echo $myValue;                // 打印 $obj->value 的新值，即 2

?> 
]]>
     </programlisting>
   </informalexample>
   本例中 <varname>getValue</varname> 函数所返回的对象的属性将被赋值，
    而不是拷贝，就和没有用引用语法一样。
  </para>
  <note>
   <simpara>
    和参数传递不同，这里必须在两个地方都用 <literal>&amp;</literal>
    符号——指出返回的是一个引用，而不是通常的一个拷贝，同样也指出 <varname>$myValue</varname>
    是作为引用的绑定，而不是通常的赋值。
   </simpara>
  </note>
  <note>
   <simpara>
    如果试图这样从函数返回引用：<literal>return
    ($this->value);</literal>，这将<emphasis>不会</emphasis>起作用，
     因为在试图返回一个<emphasis>表达式</emphasis>的结果而不是一个引用的变量。
     只能从函数返回引用变量——没别的方法。
   </simpara>
  </note>
   <para>
     要使用返回的引用，必须使用引用赋值：
     <informalexample>
       <programlisting role="php">
         <![CDATA[
<?php
function &collector()
{
    static $collection = array();
    return $collection;
}

$collection = &collector();
$collection[] = 'foo';

?>
]]>
       </programlisting>
     </informalexample>
     要将返回的引用传递给另外一个需要引用的函数，可以使用如下语法：
     <informalexample>
       <programlisting role="php">
         <![CDATA[
<?php
function &collector()
{
    static $collection = array();
    return $collection;
}

array_push(collector(), 'foo');

?>
]]>
       </programlisting>
     </informalexample>
   </para>
   <note>
     <simpara>
       注意 <literal>array_push(&amp;collector(), 'foo');</literal> 将 
       <emphasis>不</emphasis> 起作用，它会导致 Fatal 错误。
     </simpara>
   </note>
 </sect1>

 <sect1 xml:id="language.references.unset">
  <title>取消引用</title>
  <para>
   当 unset 一个引用，只是断开了变量名和变量内容之间的绑定。这并不意味着变量内容被销毁了。例如：
   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php

$a = 1;
$b =& $a;
unset($a);

?>
]]>
    </programlisting>
   </informalexample>
   不会 unset <varname>$b</varname>，只是 <varname>$a</varname>。
  </para>
  <simpara>
   再拿这个和 Unix 的 <command>unlink</command> 调用来类比一下可能有助于理解。
  </simpara>
 </sect1>

 <sect1 xml:id="language.references.spot">
  <title>引用定位</title>
  <simpara>
   许多 PHP 的语法结构是通过引用机制实现的，所以上述有关引用绑定的一切也都适用于这些结构。
    一些结构，例如引用传递和返回，已经在上面提到了。
    其它使用引用的结构有：
  </simpara>

  <sect2 xml:id="references.global">
   <title>global 引用</title>
   <para>
    当用 <command>global $var</command> 声明一个变量时实际上建立了一个到全局变量的引用。
     也就是说和这样做是相同的：
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

$var =& $GLOBALS["var"];

?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    这意味着，例如，unset <varname>$var</varname> 不会 unset 全局变量。
   </simpara>
  </sect2>

  <sect2 xml:id="references.this">
   <title><literal>$this</literal></title>
   <simpara>
    在一个对象的方法中，<varname>$this</varname> 永远是调用它的对象的引用。
   </simpara>
  </sect2>
 </sect1>

</chapter>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->