language basic-syntax.xml constants.xml control-structures.xml expressions.xml functions.xml oop.xml operators.xml references.xml types.xml variables.xml

Glace Cheung Sun, 08 Apr 2001 02:56:57 -0700

glace           Sun Apr  8 03:13:57 2001 EDT

  Added files:                 
    /phpdoc/hk/language basic-syntax.xml constants.xml 
                        control-structures.xml expressions.xml 
                        functions.xml oop.xml operators.xml 
                        references.xml types.xml variables.xml 
  Log:
  use xml


Index: phpdoc/hk/language/basic-syntax.xml
+++ phpdoc/hk/language/basic-syntax.xml
  <chapter id="language.basic-syntax">
   <title>基本句法</title>

   <sect1 id="language.basic-syntax.phpmode">
    <title>進入 PHP 語言模式</title>
  
    <para>
     在 HTML 文件中插入 PHP 的指令共有四種方法: </para>

    <para>
     <example>
      <title>Ways of escaping from HTML</title>
      <programlisting>
1.  &lt;? echo ("this is the simplest, an SGML processing instruction\n"); ?&gt;
 
2.  &lt;?php echo("if you want to serve XHTML or XML documents, do like this\n"); ?&gt;

3.  &lt;script language="php"&gt; 
        echo ("some editors (like FrontPage) don't
              like processing instructions");
    &lt;/script&gt;

4.  &lt;% echo ("You may optionally use ASP-style tags"); %&gt;
    &lt;%= $variable; # This is a shortcut for "&lt;%echo .." %&gt;
      </programlisting>
     </example>
    </para>

    <para>
     上面列出的方法中第一種只當 PHP 被設定成接受 "短標籤" 時才會有效。 設定方法可以
     <!-- via the <function>short_tags</function> function,-->在調設文件 PHP.INI 中把
     <link linkend="ini.short-open-tag">short_open_tag</link>
     設為真值， 或者在編譯 PHP 時執行    <command>configure</command>
時加入 --enable-short-tags 這個選項。
    </para>

    <para>
     The second way is the generally preferred method, as it allows for the
     next generation of XHTML to be easily implemented with PHP.
    </para>

    <para>
     第四種方法也只有當 ASP 形態的標籤 被允許時才有效。 這需要調設 
<link linkend="ini.asp-tags">asp_tags</link>
這個參數。 

    <note>
     <para>對 ASP-style 標籤的支援從 PHP 第 3.0.4 版開始.</para>
    </note></para>

    <para>
程式段的結束標記將會包括跟隨在其後的換行符號。 (假如有換行符號的話。) 
</para></sect1>

   <sect1 id="language.basic-syntax.instruction-separation">
    <title>分隔指令</title>

    <simpara>
    PHP 各指令行之間的分隔方法和 C、 PERL 是一樣的。 - 每行指令間用分號 ";" 分開。 
</simpara>

    <para>
     由於程式段結束標籤同樣代表指令結束， 因此以下的兩段程式是效果是一樣的。 
     <informalexample>
      <programlisting>
&lt;?php
    echo "This is a test";
?>

&lt;?php echo "This is a test" ?>
      </programlisting>
     </informalexample></para></sect1>

   <sect1 id="language.basic-syntax.comments">
    <title>加注釋的方法</title>
   
    <para>
     PHP 上可以用 C、 C++、 和 Unix shell 的注釋方法。 在注釋號內的內容將被 PHP 
解釋器忽略。 比如說 : 

    <informalexample><programlisting>
&lt;?php
    echo "This is a test"; // This is a one-line c++ style comment
    /* This is a multi line comment
       yet another line of comment */
    echo "This is yet another test";
    echo "One Final Test"; # This is shell-style style comment
?>
     </programlisting>
    </informalexample></para>

    <simpara>
    至於那種只注解一行的注釋符號的作用範圍只會在本行內有效。 ( 如本行中同時出現 PHP 
程弍段結束符號 "?>" 則在符號後的文字將不會被忽略。)</simpara>
    <informalexample><programlisting>
&lt;h1>This is an &lt;?php # echo "simple";?> example.&lt;/h1>
&lt;p>The header above will say 'This is an example'.
</programlisting></informalexample> 

    <simpara>
如果是 C 的格式來做注釋， 注意不要像下例般在注釋中再加注釋， 否則會造成錯誤。

</simpara>

    <informalexample><programlisting>
&lt;?php
 /* 
    echo "This is a test"; /* This comment will cause a problem */
 */
?>
    </programlisting></informalexample></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
 sgml-parent-document:nil
 sgml-default-dtd-file:"../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->

Index: phpdoc/hk/language/constants.xml
+++ phpdoc/hk/language/constants.xml
 <chapter id="language.constants">
  <title>常數</title>

  <simpara>
   PHP 自己提供了一些常數， 也允許程式執行時另外再定義各種常數。常數和變數很相似， 
它們之間只有兩個分別： 首先常必須用 
   <function>define</function> 函數來定義， 另外就是一旦定義後常數的值不可改變。
  </simpara>

  <para>
   系統內預先定義的常數包括: 
   <variablelist>

    <varlistentry>
     <term>__FILE__</term>
     <listitem>
      <simpara>
       儲存了目前正被執行的文件的名字。 如果用在被 include() 或 require() 的文件之中， 
則儲存了母文件的名字而非被 include() 或 reuqire() 文件的名字。
      </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>__LINE__</term>
     <listitem>
      <simpara>
      現在正在被分析/解析的指令行。 如果指令是在被 include() 或 require() 的文件中， 
則儲存指令在該子文件中的行號。 

      </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>PHP_VERSION</term>
     <listitem>
      <simpara>
       以文句的型態儲存了現時 PHP 的版本。 例如 '3.0.8-dev'. 

      </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>PHP_OS</term>
     <listitem>
      <simpara>
       運行 PHP 的作業系統， 如 'Linux'.       </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>TRUE</term>
     <listitem>
      <simpara>
       代表邏輯值真/是。 
      </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>FALSE</term>
     <listitem>
      <simpara>
       代表邏輯值假/非。 
      </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>E_ERROR</term>
     <listitem>
      <simpara>
       代表出現了並非解析上的錯誤並引致程式無法繼續執行下去。       </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>E_WARNING</term>
     <listitem>
      <simpara>
      代表出現了警兆但 PHP 會繼續執行程式。 這樣的警兆可用程式中捕捉。類似的例子如     
   <function>ereg</function>
中表達式弄錯了。 
      </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>E_PARSE</term>
     <listitem>
      <simpara>
解析器在分析指令行時發現了錯誤， 在這情況下無法回復程式的執行。 
      </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>E_NOTICE</term>
     <listitem>
      <simpara>
代表有些事不對勁， 可能是發生了錯誤也可能不是。 這類問題的例子有: 
用關聯字索引取用陣列時沒有把關聯字用引號括起來、 沒有指定變數的取用變數‧‧‧ 
      </simpara>
     </listitem>
    </varlistentry>
    
    <varlistentry>
     <term>E_ALL</term>
     <listitem>
      <simpara>
        ??
      </simpara>
     </listitem>
    </varlistentry>

   </variablelist>
  </para>

   <para>
      這些由 E_ 打頭的常數通常是和 
       <function>error_reporting</function>函數配合用來調整 error reporting level ， 
就是說調設有哪些錯誤會被處理， 有哪些會被忽略。 
         </para>

   <para>
    如要定義自己的常數， 請用 
    <function>define</function> 函數。 </para>
        
   <para>
        留心這都是常數而不是 C 風格的巨集： 常數只能儲存合法的數據。 
    <example>
     <title>設定 常數</title>
     <programlisting>
&lt;?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // outputs "Hello world."
?&gt;
     </programlisting>
    </example>

    <example>
     <title>__FILE__ 和 __LINE__ 的用法
</title>
     <programlisting>
&lt;?php
function report_error($file, $line, $message) {
    echo "An error occured in $file on line $line: $message.";
}

report_error(__FILE__,__LINE__, "Something went wrong!");
?&gt;
     </programlisting>
    </example></para>
        
  </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
 sgml-parent-document:nil
 sgml-default-dtd-file:"../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->

Index: phpdoc/hk/language/control-structures.xml
+++ phpdoc/hk/language/control-structures.xml
 <chapter id="control-structures">
  <title>控制程式的流程</title>

  <simpara>
  PHP 程式全都是由一句句的語句所構成。 語句可以指派變數的值、 調用函數、 執行迴圈、 
按條件分流程式甚至什麼也不做(空白語句)。 一句語句通常以 ';' 分號作結尾。 利用花括號 '{ 
}'可以把好多條語句組成一組， 這樣組成的語組它自己也是一句語句。 
本節會介紹各式各樣的語句類型。 
  </simpara>

  <sect1 id="control-structures.if">
   <title><literal>if</literal></title>
   <para>
if 是程式中語言中極其重要的組成部分， 對 PHP 不也不例外。 
它提供了按需要執行不同程式段的功能。 PHP 所用的 if 結構和 C 所用的沒什麼不同： 

    <informalexample>
     <programlisting>
if (expr)
    statement
     </programlisting>
    </informalexample>
   </para>
   <simpara>
if 是程式中語言中極其重要的組成部分， 對 PHP 不也不例外。 
它提供了按需要執行不同程式段的功能。 PHP 所用的 if 結構和 C 所用的沒什麼不同： 

   </simpara>
   <para>
以下範例會打出 a is bigger than b 如果 $a 的值比 $b的大: 

    <informalexample>
     <programlisting role="php">
if ($a > $b)
    print "a is bigger than b";
     </programlisting>
    </informalexample>
   </para>
   <para>
通常在決定了條件後你可能要執行多過一句指令， 當然你不必每個指令前都用一次 if ， 
你只需要把這些要執行的指令用 '{ }' 組成語組就行了。 好像以下的程式段會顯示出 a is 
bigger than b 如果 $a 比 $b 大， 同時會把 $a 的值抄到 $b中: 

    <informalexample>
     <programlisting role="php">
if ($a > $b) {
    print "a is bigger than b";
    $b = $a;
}
     </programlisting>
    </informalexample>
   </para>
   <simpara>
If 可以在別的 if 之內出現， 像這樣的情況稱為巢狀的 if， PHP 允許無限多的巢狀結構。 
如此你在編程式有很大的自由度來控制程式的流程。 

   </simpara>
  </sect1>
 
  <sect1 id="control-structures.else">
   <title><literal>else</literal></title>
   <para>
有時候你會有兩組指令， 一組在條件成立時執行， 另一組在條件不成立時執行。 這時用 else 
就方便很多了。 else 補充 if 的功能： 如果 if 語句中的表達式不成立時， if 
不會執行緊跟的指令組， 而會執行 else 之後的指令組。 像下面程式會打出 a is bigger than 
b 如果 $a 大過 $b， 反之則打出 a is NOT bigger than b : 

    <informalexample>
     <programlisting role="php">
if ($a > $b) {
    print "a is bigger than b";
} else {
    print "a is NOT bigger than b";
}
     </programlisting>
    </informalexample>

else 中的指令組只當 if 表達式演算的結果是假的時候才會被執行。如果還有別的 elseif 
表達式的話， 這些表達式的結果也要是假才行。(看下面) 
   </para>
  </sect1>
 
  <sect1 id="control-structures.elseif">
   <title><literal>elseif</literal></title>
   <para>
elseif， 一看就知道是if 和 else的混合體。 Like else一樣， 它補充了 if 語句的功能： 
它在 if 的條件不成立時才會執行。但和 else不一樣的是， elseif 除了要求 if 
的條件不成立， 它同時要求自己的條件成立，否則它不會執行跟著的程式段。 下列示範依 
$a、$b 的大小打出 a is bigger than b或 a equal to b 或 a is smaller than b: 

    <informalexample>
     <programlisting role="php">
if ($a > $b) {
    print "a is bigger than b";
} elseif ($a == $b) {
    print "a is equal to b";
} else {
    print "a is smaller than b";
}
     </programlisting>
    </informalexample>
   </para>
   <simpara>
可以有好幾個 elseif出現在同一個 if 語句中。 第一個成立的 elseif 會被執行。 編寫 PHP 
程式時你也可以用兩個字的 'else if' ， 這和單字的 'elseif' 是相同的。 
雖然兩者在句法的解釋上有不同，但所有的功能和結果都是沒有分別的。 (如你熟悉 C 的話， 
這和 C 的情況是一樣。) 

   </simpara>
   <simpara>
再提醒一次， elseif 中的指令組只有當它前面的 if 和其他的 elseif 
的條件不成立並且它自己的條件成立時才會被執行。 

   </simpara>
  </sect1>
 
  <sect1 id="control-structures.alternative-syntax">
   <title>等效句法</title>
   <para>
PHP 對於以下的條件句提供了另外一種寫法，這些語句包括：if、 while、 for、 switch。 
等效的寫法就是把指令組開頭的 '{' 括號變成冒號 ':'： 同時結尾的 '}' 分別變成 endif; 
endwhile; endfor; endswitch;。 

    <informalexample>
     <programlisting role="php">
 &lt;?php if ($a == 5): ?&gt;
 A is equal to 5
 &lt;?php endif; ?&gt;
     </programlisting>
    </informalexample>
   </para>
   <simpara>
在上述示範中， HTML 格式的句子 "A is equal to 5" 被包在一個 if 語句之中。 
這情況下只有當 $a 是 5 時該句子才被印出來。 

   </simpara>
   <para>
   等效的句法也可用在 else和 elseif 上。下面就是 if 加上 elseif 和 else 的等效寫法。 

    <informalexample>
     <programlisting role="php">
if ($a == 5):
    print "a equals 5";
    print "...";
elseif ($a == 6):
    print "a equals 6";
    print "!!!";
else:
    print "a is neither 5 nor 6";
endif;
     </programlisting>
    </informalexample>
   </para>
   <para>
另請看  <link linkend="control-structures.while">while</link>,
    <link linkend="control-structures.for">for</link>,  <link
    linkend="control-structures.if">if</link> 中的其他示範。 
   </para>
  </sect1>

  <sect1 id="control-structures.while">
   <title><literal>while</literal></title>
   <para>
while 迴圈是 PHP 裏最簡單的迴圈形式。 和 c 的 while 一樣， 它基本的句式是：     
<informalexample>
     <programlisting>
while (expr) statement
     </programlisting>
    </informalexample>
   </para>
   <simpara>
while 的意思很直接： 只要它的條件表達式成立， 它會叫 PHP 不停地執行 while 之內的指令。 
因為每次 while 之內的指令全部執行後都會檢查一次 while 條件是否依然成立， 
所以就算條件在指令之時已經改變， 
但都要等所有指令都完成後才會跳出迴圈。(每次執行完迴圈中所有的指令都叫做完成了一次循環) 
假如 while 表達式在一開始的時候就不成立，那 while 之中的指令根本不會被執行 
(零次循環)。 

   </simpara>
   <para>
和 if 一樣， 你可以把好多指令用 '{ }' 包起來放在while 迴圈之中。 你也可以用 while 
的等效句法來寫: 

    <informalexample>
     <programlisting>
while (expr): statement ... endwhile;
     </programlisting>
    </informalexample>
   </para>
   <para>
下面兩個示範將產生相同的結果： 把 1 到 10 印出來    <informalexample>
     <programlisting>
/* example 1 */

$i = 1;
while ($i &lt;= 10) {
    print $i++;  /* the printed value would be
                    $i before the increment
                    (post-increment) */
}
 
/* example 2 */
 
$i = 1;
while ($i &lt;= 10):
    print $i;
    $i++;
endwhile;
     </programlisting>
    </informalexample>
   </para>
  </sect1>
 
  <sect1 id="control-structures.do.while">
   <title><literal>迴圈</literal></title>
   <simpara>
do.while 迴圈 和 while 迴圈差不多，但它到最後才檢查執行條件是否成立。 這樣保證了 
do.while 中的指令起碼會被執行一次。 由於 while 是在一開頭便檢查條件， 所以用 while 
的話可能一次循環也執行不了。 

   </simpara>
   <para>
do.while 迴圈 只有一個句法， 沒有別的等效寫法 : 
 
    <informalexample>
     <programlisting role="php">
$i = 0;
do {
   print $i;
} while ($i>0);
     </programlisting>
    </informalexample>
   </para>
   <simpara>
上面的程式只會跑一次， 因為指令執行完了才檢查條件才發現原來條件不成立於是跳出迴圈。 
   </simpara>
   <para>
用 C 編程的高手可能懂得另一種 do.while 迴圈 的用法： 用  <link
    linkend="control-structures.break"><literal>break</literal></link>
指令和 do.while(0) 迴圈來使程式在執行中途終止。下列程式段示範這一個用法: 
    <informalexample>
     <programlisting role="php">
do {
    if ($i &lt; 5) {
        print "i is not big enough";
        break;
    }
    $i *= $factor;
    if ($i &lt; $minimum_limit) {
        break;
    }
    print "i is ok";

     ...process i...

} while(0);
     </programlisting>
    </informalexample>
   </para>
   <simpara>
縱使你看不出上面程式有什麼奧妙也沒關係。 就算不用 do.while 
的這個特性也一樣可以寫出功能很強的程式。 
   </simpara>
  </sect1>
 
  <sect1 id="control-structures.for">
   <title><literal>for 迴圈</literal></title>
   <para>
for 迴圈 可說是 PHP 中最複雜的迴圈類。它們的用法和在 C 中的用法並沒有分別: 

    <informalexample>
     <programlisting>
for (expr1; expr2; expr3) statement
     </programlisting>
    </informalexample>
   </para>
   <simpara>
首先第一個表達式 (expr1) 無論如何都會演算一次    </simpara>
   <simpara>
然後在每個循環開始前 expr2 都會被算出來， 如果得出結果成立的話， 
迴圈中的指令便被執行， 如果 expr2 不成立的話， 便會跳出迴圈。 
   </simpara>
   <simpara>
每一個循環完成之後電腦會演算一次 expr3。    </simpara>
   <simpara>
   三個表達式中任何一個都可以是空的。 expr2 空的話代表迴圈會無止境地執行下去。 (PHP 和 
C 一樣， 自動把空的表達式當成是成立的) 這聽上去很無聊， 但實際上你可能想在迴圈中用
<link
    linkend="control-structures.break"><literal>break</literal></link>
    的方式來結束。    </simpara>
   <para>
以下每一個例子都會顯示 1 到 10:     <informalexample>
     <programlisting role="php">
/* example 1 */
 
for ($i = 1; $i &lt;= 10; $i++) {
    print $i;
}
 
/* example 2 */
 
for ($i = 1;;$i++) {
    if ($i &gt; 10) {
        break;
    }
    print $i;
}
 
/* example 3 */
 
$i = 1;
for (;;) {
    if ($i &gt; 10) {
        break;
    }
    print $i;
    $i++;
}
 
/* example 4 */
 
for ($i = 1; $i &lt;= 10; print $i, $i++) ;
     </programlisting>
    </informalexample>
   </para>
   <simpara>
當然， 在上面的示範中看起來只有第一個 (也許也人喜愛第四個例子) 最正規， 有不過有時候在 
for 迴圈 用空的表達式可以令編寫程式變很方便。 

   </simpara>
   <para>
for 迴圈 也有它的另一種寫法。     <informalexample>
     <programlisting>
for (expr1; expr2; expr3): statement; ...; endfor;
     </programlisting>
     </informalexample>
   </para>
   <para>
有的程式語言有個叫 foreach 的命令來存取陣列和拼雜資料表。 PHP3 沒有這樣指令但 PHP4 
有。 (請看
<link
    linkend="control-structures.foreach">foreach</link>)。用 PHP3 時，你要同時用 
<link linkend="control-structures.while">while</link> 和<function>list</function> 以及 
<function>each</function>
函數才能完成相同的工作。 想知道怎麼做的話請看有關這些函數的章節。 

   </para>

  </sect1>
  <sect1 id="control-structures.foreach">
   <title><literal>foreach</literal></title>
   <para>
PHP4 (PHP3 並沒有) 加入了 foreach 的功能。這功能在 PERL 和其他語言中都有。 
用它可以很方便地存取陣列。 合法的句式有兩個： 
第二個只是對第一個句法作了一點改動但很有用。如下： 

    <informalexample>
     <programlisting>
foreach(array_expression as $value) statement
foreach(array_expression as $key =&gt; $value) statement
     </programlisting>
    </informalexample>
   </para>
   <simpara>
第一個句式每次循環都會把陣列 array_expression 中的一個元素的值存到變數 $value 
中直到陣列中所有的元素用完了。 
   </simpara>
   <simpara>
第二個句式和第一個差不多， 分別在於除了 $value 會儲存了元素的值， $key 
還會儲存了目前元素的索引號。 
   </simpara>
   <para>
    <note>
     <para>
          當 foreach 開始時內置的陣列指標會指向陣列的首個元素的位置。 
這代表你不必在每次 foreach 前調用
      <function>reset</function> 函數。 
         </para>
        </note>
   </para>
   <para>
    <note>
         <para>
           Also note that <literal>foreach</literal> operates on a copy of
           the specified array, not the array itself, therefore the array
           pointer is not modified like with the each construct.
         </para>
    </note>
   </para>
   <para>
    在下面的範例， 你應可看出它們功能是一樣的:     <informalexample>
     <programlisting role="php">
reset ($arr);
while (list(, $value) = each ($arr)) {
    echo "Value: $value&lt;br&gt;\n";
}

foreach ($arr as $value) {
    echo "Value: $value&lt;br&gt;\n";
}
     </programlisting>
    </informalexample>
    下面的範例也是一樣功能的: 
    <informalexample>
     <programlisting role="php">
reset ($arr);
while (list($key, $value) = each ($arr)) {
    echo "Key: $key; Value: $value&lt;br&gt;\n";
}

foreach ($arr as $key =&gt; $value) {
    echo "Key: $key; Value: $value&lt;br&gt;\n";
}
     </programlisting>
    </informalexample>
   </para>
   <para>
更多的示範: 
    <informalexample>
     <programlisting role="php">
/* foreach example 1: value only */

$a = array (1, 2, 3, 17);

foreach ($a as $v) {
   print "Current value of \$a: $v.\n";
}

/* foreach example 2: value (with key printed for illustration) */

$a = array (1, 2, 3, 17);

$i = 0; /* for illustrative purposes only */

foreach($a as $v) {
    print "\$a[$i] =&gt; $v.\n";
}

/* foreach example 3: key and value */

$a = array (
    "one" =&gt; 1,
    "two" =&gt; 2,
    "three" =&gt; 3,
    "seventeen" =&gt; 17
);

foreach($a as $k =&gt; $v) {
    print "\$a[$k] =&gt; $v.\n";
}
     </programlisting>
    </informalexample>
   </para>
  </sect1>
 
  <sect1 id="control-structures.break">
   <title><literal>break</literal></title>
   <simpara>
break 是用來跳離類似下列的迴圈或條件句式 ： if 、 for 、 while、switch 。 

   </simpara>
   <simpara>
用 break 時可以加上一個參數告訴電腦要跳離多少層的迴圈。    </simpara>
   <para>
    <informalexample>
     <programlisting role="php">
$arr = array ('one', 'two', 'three', 'four', 'stop', 'five');
while (list (, $val) = each ($arr)) {
    if ($val == 'stop') {
        break;    /* You could also write 'break 1;' here. */
    }
    echo "$val&lt;br&gt;\n";
}

/* Using the optional argument. */

$i = 0;
while (++$i) {
    switch ($i) {
    case 5:
        echo "At 5&lt;br&gt;\n";
        break 1;  /* Exit only the switch. */
    case 10:
        echo "At 10; quitting&lt;br&gt;\n";
        break 2;  /* Exit the switch and the while. */
    default:
        break;
    }
}
     </programlisting>
    </informalexample>
   </para>
  </sect1>
 
  <sect1 id="control-structures.continue">
   <title><literal>continue </literal></title>
   <simpara>
continue 在迴圈中的作用是立時跳離現時執行中的循環而開始下一個循環。 

   </simpara>
   <simpara>
    continue 和 break 一樣可用一個參數指示它應該從那一層迴圈開始下一次循環。    
</simpara>
   <para>
    <informalexample>
     <programlisting role="php">
while (list ($key, $value) = each ($arr)) {
    if (!($key % 2)) { // skip odd members
        continue;
    }
    do_something_odd ($value);
}

$i = 0;
while ($i++ &lt; 5) {
    echo "Outer&lt;br&gt;\n";
    while (1) {
        echo "&nbsp;&nbsp;Middle&lt;br&gt;\n";
        while (1) {
            echo "&nbsp;&nbsp;Inner&lt;br&gt;\n";
            continue 3;
        }
        echo "This never gets output.&lt;br&gt;\n";
    }
    echo "Neither does this.&lt;br&gt;\n";
}
     </programlisting>
     </informalexample>
    </para>
  </sect1>
 
  <sect1 id="control-structures.switch">
   <title><literal>switch</literal></title>
   <simpara>
   switch 命令的功能和一連串用同一條件表達式的 if 語句相似。 
有不少的情況要求把一個變數或一句表達式和不同的數值作比較， 
當它等於某一個數值時便執行相對應的程式段。 這正是 switch 的功用。 

   </simpara> 
   <para>
下面示範了怎樣用一連串的 if 和用一個 switch 來完成相同的工作：     <informalexample>
     <programlisting role="php">
if ($i == 0) {
    print "i equals 0";
}
if ($i == 1) {
    print "i equals 1";
}
if ($i == 2) {
    print "i equals 2";
}
 
switch ($i) {
    case 0:
        print "i equals 0";
        break;
    case 1:
        print "i equals 1";
        break;
    case 2:
        print "i equals 2";
        break;
}
     </programlisting>
    </informalexample>
   </para>
   <para>
為了避免弄錯，最好是搞明白 switch 的運作方式。 switch 是一句接一句的執行程式的。 首先 
PHP 要找一個case 的值和 switch 條件表達式所演算出來的值是一樣的。 然後 PHP 
會執行在那個 case 之後出現的所有指令直到 switch 程式段的最後或者直到 PHP 碰到一句 
break 指令。 如果你沒有在每個 case 的最後加上 break 指令， PHP 
會接下去執行接在下面的另一個 case 之中的指令！ 下面的程式示範了這一點： 

    <informalexample>
     <programlisting role="php">
switch ($i) {
    case 0:
        print "i equals 0";
    case 1:
        print "i equals 1";
    case 2:
        print "i equals 2";
}
     </programlisting>
    </informalexample>
   </para>
   <simpara>
對上面程式而言， 如果 $i 是 0 的話， PHP 會執行所有的 print 指令！ 如果 $i 是 1， PHP 
只會執行後面兩句指令； 只有當 $i 等 2 才會得到本來想要的結果：印出 'i equals 2' 。 
由此可見， 先萬別要漏了放 break 指令在每個 case 之後。 (雖然在一些情況下你可能特地不加 
break。) 

   </simpara>
   <simpara>
程式執行 switch 時， 條件表達式只會被檢查一次。 這一次的運算結果會用來和每個 case 
比較； 但在 elseif 語句中該條件表達式會重新被演算一遍。 
因此在條件表達式很複雜或是在速度要求很高的迴圈中用 switch 會比較快一些。 

   </simpara>
   <para>
一個 case 所含的指令數目也可以是 0 個， 這樣一來程式會自動檢查下一個 case     
<informalexample>
     <programlisting role="php">
switch ($i) {
    case 0:
    case 1:
    case 2:
        print "i is less than 3 but not negative";
        break;
    case 3:
        print "i is 3";
}
     </programlisting>
    </informalexample>
   </para>
   <para>
有個特殊的 case 是 default case， 如果所有的 case 都沒法成立時， default 便會被執行。 
看下面的示範: 

    <informalexample>
     <programlisting role="php">
switch ($i) {
    case 0:
        print "i equals 0";
        break;
    case 1:
        print "i equals 1";
        break;
    case 2:
        print "i equals 2";
        break;
    default:
        print "i is not equal to 0, 1 or 2";
}
     </programlisting>
    </informalexample>
   </para>
   <para>
   有效的 case 表達式一定要得出一個類形簡單的數值， 如整數、 小數或是文句。 
如果是陣列的話就一定要指出陣列中的那一個元素並該元素也要是一個類型簡單的值。 
   </para>
   <para>
    swithes 也有它們另一種等效的寫法， 詳情可看 <link
    linkend="control-structures.alternative-syntax">控制程式流程的等效句法 </link> .
    <informalexample>
     <programlisting role="php">
switch ($i):
    case 0:
        print "i equals 0";
        break;
    case 1:
        print "i equals 1";
        break;
    case 2:
        print "i equals 2";
        break;
    default:
        print "i is not equal to 0, 1 or 2";
endswitch;
     </programlisting>
    </informalexample>
   </para>
  </sect1>
  
  <sect1 id="function.require">
   <title><function>require</function></title>
   <simpara>
    The <function>require</function> statement replaces itself with
    the specified file, much like the C preprocessor's
    <literal>#include</literal> works.
   </simpara>
   <simpara>
    If "URL fopen wrappers" are enabled in PHP (which they are in the
    default configuration), you can specify the file to be
    <function>require</function>ed using an URL instead of a local
    pathname. See <link linkend="features.remote-files">Remote
    files</link> and <function>fopen</function> for more information.
   </simpara>
   <simpara>
    An important note about how this works is that when a file is
    <function>include</function>ed or <function>require</function>ed,
    parsing drops out of PHP mode and into HTML mode at the beginning
    of the target file, and resumes PHP mode again at the end. For
    this reason, any code inside the target file which should be
    executed as PHP code must be enclosed within <link
    linkend="language.basic-syntax.phpmode">valid PHP start and end
    tags</link>.
   </simpara>
   <simpara>
    <function>require</function> is not actually a function in PHP;
    rather, it is a language construct. It is subject to some
    different rules than functions are. For instance,
    <function>require</function> is not subject to any containing
    control structures. For another, it does not return any value;
    attempting to read a return value from a
    <function>require</function> call results in a parse error.
   </simpara>
   <simpara>
    Unlike <function>include</function>, <function>require</function>
    will <emphasis>always</emphasis> read in the target file,
    <emphasis>even if the line it's on never executes</emphasis>. If
    you want to conditionally include a file, use
    <function>include</function>. The conditional statement won't
    affect the <function>require</function>. However, if the line on
    which the <function>require</function> occurs is not executed,
    neither will any of the code in the target file be executed.
   </simpara>
   <simpara>
    Similarly, looping structures do not affect the behaviour of
    <function>require</function>. Although the code contained in the
    target file is still subject to the loop, the
    <function>require</function> itself happens only once.
   </simpara>
   <para>
    This means that you can't put a <function>require</function>
    statement inside of a loop structure and expect it to include the
    contents of a different file on each iteration. To do that, use an
    <function>include</function> statement.
    <informalexample>
     <programlisting role="php">
require ('header.inc');
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    When a file is <function>require</function>ed, the code it
    contains inherits the variable scope of the line on which the
    <function>require</function> occurs. Any variables available at
    that line in the calling file will be available within the called
    file. If the <function>require</function> occurs inside a
    function within the calling file, then all of the code contained
    in the called file will behave as though it had been defined
    inside that function.
   </simpara>
   <para>
    If the <function>require</function>ed file is called via HTTP
    using the fopen wrappers, and if the target server interprets the
    target file as PHP code, variables may be passed to the
    <function>require</function>ed file using an URL request string as
    used with HTTP GET. This is not strictly speaking the same thing
    as <function>require</function>ing the file and having it inherit
    the parent file's variable scope; the script is actually being run
    on the remote server and the result is then being included into
    the local script.
    <informalexample>
     <programlisting role="php">
/* This example assumes that someserver is configured to parse .php
 * files and not .txt files. Also, 'works' here means that the variables 
 * $varone and $vartwo are available within the require()ed file. */

/* Won't work; file.txt wasn't handled by someserver. */
require ("http://someserver/file.txt?varone=1&amp;vartwo=2");

/* Won't work; looks for a file named 'file.php?varone=1&amp;vartwo=2'
 * on the local filesystem. */
require ("file.php?varone=1&amp;vartwo=2");               

/* Works. */
require ("http://someserver/file.php?varone=1&amp;vartwo=2"); 

$varone = 1;
$vartwo = 2;
require ("file.txt");  /* Works. */
require ("file.php");  /* Works. */
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    In PHP 3, it is possible to execute a <literal>return</literal>
    statement inside a <function>require</function>ed file, as long as
    that statement occurs in the global scope of the
    <function>require</function>ed file. It may not occur within any
    block (meaning inside braces ({}). In PHP 4, however, this ability
    has been discontinued. If you need this functionality, see
    <function>include</function>.
   </simpara>
   <simpara>
    See also <function>include</function>, <function>require_once</function>,
    <function>include_once</function>, <function>readfile</function>,
        and <function>virtual</function>.
   </simpara>
  </sect1>
 
  <sect1 id="function.include">
   <title><function>include</function></title>
   <simpara>
    The <function>include</function> statement includes and evaluates
    the specified file.
   </simpara>
   <simpara>
    If "URL fopen wrappers" are enabled in PHP (which they are in the
    default configuration), you can specify the file to be
    <function>include</function>ed using an URL instead of a local
    pathname. See <link linkend="features.remote-files">Remote
    files</link> and <function>fopen</function> for more information.
   </simpara>
   <simpara>
    An important note about how this works is that when a file is
    <function>include</function>ed or <function>require</function>ed,
    parsing drops out of PHP mode and into HTML mode at the beginning
    of the target file, and resumes again at the end. For this reason,
    any code inside the target file which should be executed as PHP
    code must be enclosed within <link
    linkend="language.basic-syntax.phpmode">valid PHP start and end
    tags</link>.
   </simpara>
   <para>
    This happens each time the <function>include</function> statement
    is encountered, so you can use an <function>include</function>
    statement within a looping structure to include a number of
    different files.
    <informalexample>
     <programlisting role="php">
$files = array ('first.inc', 'second.inc', 'third.inc');
for ($i = 0; $i &lt; count($files); $i++) {
    include $files[$i];
}
     </programlisting>
    </informalexample>
   </para>
   <para>
    <function>include</function> differs from
    <function>require</function> in that the include statement is
    re-evaluated each time it is encountered (and only when it is
    being executed), whereas the <function>require</function>
    statement is replaced by the required file when it is first
    encountered, whether the contents of the file will be evaluated or
    not (for example, if it is inside an <link
    linkend="control-structures.if">if</link> statement whose
    condition evaluated to false).
   </para>
   <para>
    Because <function>include</function> is a special language
    construct, you must enclose it within a statement block if it is
    inside a conditional block.
    <informalexample>
     <programlisting role="php">
/* This is WRONG and will not work as desired. */
 
if ($condition)
    include($file);
else
    include($other);
 
/* This is CORRECT. */
 
if ($condition) {
    include($file);
} else {
    include($other);
}
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    In both PHP 3 and PHP 4, it is possible to execute a
    <literal>return</literal> statement inside an
    <function>include</function>ed file, in order to terminate
    processing in that file and return to the script which called
    it. Some differences in the way this works exist, however. The
    first is that in PHP 3, the <literal>return</literal> may not
    appear inside a block unless it's a function block, in which case
    the <literal>return</literal> applies to that function and not the
    whole file. In PHP 4, however, this restriction does not
    exist. Also, PHP 4 allows you to return values from
    <function>include</function>ed files. You can take the value of
    the <function>include</function> call as you would a normal
    function. This generates a parse error in PHP 3.
   </simpara>
   <example>
    <title><function>include</function> in PHP 3 and PHP 4</title>
    <para>
     Assume the existence of the following file (named
     <filename>test.inc</filename>) in the same directory as the main
     file:
     <programlisting role="php">
&lt;?php
echo "Before the return &lt;br&gt;\n";
if (1) {
    return 27;
}
echo "After the return &lt;br&gt;\n";
?&gt;
     </programlisting>
    </para>
    <para>
     Assume that the main file (<filename>main.html</filename>)
     contains the following:
     <programlisting role="php">
&lt;?php
$retval = include ('test.inc');
echo "File returned: '$retval'&lt;br&gt;\n";
?&gt;
     </programlisting>
    </para>
    <para>
     When <filename>main.html</filename> is called in PHP 3, it will
     generate a parse error on line 2; you can't take the value of an
     <function>include</function> in PHP 3. In PHP 4, however, the
     result will be:
     <screen>
Before the return
File returned: '27'
     </screen>
    </para>
    <para>
     Now, assume that <filename>main.html</filename> has been altered
     to contain the following:
     <programlisting role="php">
&lt;?php
include ('test.inc');
echo "Back in main.html&lt;br&gt;\n";
?&gt;
     </programlisting>
    </para>
    <para>
     In PHP 4, the output will be:
     <screen>
Before the return
Back in main.html
     </screen>
     However, PHP 3 will give the following output:
     <screen>
Before the return 
27Back in main.html

Parse error: parse error in /home/torben/public_html/phptest/main.html on line 5
     </screen>
    </para>
    <para>
     The above parse error is a result of the fact that the
     <literal>return</literal> statement is enclosed in a non-function
     block within <filename>test.inc</filename>. When the return is
     moved outside of the block, the output is:
     <screen>
Before the return
27Back in main.html
     </screen>
    </para>
    <para>
     The spurious '27' is due to the fact that PHP 3 does not support
     <literal>return</literal>ing values from files like that.
    </para>
   </example>
   <simpara>
    When a file is <function>include</function>ed, the code it
    contains inherits the variable scope of the line on which the
    <function>include</function> occurs. Any variables available at
    that line in the calling file will be available within the called
    file. If the <function>include</function> occurs inside a
    function within the calling file, then all of the code contained
    in the called file will behave as though it had been defined
    inside that function.
   </simpara>
   <para>
    If the <function>include</function>ed file is called via HTTP
    using the fopen wrappers, and if the target server interprets the
    target file as PHP code, variables may be passed to the
    <function>include</function>ed file using an URL request string as
    used with HTTP GET. This is not strictly speaking the same thing
    as <function>include</function>ing the file and having it inherit
    the parent file's variable scope; the script is actually being run
    on the remote server and the result is then being included into
    the local script.
    <informalexample>
     <programlisting role="php">
/* This example assumes that someserver is configured to parse .php
 * files and not .txt files. Also, 'works' here means that the variables 
 * $varone and $vartwo are available within the include()ed file. */

/* Won't work; file.txt wasn't handled by someserver. */
include ("http://someserver/file.txt?varone=1&amp;vartwo=2");

/* Won't work; looks for a file named 'file.php?varone=1&amp;vartwo=2'
 * on the local filesystem. */
include ("file.php?varone=1&amp;vartwo=2");               

/* Works. */
include ("http://someserver/file.php?varone=1&amp;vartwo=2"); 

$varone = 1;
$vartwo = 2;
include ("file.txt");  /* Works. */
include ("file.php");  /* Works. */
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    See also <function>require</function>, <function>require_once</function>,
    <function>include_once</function>, <function>readfile</function>,
        and <function>virtual</function>.
   </simpara>
  </sect1>
 
  <sect1 id="function.require-once">
   <title><function>require_once</function></title>
   <para>
    The <function>require_once</function> statement replaces
    itself with the specified file, much like the C preprocessor's
    <literal>#include</literal> works, and in that respect is
        similar to the <function>require</function> statement. The main
        difference is that in an inclusion chain, the use of
        <function>require_once</function> will assure that the code is
        added to your script only once, and avoid clashes with variable
        values or function names that can happen.
   </para>
   <para>
     For example, if you create the following 2 include files
         <literal>utils.inc</literal> and <literal>foolib.inc</literal>
         <example>
         <title>utils.inc</title>
         <programlisting role="php">
&lt;?php
define(PHPVERSION, floor(phpversion()));
echo "GLOBALS ARE NICE\n";
function goodTea() {
        return "Oolong tea tastes good!";
}
?&gt;
         </programlisting>
         </example>
         <example>
         <title>foolib.inc</title>
         <programlisting role="php">
&lt;?php
require ("utils.inc");
function showVar($var) {
        if (PHPVERSION == 4) {
                print_r($var);
        } else {
                var_dump($var);
        }
}

// bunch of other functions ...
?&gt;
         </programlisting>
         </example>
         And then you write a script <literal>cause_error_require.php</literal>
         <example>
         <title>cause_error_require.php</title>
         <programlisting role="php">
&lt;?php
require("foolib.inc");
/* the following will generate an error */
require("utils.inc");
$foo = array("1",array("complex","quaternion"));
echo "this is requiring utils.inc again which is also\n";
echo "required in foolib.inc\n";
echo "Running goodTea: ".goodTea()."\n";
echo "Printing foo: \n";
showVar($foo);
?&gt;
         </programlisting>
         </example>
         When you try running the latter one, the resulting ouptut will be (using
         PHP 4.01pl2):
         <informalexample>
         <programlisting>
GLOBALS ARE NICE
GLOBALS ARE NICE

Fatal error:  Cannot redeclare goodTea() in utils.inc on line 5
         </programlisting>
         </informalexample>
         By modifying <literal>foolib.inc</literal> and
         <literal>cause_errror_require.php</literal> 
         to use <function>require_once</function>
         instead of <function>require</function> and renaming the
         last one to <literal>avoid_error_require_once.php</literal>, we have:
         <example>
         <title>foolib.inc (fixed)</title>
         <programlisting role="php">
..
require_once("utils.inc");
function showVar($var) {
..
         </programlisting>
         </example>
         <example>
         <title>avoid_error_require_once.php</title>
         <programlisting role="php">
..
require_once("foolib.inc");
require_once("utils.inc");
$foo = array("1",array("complex","quaternion"));
..
         </programlisting>
         </example>
         And when running the latter, the output will be (using PHP 4.0.1pl2):
         <informalexample>
         <programlisting>
GLOBALS ARE NICE
this is requiring globals.inc again which is also
required in foolib.inc
Running goodTea: Oolong tea tastes good!
Printing foo:
Array
(
    [0] =&gt; 1
    [1] =&gt; Array
        (
            [0] =&gt; complex
            [1] =&gt; quaternion
        )

)
         </programlisting>
         </informalexample>
   </para>
   <para>
     Also note that, analogous to the behavior of the
         <literal>#include</literal> of the C preprocessor, this statement
         acts at "compile time", e.g. when the script is parsed and before it
         is executed, and should not be used for parts of the script that need
         to be inserted dynamically during its execution. You should use
         <function>include_once</function> or <function>include</function>
         for that purpose.
   </para>
   <para>
     For more examples on using <function>require_once</function> and 
         <function>include_once</function>, look at the PEAR code included in
         the latest PHP source code distributions.
   </para>
   <para>
    See also: <function>require</function>,
    <function>include</function>, <function>include_once</function>,
    <function>get_required_files</function>,
    <function>get_included_files</function>, <function>readfile</function>,
        and <function>virtual</function>.
   </para>
  </sect1>
  
  <sect1 id="function.include-once">
   <title><function>include_once</function></title>
   <para>
    The <function>include_once</function> statement includes and evaluates
    the specified file during the execution of the script.
        This is a behavior similar to the <function>include</function> statement,
        with the important difference that if the code from a file has already
        been included, it will not be included again.
   </para>
   <para>
    As mentioned in the <function>require_once</function> description, the
        <function>include_once</function> should be used in the cases in which
        the same file might be included and evaluated more than once during a
        particular execution of a script, and you want to be sure that it is
        included exactly once to avoid problems with function redefinitions,
        variable value reassignments, etc.
   </para>
   <para>
     For more examples on using <function>require_once</function> and 
         <function>include_once</function>, look at the PEAR code included in
         the latest PHP source code distributions.
   </para>
   <para>
     <function>include_once</function> was added in PHP 4.0.1pl2
   </para>
   <para>
    See also: <function>require</function>,
    <function>include</function>, <function>require_once</function>,
    <function>get_required_files</function>,
    <function>get_included_files</function>, <function>readfile</function>,
        and <function>virtual</function>.
   </para>
  </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
 sgml-parent-document:nil
 sgml-default-dtd-file:"../../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->
<!-- Keep this comment for vi/vim/gvim
     vi: et:ts=1:sw=1
--> 

Index: phpdoc/hk/language/expressions.xml
+++ phpdoc/hk/language/expressions.xml
 <chapter id="language.expressions">
   <title>表達式</title>

   <simpara>
   表達式是 PHP 程式的最根本的組成部份。 用 PHP 
編程，幾乎所有你寫得下來的指令句都是表達式。 用最簡單且最精確的句子來描述表達式就是： 
"任何有值的東西"。 
</simpara>

   <simpara>
最基本的表達式是常數和變數。當你輸入 "$a = 5"， 你把 '5' 指派給 $a。 '5'， 
當然代表數值 5， 但換個說法是 '5' 是一個表達式， 它的值是 5。(在本例中， '5' 
是一個整數形態的常數).
</simpara>

   <simpara>
    這個指派操作完成後， $a 的值也應該是 5， 假如你再寫 $b = $a，它給出的結果應該和寫 
$b = 5 是一樣的。 換個說法， $a 也一個表達式， 它表達的值同樣是 5。 
如果沒做錯什麼的話， 得出的結果就是這個。
</simpara>

   <para>
較複雜的表達式可以用函數來作示範。 如以下的例子， 
    <informalexample>
     <programlisting>
function foo () {
    return 5;
}
     </programlisting>
    </informalexample></para>

   <simpara>
如你對函數應用有一定認識 (如否請看有關函數的章節)， 你會同意$c = foo() 和 $c = 5 
這兩句是一樣的。 事實上正是這樣。 函數也是一種表達式， 
它們所表達的值就是函數的運算結果(傳回值)。 因為 foo() 傳回 5， 所以表達式 'foo()' 
的值就是 5。 當然一般來說函數不會光傳回一個常數而是要作些運算的。 

</simpara>

   <simpara>
   當然， 值不一定是整數。 PHP 可以讓你應用三種不同類形的純量值， 
分別是整數、浮點數、文句。(純量值就是不能再分成更小的分量的值，非純量值的例子有矢量，陣列等)。另外
 PHP 也支援陣列和物件兩類非純量值。 
從函數傳回的值的形態和指派給變數的值的形態可以是上述的任何一種值。

</simpara>

   <simpara>
    到目前為止， 用 PHP/FI 2 的人應不會覺得有什麼不一樣。 然而， PHP 
把表達式的概念進一步發揮， 變成和很多別的程式語言一樣。 PHP 
是以表達式為基礎的編程語言， 這樣說是因為幾乎所有 PHP 的句子都是由表達式組成。 
分析上面用過的例子 '$a = 5'，很明顯的在操作中有兩項值， 一項是整數 '5'， 另一項是 $a 
的值， 它會被 '5' 所取代。 不過其實還有另一個值存在，它就是表達式本身所表達的值。 
在本例中表達式的值就是指代值， 也就是 '5'‧ 應用的時候我們可以把 '$a=5' 看成是個傳回 
'5' 這個值的表達式。 由此， 如果你寫 '$b = ($a = 5)' 就等同於寫 '$a = 5; $b = 5;' 
(分號代表語句的結束)。 再進一步說， 因為表達式是從右向左來做運算的， 
所以就算簡單的寫成 '$b = $a = 5'， 答案也是一樣的。 
</simpara>

   <simpara>
    以表達式為基本的操作還有另外一種很好的示例。 就是前置或後置的增值和損值操作。 使用 
PHP/FI 2 和許多其他語言的程式員大概已看慣了 變數++ 和 變數-- 的表達句式。 
這些便是增值和損值運算符。 在 PHP/FI 2 的時候， '$a++' 並不代表任何值 
(並不是一個表達式)， 因此基本上你不能用它來做別的事。 到了 PHP， 
這些句式都變成了表達式 (就像 C 一樣)。 另外和 C 相同的是， 有兩種增值算符： 
前置的和後置的。 兩種都會把變數增加 1， 分別在於其表達式所表達的值。 前置式是寫成 
'++$variable'， 傳回的是增值後的值； (PHP 在讀取表達式的值之前先把變數值加 1， 
因此叫前置) 後置表達式寫成 '$variable++' 傳回變數還沒增加 1 前的值 (PHP 
讀取的表達式的值之後才把變數增值)。
</simpara>

   <simpara>
比較式是一種極之常見的表達式。 這類表達式的運算結果是 1 或 0， 分別代表邏輯值 真 和 
假。 PHP 明白 &gt; (大於)； &gt;= (大於或等於)； == (等於)； != (不等於)； &lt; 
(小於)； &lt;= (小於或等於)。 這類表達式通常用在條件句之中， 如if 語句。
</simpara>

   <simpara>
    最後一個示範我們會面對一類同時做指派和運算的表達式。 你已知道如果想把 $a 增加 1， 
可以直接用 '$a++' 或 '++$a'。 但是如果你其實是想把 $a 增加多一些， 比如說 '3' 
那該怎樣做　？ 當然可以連寫 3 行'$a++'， 不過這很不好看。 較平民的做法是用 
'$a=$a+3;'： '$a + 3' 的表達的是 $a 再加上 3， 這結果會放回變數 $a 之中， 
整個運算完成後 $a 的內容會增加了 3。 用 PHP 
和許多其他語言同樣可以把此類操作寫成另一個較簡單的句式，將來這種句法可能會更流行也更易理解。
 把 $a 的值增加 3 可寫成 '$a += 3'. 它代正正代表了把 $a 的值拿出來， 增加 3， 再存回 
$a 當中。除了更短和更明白之外， 這句式執行起來也更快。 這句表達式傳回的值和討論 
regular expr 時一樣， 是表達式運算的結果 '$a+3'。 
任何一個需要兩個運算元的運算符都可用此類句式造句， 例如 '$a -= 5' (把 $a 減 5), '$b *= 
7' (把 $b 乘以 7) 等。
</simpara>

   <para>
另外有一種看起來比較怪但是在其他的程式語言中也會用到的表達式: (ternary conditional 
operator 三元運算式) 

    <informalexample><programlisting>
$first ? $second : $third
</programlisting></informalexample>

    當第一個表達分式成立時， 第二個表達分式會被執行而運算結果會成為整個表達式的值。 
當第一個表達分式不成立時， 第三個分式的結果會成為整個表達式的值。 
</para>

   <para>
    以下的示範會幫你更好地掌握前置和後置增值運算符和表達式的運用: 

    <informalexample>
     <programlisting>
function double($i) {
    return $i*2;
}
$b = $a = 5;        /* assign the value five into the variable $a and $b */
$c = $a++;          /* post-increment, assign original value of $a 
                       (5) to $c */
$e = $d = ++$b;     /* pre-increment, assign the incremented value of 
                       $b (6) to $d and $e */

/* at this point, both $d and $e are equal to 6 */

$f = double($d++);  /* assign twice the value of $d <emphasis>before</emphasis> 
                       the increment, 2*6 = 12 to $f */
$g = double(++$e);  /* assign twice the value of $e <emphasis>after</emphasis>
                       the increment, 2*7 = 14 to $g */
$h = $g += 10;      /* first, $g is incremented by 10 and ends with the 
                       value of 24. the value of the assignment (24) is 
                       then assigned into $h, and $h ends with the value 
                       of 24 as well. */
</programlisting></informalexample></para>

   <simpara>
    在本章開始時我們說會講到語句 statment 的類型。 表達式可以是語句， 
但並非全部的表達代都是語句。 在上例中， 語句的形式是 'expr' ';' ， 
就是一項表達式加上分號。 比如 '$b=$a=5;'， $a=5 是一個合法的表達式但不是一句語句。 但 
'$b=$a=5;' 倒是一句合法的語句。 
</simpara>

   <simpara>
    最後值的一提的是表達式的邏輯值。許多情況下， 尤其是條件句和迴圈句裏， 
表達式的值並不是重點反而該表達式是否成立 ( TRUE 還是 FALSE)。 (PHP 
並沒有特別指定邏輯變數類。) 表達式的真假值的計算方法和 perl 差不多。 任何不等於 0 
的數字都代表真， 0 則代表假。 當心負數因為也不等 0 ， 所以也代表真！ 空的文句或文句 
"0" 是假， 所有其他文句都是真。 至於像陣列和物件這樣的非純量值， 
如果結果是空的陣列則代表真， 反之則是假。 
</simpara>

   <simpara>
    PHP 提供了完整而且功能強大的表達式。 
本手冊沒可能把所有可用的表達式的句法統統整理成文件， 
但上面的示範應可讓你知道造句的方法。 在本手冊之中， 我們會用 expr 來代表合法的表達式。
</simpara>

  </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
 sgml-parent-document:nil
 sgml-default-dtd-file:"../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->

Index: phpdoc/hk/language/functions.xml
+++ phpdoc/hk/language/functions.xml
 <chapter id="functions">
  <title>Functions</title>

  <sect1 id="functions.user-defined">
   <title>User-defined functions</title>
 
   <para>
    A function may be defined using syntax such as the following:
 
    <informalexample>
     <programlisting role="php">
function foo ($arg_1, $arg_2, ..., $arg_n) {
    echo "Example function.\n";
    return $retval;
}
     </programlisting>
    </informalexample>
   </para>
     
   <simpara>
    Any valid PHP code may appear inside a function, even other
    functions and <link linkend="keyword.class">class</link>
    definitions.
   </simpara>
   <simpara>
    In PHP 3, functions must be defined before they are referenced. No
    such requirement exists in PHP 4.
   </simpara>
   <simpara>
    PHP does not support function overloading, nor is it possible to
    undefine or redefine previously-declared functions.
   </simpara>
   <simpara>
    PHP 3 does not support variable numbers of arguments to functions,
    although default arguments are supported (see <link
    linkend="functions.arguments.default">Default argument
    values</link> for more information). PHP 4 supports both: see <link
    linkend="functions.variable-arg-list">Variable-length argument
    lists</link> and the function references for
    <function>func_num_args</function>,
    <function>func_get_arg</function>, and
    <function>func_get_args</function> for more information.
   </simpara>

  </sect1>
 
  <sect1 id="functions.arguments">
   <title>Function arguments</title>
 
   <simpara>
    Information may be passed to functions via the argument list,
    which is a comma-delimited list of variables and/or constants.
   </simpara> 
   <para>
     PHP supports passing arguments by value (the default), <link
     linkend="functions.arguments.by-reference">passing by
     reference</link>, and <link
     linkend="functions.arguments.default">default argument
     values</link>. Variable-length argument lists are supported only
     in PHP 4 and later; see <link
     linkend="functions.variable-arg-list">Variable-length argument
     lists</link> and the function references for
     <function>func_num_args</function>,
     <function>func_get_arg</function>, and
     <function>func_get_args</function> for more information. A
     similar effect can be achieved in PHP 3 by passing an array of
     arguments to a function:
 
    <informalexample>
     <programlisting role="php">
function takes_array($input) {
    echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
     </programlisting>
    </informalexample>
   </para>
 
   <sect2 id="functions.arguments.by-reference">
    <title>Making arguments be passed by reference</title>
 
    <simpara>
     By default, function arguments are passed by value (so that if
     you change the value of the argument within the function, it does
     not get changed outside of the function). If you wish to allow a
     function to modify its arguments, you must pass them by
     reference.
    </simpara>
    <para>
     If you want an argument to a function to always be passed by
     reference, you can prepend an ampersand (&amp;) to the argument
     name in the function definition:
 
     <informalexample>
      <programlisting role="php">
function add_some_extra(&amp;$string) {
    $string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str;    // outputs 'This is a string, and something extra.'
      </programlisting>
     </informalexample>
    </para>
 
    <para>
     If you wish to pass a variable by reference to a function which
     does not do this by default, you may prepend an ampersand to the
     argument name in the function call:
 
     <informalexample>
      <programlisting role="php">
function foo ($bar) {
    $bar .= ' and something extra.';
}
$str = 'This is a string, ';
foo ($str);
echo $str;    // outputs 'This is a string, '
foo (&amp;$str);
echo $str;    // outputs 'This is a string, and something extra.'
      </programlisting>
     </informalexample>
    </para>

   </sect2>
 
   <sect2 id="functions.arguments.default">
    <title>Default argument values</title>
 
    <para>
     A function may define C++-style default values for scalar
     arguments as follows:
 
     <informalexample>
      <programlisting role="php">
function makecoffee ($type = "cappucino") {
    return "Making a cup of $type.\n";
}
echo makecoffee ();
echo makecoffee ("espresso");
      </programlisting>
     </informalexample>
    </para>
 
    <para>
     The output from the above snippet is:
 
     <screen>
Making a cup of cappucino.
Making a cup of espresso.
     </screen>
    </para>
 
    <simpara>
     The default value must be a constant expression, not (for
     example) a variable or class member.
    </simpara>
    <para>
     Note that when using default arguments, any defaults should be on
     the right side of any non-default arguments; otherwise, things
     will not work as expected. Consider the following code snippet:
 
     <informalexample>
      <programlisting role="php">
function makeyogurt ($type = "acidophilus", $flavour) {
    return "Making a bowl of $type $flavour.\n";
}
 
echo makeyogurt ("raspberry");   // won't work as expected
      </programlisting>
     </informalexample>
    </para>
 
    <para>
     The output of the above example is:
 
     <screen>
Warning: Missing argument 2 in call to makeyogurt() in 
/usr/local/etc/httpd/htdocs/php3test/functest.html on line 41
Making a bowl of raspberry .
     </screen>
    </para>
 
    <para>
     Now, compare the above with this:
 
     <informalexample>
      <programlisting role="php">
function makeyogurt ($flavour, $type = "acidophilus") {
    return "Making a bowl of $type $flavour.\n";
}
 
echo makeyogurt ("raspberry");   // works as expected
      </programlisting>
     </informalexample>
    </para>
 
    <para>
     The output of this example is:
 
     <screen>
Making a bowl of acidophilus raspberry.
     </screen>
    </para>

   </sect2>

   <sect2 id="functions.variable-arg-list">
    <title>Variable-length argument lists</title>
        
    <simpara>
     PHP 4 has support for variable-length argument lists in
     user-defined functions. This is really quite easy, using the
     <function>func_num_args</function>,
     <function>func_get_arg</function>, and
     <function>func_get_args</function> functions.
    </simpara>

    <simpara>
     No special syntax is required, and argument lists may still be
     explicitly provided with function definitions and will behave as
     normal.
    </simpara>

   </sect2>

  </sect1>
 
  <sect1 id="functions.returning-values">
   <title>Returning values</title>
 
   <para>
    Values are returned by using the optional return statement. Any
    type may be returned, including lists and objects.
 
    <informalexample>
     <programlisting role="php">
function square ($num) {
    return $num * $num;
}
echo square (4);   // outputs '16'.
     </programlisting>
    </informalexample>
   </para>
      
   <para>
    You can't return multiple values from a function, but similar
    results can be obtained by returning a list.
 
    <informalexample>
     <programlisting role="php">
function small_numbers() {
    return array (0, 1, 2);
}
list ($zero, $one, $two) = small_numbers();
     </programlisting>
    </informalexample>
   </para>
   <para>
    To return a reference from a function, you have to use
    the reference operator &amp; in both the function declaration and
    when assigning the returned value to a variable:
    <informalexample>
     <programlisting role="php">
function &amp;returns_reference() {
    return $someref;
}

$newref =&amp;returns_reference();
     </programlisting>
    </informalexample>
   </para>

  </sect1>
 
  <sect1 id="functions.old-syntax">
   <title><literal>old_function</literal></title>
 
   <simpara>
    The <literal>old_function</literal> statement allows you to
    declare a function using a syntax identical to PHP/FI2 (except you
    must replace 'function' with 'old_function'.
   </simpara>
   <simpara>
    This is a deprecated feature, and should only be used by the
    PHP/FI2->PHP 3 convertor.
   </simpara>
   <warning>
    <para>
     Functions declared as <literal>old_function</literal> cannot be
     called from PHP's internal code. Among other things, this means
     you can't use them in functions such as
     <function>usort</function>, <function>array_walk</function>, and
     <function>register_shutdown_function</function>. You can get
     around this limitation by writing a wrapper function (in normal
     PHP 3 form) to call the <literal>old_function</literal>.
    </para>
   </warning>

  </sect1>

  <sect1 id="functions.variable-functions">
   <title>Variable functions</title>

   <para>
    PHP supports the concept of variable functions. This means that if
    a variable name has parentheses appended to it, PHP will look for
    a function with the same name as whatever the variable evaluates
    to, and will attempt to execute it. Among other things, this can
    be used to implement callbacks, function tables, and so forth.
   </para>

   <para>
    <example>
     <title>Variable function example</title>
     <programlisting role="php">
&lt;?php
function foo() {
    echo "In foo()&lt;br>\n";
}

function bar( $arg = '' ) {
    echo "In bar(); argument was '$arg'.&lt;br>\n";
}

$func = 'foo';
$func();
$func = 'bar';
$func( 'test' );
?>
     </programlisting>
    </example>
   </para>

  </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
 sgml-parent-document:nil
 sgml-default-dtd-file:"../../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->

Index: phpdoc/hk/language/oop.xml
+++ phpdoc/hk/language/oop.xml
 <chapter id="language.oop">
  <title>類別和物件</title>

  <sect1 id="keyword.class">
   <title><literal>類別</literal></title>
   <para>
    類別的概念簡單來說就是一小段(也可能是一大段)有一個名稱的程式段， 
其內有變數以及使用這些變數的函數。 定義類別的句法請看下列示範： 
    <informalexample>
     <programlisting role="php">
&lt;?php
class Cart {
    var $items;  // Items in our shopping cart
   
    // Add $num articles of $artnr to the cart
 
    function add_item ($artnr, $num) {
        $this->items[$artnr] += $num;
    }
   
    // Take $num articles of $artnr out of the cart
 
    function remove_item ($artnr, $num) {
        if ($this->items[$artnr] > $num) {
            $this->items[$artnr] -= $num;
            return true;
        } else {
            return false;
        }   
    }
}
?&gt;
     </programlisting>
    </informalexample>
   </para>
 
   <para>
    上面定義了一個叫做 Cart 的類別(按: 模擬網上購物車)。 
它包括了一個名稱索引式的陣列以兩個分別用來在陣列中加入及扣除物品的函數。 
   </para>

   <note>
    <simpara>
     In PHP 4, only constant initializers for <literal>var</literal>
     variables are allowed. Use constructors for non-constant
     initializers.  
    </simpara>
    <informalexample>
     <programlisting role="php">
/* None of these will work in PHP 4. */
class Cart {
    var $todays_date = date("Y-m-d");
    var $name = $firstname;
    var $owner = 'Fred ' . 'Jones';
}

/* This is how it should be done. */
class Cart {
    var $todays_date;
    var $name;
    var $owner;

    function Cart() {
        $this->todays_date = date("Y-m-d");
        $this->name = $GLOBALS['firstname'];
        /* etc. . . */
    }
}
     </programlisting>
    </informalexample>
   </note>

   <para>
    類別是一種變數的形態。 也就是說像 integer、 string 等何以把某類別形態指派給變數。 
不同的是建立某個類別的變數需要用到 new 指令 (按: 
這樣產生的變數術語上叫做建立了一個物件)： 
   </para>
 
   <informalexample>
    <programlisting role="php">
$cart = new Cart;
$cart->add_item("10", 1);
    </programlisting>
   </informalexample>
 
   <para>
    上例建立了一個叫做 cart 的物件， 它的類別是 $Cart。 (還記得 PHP 
中大小寫是不一樣的嗎 ?) 跟著調用該物件中的 add_item 函數在陣列中加入一個編號 '10' 
的東西。 
</para><para> 類別也可以是其他類別的延伸。 
新的類別繼承了舊的類別之外還可以加上自己的變數及功能。 
定義延伸類別的方法是定義類別時加上 extend 這個關鍵字。 不過不準定多重繼承關係。 
   </para>
 
   <informalexample>
    <programlisting role="php">
class Named_Cart extends Cart {
    var $owner;
  
    function set_owner ($name) {
        $this->owner = $name;
    }
}
    </programlisting>
   </informalexample>
 
   <para>
    上面新定義了 Named_Cart 類別， 它擁有 Cart 
類別中所有的變數及函數另加上一個存用戶名字的變數及存取該變數的函數： set_owner()。 
你可用老方法根據新類別建立一個物件， 
現在這個物件除了可以像以前一樣加減東西外還可以設定用戶名字： 
   </para>
 
   <informalexample>
    <programlisting role="php">
$ncart = new Named_Cart;    // Create a named cart
$ncart->set_owner ("kris"); // Name that cart
print $ncart->owner;        // print the cart owners name
$ncart->add_item ("10", 1); // (inherited functionality from cart)
    </programlisting>
   </informalexample>
  
   <para>
   在定義類別時 $this 這個變數是指物件本身。 在物件之中你一定要用 $this->something 
的句式來調用或存取物件中的變數和函數。 
。
Both in and
    outside of the object you do not need a $ when accessing an object's
    properties.
   </para>

   <informalexample>
    <programlisting role="php">
$ncart->owner  = "chris"; // no $

$ncart->$owner = "chris";
// this is invalid because $ncart->$owner = $ncart->""

$myvar = 'owner';
$ncart->$myvar = "chris";  
// this is valid because $ncart->$myvar = $ncart->owner
    </programlisting>
   </informalexample>

   <para>
    Constructors 建造者 是類別中的一個函數。 
它會在每個根據該類別產生物件時自動被執行。 
把函數變成建造者函數的方法是把該函數命名成和類別的名字一樣。 
   </para>
 
   <informalexample>
    <programlisting role="php">
class Auto_Cart extends Cart {
    function Auto_Cart () {
        $this->add_item ("10", 1);
    }
}
    </programlisting>
   </informalexample>
 
   <para>
    上面我們定義了 Auto_Cart 類別。 它是一個 Cart 類別加上了一個建造者函數， 
這函數會自動會在陣列 (或者說是購物單) 中加上一個 '10' 號的東西。 
另外建造者函數也可以接受參數， 這令建立物件時有更大的彈性。 
   </para>
 
   <informalexample>
    <programlisting role="php">
class Constructor_Cart extends Cart {
    function Constructor_Cart ($item = "10", $num = 1) {
        $this->add_item ($item, $num);
    }
}
 
// Shop the same old boring stuff.
 
$default_cart   = new Constructor_Cart;
 
// Shop for real...
 
$different_cart = new Constructor_Cart ("20", 17);
    </programlisting>
   </informalexample>
 
   <caution>
    <simpara>
     對於繼承類別而言， 如果子類別和父類別都有建造者函數話， 
建立繼承類別的物件時並不會同時調用母類別的建造者函數。 
    </simpara> 
   </caution>
  </sect1>
  
 <sect1 id="language.oop.newref">
   <title>References inside the constructor</title>
   <para>
    Creating references within the constructor can lead to confusing
    results. This tutorial-like section helps you to avoid problems.
 
    <informalexample>
     <programlisting role="php">

class foo {
    function foo($name) {
        // create a reference inside the global array $globalref
        global $globalref;
                $globalref[] = &amp;$this;
        // set name to passed value
        $this->setName($name);
                // and put it out
        $this->echoName();
    }

    function echoName() {
        echo "&lt;br&gt;",$this->Name;
    }
        
        function setName($name) {
                $this->Name = $name;
    }
}
    </programlisting>
   </informalexample>
  </para>
    
   <para>
   Let us check out if there is a difference between <varname>$bar1</varname> which 
has been created using the copy <literal>=</literal> operator
   and <varname>$bar2</varname> which has been created using the reference 
<literal>=&amp;</literal> operator...
   

    <informalexample>
     <programlisting role="php">
   
    $bar1 = new foo('set in constructor');
    $bar1->echoName();
    $globalref[0]->echoName();
    
    /* output:
    set in constructor
    set in constructor
    set in constructor */
    
    $bar2 =&amp; new foo('set in constructor');
    $bar2->echoName();
    $globalref[1]->echoName();

    /* output:
    set in constructor
    set in constructor
    set in constructor */
    
        </programlisting>
   </informalexample>
  </para>
   <para>
    Apparently there is no difference, but in fact there is a very significant one:
    <varname>$bar1</varname> and <varname>$globalref[0]</varname> are _NOT_ 
referenced, they are NOT the same variable. 
    This is because "new" does not return a reference by default, instead it returns a 
copy.
       <note>
         <simpara>
         There is no performance loss (since php 4 and up use reference counting) 
returning copies instead of references.
         On the contrary it is most often better to simply work with copies instead of 
references, because creating
         references takes some time where creating copies virtually takes no time 
(unless none of them is a large array or object
         and one of them gets changed and the other(s) one(s) subsequently, then it 
would be wise to use references to change them
         all concurrently).
         </simpara>
        </note>
    To prove what is written above let us watch the code below.
   

   <informalexample>
     <programlisting role="php">
        // now we will change the name. what do you expect?
        // you could expect that both $bar and $globalref[0] change their names...
        $bar1->setName('set from outside');

        // as mentioned before this is not the case.
        $bar1->echoName();
        $globalref[0]->echoName();

        /* output:
        set on object creation
        set from outside */

        // let us see what is different with $bar2 and $globalref[1]
        $bar2->setName('set from outside');

        // luckily they are not only equyl, they are thesame variable
        // thus $bar2->Name and $globalref[1]->Name are the same too
        $bar2->echoName();
        $globalref[1]->echoName();

        /* output:
        set from outside
        set from outside */
        
      </programlisting>
   </informalexample>   
 </para>   
   <para>
   Another final example, try to understand it.
   
   <informalexample>
     <programlisting role="php">

class a {
    function a($i) {
        $this->value = $i;
        // try to figure out why we do not need a reference here
        $this->b = new b($this);
    }

    function createRef() {
        $this->c = new b($this);
    }

    function echoValue() {
        echo "&lt;br&gt;","class ",get_class($this),': ',$this->value;
        }
}


class b  {

    function b(&amp;$a) {
        $this->a = &amp;$a;
    }

   function echoValue() {
        echo "&lt;br&gt;","class ",get_class($this),': ',$this->a->value;
        }

}

// try to undestand why using a simple copy here would yield
// in an undesired result in the *-marked line
$a =&amp; new a(10);
$a->createRef();

$a->echoValue();
$a->b->echoValue();
$a->c->echoValue();

$a->value = 11;

$a->echoValue();
$a->b->echoValue(); // *
$a->c->echoValue();

/*
output:
class a: 10
class b: 10
class b: 10
class a: 11
class b: 11
class b: 11
*/
      </programlisting>
   </informalexample>
  </para>
</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
 sgml-parent-document:nil
 sgml-default-dtd-file:"../../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->

Index: phpdoc/hk/language/operators.xml
+++ phpdoc/hk/language/operators.xml
 <chapter id="language.operators">
  <title>各類運算符</title>
  <simpara>
  </simpara>
  
  <sect1 id="language.operators.arithmetic">
   <title>算術運算符</title>
   <simpara>
    還記得中小學教的加減乘除嗎 ？ 這些算符就是那樣用的。    </simpara>
   <table>
    <title>算術運算符</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>示範 
</entry>
       <entry>算符名稱</entry>
       <entry>運算結果</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>$a + $b</entry>
       <entry>加法 Addition</entry>
       <entry>$a 、$b 的和</entry>
      </row>
      <row>
       <entry>$a - $b</entry>
       <entry> 減法 Subtraction </entry>
       <entry>$a、 $b 的差</entry>
      </row>
      <row>
       <entry>$a * $b</entry>
       <entry> 乘法 Multiplication </entry>
       <entry>$a 、$b 的積</entry>
      </row>
      <row>
       <entry>$a / $b</entry>
       <entry>除法 Division</entry>
       <entry>$a 、$b 的商</entry>
      </row>
      <row>
       <entry>$a % $b</entry>
       <entry>餘數 Modulus</entry>
       <entry>$a 除以 $b 後的餘數</entry>
      </row>
     </tbody>
    </tgroup>
   </table>
   
   <simpara>
    The division operator ("/") returns an integer value (the result
    of an integer division) if the two operands are integers (or
    strings that get converted to integers) and the quotient is an
    integer. If either operand is a floating-point value, or the
    operation results in a non-integer value, a floating-point value
    is returned.
   </simpara>
  </sect1>
  
  <sect1 id="language.operators.assignment">
   <title>指定變數的值</title>
   <simpara>
基本的指派算符是 '='。 要先入為主的以為這代表 '等於'， 它其實是指要把 '=' 
號右面的值存到左面的運算元之中。 
   </simpara>
   <para>
指定值本身也是個表達式， 它所代表的值就是它要指定的值。 就是說 "$a = 3" 的值就是 3。 
這可以讓你造一些有趣的語句: 
    <informalexample>
     <programlisting role="php"> 
$a = ($b = 4) + 5; // $a is equal to 9 now, and $b has been set to 4.
     </programlisting>
    </informalexample>
   </para>
   <para>
另有一類運算符把計算和指派的操作合而為一。 
所有的二元算符都可以用合併的句式取用變數的值來做操作同時把運算結果存回到該變數之中。 
請看下例: 
    <informalexample>
     <programlisting role="php">
$a = 3;
$a += 5; // sets $a to 8, as if we had said: $a = $a + 5;
$b = "Hello ";
$b .= "There!"; // sets $b to "Hello There!", just like $b = $b . "There!";
     </programlisting>
    </informalexample>
   </para>
   <para>
注意指派的動作是把數據抄到新的變數之中去。 操作完成後新的變數跟本來的再也沒有關聯。 
當你需要抄一個很大很大的陣列時可能會需要較長的時間。 在這方面， PHP4 
允許你用參照的方式指派變數。 如下的句式 $var = &$othervar; 
完成後兩個變數最終都指向同一份資料， 期間沒有涉及任何抄寫資料的動作。 注意在 PHP3 
時是不合法的。 

    To learn more about references, please read <link 
    linkend="language.references">References explained</link>.
   </para>
  </sect1>

  <sect1 id="language.operators.bitwise">
   <title>以位元為單位的運算符</title>
   <simpara>
位元操作運算符允許你設定整數中某個位元的值。 
   </simpara>
   <table>
    <title>以位元為單位的運算符</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>示範 
</entry>
       <entry>運算符名稱</entry>
       <entry>運算結果</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>$a &amp; $b</entry>
       <entry>And</entry>
       <entry>當 $a 和 $b 的相對應位元皆是 '1' 時才會傳回 1 。</entry>
      </row>
      <row>
       <entry>$a | $b</entry>
       <entry>Or</entry>
       <entry>當 $a 和 $b 的相對應位元中有一個或以上 '1' 時才會傳回 1 。/entry>
      </row>
      <row>
       <entry>$a ^ $b</entry>
       <entry>Xor</entry>
       <entry>
        當 $a 和 $b 的相對應位元中只有一個是 '1' 時才會傳回 1 。
       </entry>
      </row>
      <row>
       <entry>~ $a</entry>
       <entry>Not</entry>
       <entry>
        把 $a 裏的位元取反相： 1 變 0 、 0 變 1 。
       </entry>
      </row>
      <row>
       <entry>$a &lt;&lt; $b</entry>
       <entry>Shift left</entry>
       <entry>
把 $a 的位元向左移動 $b 那麼多位。(每移一次代表把 $a 乘以 2)
       </entry>
      </row>
      <row>
       <entry>$a &gt;&gt; $b</entry>
       <entry>Shift right</entry>
       <entry>
        把 $a 的位元向右移動 $b 那麼多位。(每移一次代表把 $a 除以 2)
       </entry>
      </row>
     </tbody>
    </tgroup>
   </table>
  </sect1>

  <sect1 id="language.operators.comparison">
   <title>用來作比較的運算符</title>
   <simpara>
    比較算符， 顧名思義是用來比較兩個值的大小的。 
   </simpara>
   <table>
    <title>用來作比較的運算符</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>示範 </entry>
       <entry>算符名稱</entry>
       <entry>運算結果</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>$a == $b</entry>
       <entry>相等</entry>
       <entry>當兩者相等時成立</entry>
      </row>
      <row>
       <entry>$a === $b</entry>
       <entry>全等</entry>
       <entry>
        當兩者相等且形態一樣時成立(PHP4 才有)
       </entry>
      </row>
      <row>
       <entry>$a != $b</entry>
       <entry>不等</entry>
       <entry>當兩者不等時成立</entry>
      </row>
      <row>
       <entry>$a !== $b</entry>
       <entry>Not identical</entry>
       <entry>
        True if $a is not equal to $b, or they are not of the same
        type. (PHP 4 only)
       </entry>
      </row>
      <row>
       <entry>$a &lt; $b</entry>
       <entry> 小於 </entry>
       <entry>前者小於後者時成立</entry>
      </row>
      <row>
       <entry>$a &gt; $b</entry>
       <entry>大於</entry>
       <entry> 當前者大於後者時成立 /entry>
      </row>
      <row>
       <entry>$a &lt;= $b</entry>
       <entry>小於或等於 </entry>
       <entry>當前者比後者小或兩者一樣時成立</entry>
      </row>
      <row>
       <entry>$a &gt;= $b</entry>
       <entry> 大於或等於   </entry>
       <entry>當前者比後者大或兩者一樣時成立</entry>
      </row>
     </tbody>
    </tgroup>
   </table>
   <para>
另一種用來作條件算符的是 "?:" (或稱三元 trinary) 算符。 在 C 
以及其他程式語言中都可這類算符。 
    <informalexample>
     <programlisting>
(expr1) ? (expr2) : (expr3);
     </programlisting>
    </informalexample> 
當 expr1 成立時， 該算式的值等於 expr2 ， 否則算式的值等於 expr3 。    </para>
  </sect1>

  <sect1 id="language.operators.errorcontrol">
   <title>統控錯誤的運算符
</title>
   <simpara>
PHP 只有一個統控錯誤的算符: (@)算符。 可以把它加到任何一句 PHP 指令之前， 
屆時該指令假如產生警告或錯誤訊號的話 PHP 將不會理會這些警告也不會將警告句子打出來。 

   </simpara>
   <simpara>
假如設置了 <link linkend="ini.track-errors">track_errors</link>
選項， 所有錯誤信息會被抄到 $php_errormsg 變數中。 這個變數並不是陣列， 
每次有新的錯誤都會取代原來的信息， 所以要用的話要盡早取用。 
   </simpara>
   <para>
    <informalexample>
     <programlisting role="php">
&lt;?php
/* Intentional SQL error (extra quote): */
$res = @mysql_query ("select name, code from 'namelist") or
    die ("Query failed: error was '$php_errormsg'");
?&gt;
     </programlisting>
    </informalexample>
   </para>
   <simpara>
另請看 <function>error_reporting</function>一節。 
   </simpara>
   <warning>
    <para>
     Currently the "@" error-control operator prefix will even disable
     error reporting for critical errors that will terminate script
     execution. Among other things, this means that if you use "@" to
     suppress errors from a certain function and either it isn't
     available or has been mistyped, the script will die right there
     with no indication as to why.
    </para>
   </warning>
  </sect1>
  
  <sect1 id="language.operators.execution">
   <title>可執行命令的運算符</title>
   <para>
PHP 也有一個執行命令的算符: 倒斜點 (``)。 留意它並不是單引號！ PHP 
會像執行外部程式一樣執行在 `` 之中包著的文句。 如有結果輸出的話也會打出來。 
你可以把有關的輸出結果存到變數之中。 
    <informalexample>
     <programlisting role="php">
$output = `ls -al`;
echo "&lt;pre&gt;$output&lt;/pre&gt;";
     </programlisting>
    </informalexample>
   </para>
   <note>
    <para>
     The backtick operator is disabled when <link
     linkend="ini.safe-mode">safe mode</link> is enabled.
    </para>
   </note>
   <para>
    另請看  <function>system</function>,
    <function>passthru</function>, <function>exec</function>,
    <function>popen</function>, 和    <function>escapeshellcmd</function>.
   </para>
  </sect1>

  <sect1 id="language.operators.increment">
   <title>Incrementing/Decrementing 增值/損值運算符
</title>
   <para>
PHP 支援 C 樣式的前置和後置增損算符。 
   </para>
   <table>
    <title>Increment/decrement 增損運算符</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>示範</entry>
       <entry>算符名稱</entry>
       <entry>作用</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>++$a</entry>
       <entry>Pre-increment 前置增值</entry>
       <entry>先把 $a 增加 1， 再傳回 $a 的值。 </entry>
      </row>
      <row>
       <entry>$a++</entry>
       <entry>Post-increment 後置增值</entry>
       <entry>先傳回 $a 的值再把 $a 增加 1。</entry>
      </row>
      <row>
       <entry>--$a</entry>
       <entry>Pre-decrement</entry>
       <entry>先把 $a 減去 1， 再傳回 $a 的值。</entry>
      </row>
      <row>
       <entry>$a--</entry>
       <entry>Post-decrement</entry>
       <entry>先傳回 $a 的值再把 $a 減去 1。</entry>
      </row>
     </tbody>
    </tgroup>
   </table>
   <para>
    這兒有個簡單的例子: 
    <informalexample>
     <programlisting role="php">
&lt;?php
echo "&lt;h3&gt;Postincrement&lt;/h3&gt;";
$a = 5;
echo "Should be 5: " . $a++ . "&lt;br&gt;\n";
echo "Should be 6: " . $a . "&lt;br&gt;\n";

echo "&lt;h3&gt;Preincrement&lt;/h3&gt;";
$a = 5;
echo "Should be 6: " . ++$a . "&lt;br&gt;\n";
echo "Should be 6: " . $a . "&lt;br&gt;\n";

echo "&lt;h3&gt;Postdecrement&lt;/h3&gt;";
$a = 5;
echo "Should be 5: " . $a-- . "&lt;br&gt;\n";
echo "Should be 4: " . $a . "&lt;br&gt;\n";

echo "&lt;h3&gt;Predecrement&lt;/h3&gt;";
$a = 5;
echo "Should be 4: " . --$a . "&lt;br&gt;\n";
echo "Should be 4: " . $a . "&lt;br&gt;\n";
?&gt;
     </programlisting>
    </informalexample>
   </para>
  </sect1>

  <sect1 id="language.operators.logical">
   <title>邏輯類運算符</title>

   <table>
    <title>邏輯類運算符</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>示範</entry>
       <entry>算符名稱</entry>
       <entry> 結果 </entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>$a and $b</entry>
       <entry>And</entry>
       <entry>當 $a、$b 都是真時成立。</entry>
      </row>
      <row>
       <entry>$a or $b</entry>
       <entry>Or</entry>
       <entry> 當 $a、$b隨便一個是真時就成立。  </entry>
      </row>
      <row>
       <entry>$a xor $b</entry>
       <entry>Xor</entry>
       <entry>當 $a、$b 中有且只有一個是真時成立。 </entry>
      </row>
      <row>
       <entry>! $a</entry>
       <entry>Not</entry>
       <entry>結果是 $a 的相反。</entry>
      </row>
      <row>
       <entry>$a &amp;&amp; $b</entry>
       <entry>And</entry>
       <entry>當 $a、$b 都是真時成立。</entry>
      </row>
      <row>
       <entry>$a || $b</entry>
       <entry>Or</entry>
       <entry>當 $a、$b隨便一個是真時就成立。</entry>
      </row>
     </tbody>
    </tgroup>
   </table>
   <simpara>
"and" 和 "or" 有兩個版本， 功能是一樣的不過它們執行時的優先次序不同。 (請參考 
   <link linkend="language.operators.precedence">運算符號執行時的優先次序</link>)
   </simpara>
  </sect1>

  <sect1 id="language.operators.precedence">
   <title>運算符的先後次序 (先乘除後加減的問題)</title>
   <para>
算符的優先次序決定了算符作用的表達式之間連接的有多緊。 比如說，在 1 + 5 * 3表達式中， 
答案是 16 而不是 18， 這是因為 '*' 號比 '+' 號更優先執行。 

   </para>
   <para>
下表列出了從低到高的優先次序。 最下面算符會最先被執行。 
    <table>
     <title>運算符優先次序</title>
     <tgroup cols="2">
      <thead>
       <row>
        <entry>運算符優先次序
</entry>
        <entry>各類運算符</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry>左</entry>
        <entry>,</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>or</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>xor</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>and</entry>
       </row>
       <row>
        <entry>右</entry>
        <entry>print</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>
         = += -= *= /= .= %= &amp;= |= ^= ~= &lt;&lt;= &gt;&gt;=
        </entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>? :</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>||</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>&amp;&amp;</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>|</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>^</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>&amp;</entry>
       </row>
       <row>
        <entry> 
沒關聯   non-associative</entry>
        <entry>== != === !==</entry>
       </row>
       <row>
        <entry> 
沒關聯  non-associative</entry>
        <entry>&lt; &lt;= &gt; &gt;=</entry>
       </row>
       <row>
        <entry>左</entry>
        <entry>&lt;&lt; &gt;&gt;</entry>
       </row>
       <row>
        <entry>左 </entry>
        <entry>+ - .</entry>
       </row>
       <row>
        <entry>左 </entry>
        <entry>* / %</entry>
       </row>
       <row>
        <entry>右</entry>
        <entry>! ~ ++ -- (int) (double) (string) (array) (object) @</entry>
       </row>
       <row>
        <entry>右</entry>
        <entry>[</entry>
       </row>
       <row>
        <entry> 
沒關聯  non-associative</entry>
        <entry>new</entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>
  </sect1>

  <sect1 id="language.operators.string">
   <title>文句運算符</title>
   <simpara>
有兩個文句運算符可用。 第一個是串接文句用的('.')： 
它的值就是把右面的文句加到左面文句的尾巴上去。 第二個就是串接指派合併到一塊的 ('.=') 
算符。 這類合併算符的詳情請看
<link
    linkend="language.operators.assignment">指派運算符 </link>一節。 

   </simpara>

   <para>
    <informalexample>
     <programlisting role="php">
$a = "Hello ";
$b = $a . "World!"; // now $b contains "Hello World!"

$a = "Hello ";
$a .= "World!";     // now $a contains "Hello World!"
     </programlisting>
    </informalexample>
   </para>
  </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
 sgml-parent-document:nil
 sgml-default-dtd-file:"../../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->

Index: phpdoc/hk/language/references.xml
+++ phpdoc/hk/language/references.xml
 <chapter id="language.references">
  <title>References Explained</title>

  <sect1 id="language.references.whatare">
   <title>What References Are</title>
   <simpara>  
    References are a means in PHP to access the same variable content 
    by different names. They are not like C pointers, they are symbol
    table aliases. Note that in PHP, variable name and variable content 
    are different, so the same content can have different names.
    The most close analogy is with Unix filenames and files -
    variable names are directory entries, while variable contents is
    the file itself. References can be thought of as hardlinking in
    Unix filesystem.
   </simpara>
  </sect1>

  <sect1 id="language.references.whatdo">
   <title>What References Do</title>
   <para>
    PHP references allow you to make two variables to refer to the
    same content. Meaning, when you do:
    <informalexample>
     <programlisting role="php">
$a =&amp; $b 
     </programlisting>
    </informalexample>
    it means that <varname>$a</varname> and <varname>$b</varname>
    point to the same variable.
    <note>
     <para>
      <varname>$a</varname> and <varname>$b</varname> are completely
      equal here, that's not <varname>$a</varname> is pointing to
      <varname>$b</varname> or vice versa, that's
      <varname>$a</varname> and <varname>$b</varname> pointing to the
      same place.
     </para>
    </note>
   </para>
   <para>
   The same syntax can be used with functions, that return references,
   and with <literal>new</literal> operator (in PHP 4.0.4 and later):
    <informalexample>
     <programlisting role="php">
$bar =&amp; new fooclass();
$foo =&amp; find_var ($bar);
    </programlisting>
    </informalexample>
    </para>
    <note>
     <para>
     Unless you use the syntax above, the result of 
     <literal>$bar = new fooclass()</literal> will not be the same
      variable as <literal>$this</literal> in the constructor, meaning
     that if you have used reference to <literal>$this</literal> in
     the constructor, you should use reference assignment, or you get
     two different objects.
     </para>
   </note>
   <para>
    The second thing references do is to pass variables
    by-reference. This is done by making a local variable in a function and
    a variable in the calling scope reference to the same content. Example:
    <informalexample>
     <programlisting role="php">
function foo (&amp;$var) {
    $var++;
}

$a=5;
foo ($a);
     </programlisting>
    </informalexample>
    will make <varname>$a</varname> to be 6. This happens because in
    the function <varname>foo</varname> the variable
    <varname>$var</varname> refers to the same content as
    <varname>$a</varname>. See also more detailed explanations about <link
    linkend="language.references.pass">passing by reference</link>.
   </para>
   <simpara>
    The third thing reference can do is <link
    linkend="language.references.return">return by reference</link>.
   </simpara>
  </sect1>

  <sect1 id="language.references.arent">
   <title>What References Are Not</title>
   <para>
    As said before, references aren't pointers. That means, the
    following construct won't do what you expect:
    <informalexample>
     <programlisting role="php">
function foo (&amp;$var) {
    $var =&amp; $GLOBALS["baz"];
}
foo($bar); 
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    What happens is that <varname>$var</varname> in foo will be bound
    with <varname>$bar</varname> in caller, but then it will be
    re-bound with <varname>$GLOBALS["baz"]</varname>. There's no way
    to bind <varname>$bar</varname> in the calling scope to something else
    using the reference mechanism, since <varname>$bar</varname> is not
    available in the function foo (it is represented by
    <varname>$var</varname>, but <varname>$var</varname> has only
    variable contents and not name-to-value binding in the calling
    symbol table).
   </simpara>
  </sect1>

  <sect1 id="language.references.pass">
   <title>Passing by Reference</title>
   <para>
   You can pass variable to function by reference, so that function could modify
   its arguments. The sytax is as follows:
    <informalexample>
     <programlisting role="php">
function foo (&amp;$var) {
    $var++;
}

$a=5;
foo ($a);
// $a is 6 here
     </programlisting>
    </informalexample>
  Note that there's no reference sign on function call - only on
  function definition. Function definition alone is enough to
  correctly pass the argument by reference. 
  </para>
  <para>
  Following things can be passed by reference:
   <itemizedlist>
    <listitem>
     <simpara>
      Variable, i.e. <literal>foo($a)</literal>
     </simpara>
    </listitem>
    <listitem>
     <simpara>
      New statement, i.e. <literal>foo(new foobar())</literal>
     </simpara>
    </listitem>
    <listitem>
     <para>
      Reference, returned from a function, i.e.:
    <informalexample>
     <programlisting role="php">
function &amp;bar()
{
   $a = 5;
   return $a;
}
foo(bar());
     </programlisting>
    </informalexample>
    See also explanations about <link
    linkend="language.references.return">returning by reference</link>. 
     </para>
    </listitem>
  </itemizedlist>
  </para>
  <para>
  Any other expression should not be passed by reference, as the
  result is undefined. For example, the following examples of passing
  by reference are invalid:
    <informalexample>
     <programlisting role="php">
function bar() // Note the missing &amp;
{
        $a = 5;
        return $a;
}
foo(bar));

foo($a = 5) // Expression, not variable
foo(5) // Constant, not variable
     </programlisting>
    </informalexample>
These requirements are for PHP 4.0.4 and later.
  </para>
  </sect1>

  <sect1 id="language.references.return">
   <title>Returning References</title>
   <para>
    Returning by-reference is useful when you want to use a function
    to find which variable a reference should be bound to. When
    returning references, use this syntax:
    <informalexample>
     <programlisting role="php">
function &amp;find_var ($param) {
    ...code...
    return $found_var;
}

$foo =&amp; find_var ($bar);
$foo->x = 2; 
     </programlisting>
    </informalexample>
    In this example, the property of the object returned by the
    <varname>find_var</varname> function would be set, not the
    copy, as it would be without using reference syntax.
   </para>
   <note>
    <simpara>
     Unlike parameter passing, here you have to use
     <literal>&amp;</literal> in both places - to indicate that you
     return by-reference, not a copy as usual, and to indicate that
     reference binding, rather than usual assignment, should be done
     for <varname>$foo</varname>.
    </simpara>
   </note>
  </sect1>

  <sect1 id="language.references.unset">
   <title>Unsetting References</title>
   <para>
    When you unset the reference, you just break the binding between
    variable name and variable content. This does not mean that
    variable content will be destroyed. For example:
    <informalexample>
     <programlisting role="php">
$a = 1;
$b =&amp; $a;
unset ($a); 
     </programlisting>
    </informalexample>
    won't unset <varname>$b</varname>, just <varname>$a</varname>. 
   </para>
   <simpara>
    Again, it might be useful to think about this as analogous to Unix
    <command>unlink</command> call.
   </simpara>
  </sect1>

  <sect1 id="language.references.spot">
   <title>Spotting References</title>
   <simpara>
    Many syntax constructs in PHP are implemented via referencing
    mechanisms, so everything told above about reference binding also
    apply to these constructs. Some constructs, like passing and
    returning by-reference, are mentioned above. Other constructs that
    use references are:
   </simpara>

   <sect2 id="references.global">
    <title><literal>global</literal> References</title>
    <para>
     When you declare variable as <command>global $var</command> you
     are in fact creating reference to a global variable. That means,
     this is the same as:
     <informalexample>
      <programlisting role="php">
$var =&amp; $GLOBALS["var"];
      </programlisting>
     </informalexample>
    </para>
    <simpara>
     That means, for example, that unsetting <varname>$var</varname>
     won't unset global variable.
    </simpara>
   </sect2>

   <sect2 id="references.this">
    <title><literal>$this</literal></title>
    <simpara>
     In an object method, <varname>$this</varname> is always reference
     to the caller object.
    </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
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->

Index: phpdoc/hk/language/types.xml
+++ phpdoc/hk/language/types.xml
 <chapter id="language.types">
  <title>各類變數</title>

  <para>
  PHP 可以處理以下數據形態: 
   <itemizedlist>
    <listitem>
     <simpara>
      <link linkend="language.types.array">陣列 </link>
     </simpara>
    </listitem>
    <listitem>
     <simpara>
      <link linkend="language.types.double">浮點數 
      </link>
     </simpara>
    </listitem>
    <listitem>
     <simpara>
      <link linkend="language.types.integer">整數 </link>
     </simpara>
    </listitem>
    <listitem>
     <simpara>
      <link linkend="language.types.object">類別 </link>
     </simpara>
    </listitem>
    <listitem>
     <simpara>
      <link linkend="language.types.string">文句 </link>
     </simpara>
    </listitem>
   </itemizedlist>
  </para>
  <simpara>
程式員通常不用指定變數是什麼形態。 PHP 
會在運行根據該變數所含的值來自行決定該指派什麼類型給變數。 

  </simpara>
  <simpara>
  如果你想自己決定變數的形態或改變變數的形態， 要麼就是用<link
   linkend="language.types.typecasting">變數套換</link>， 不然就是調用
<function>settype</function>函數。 
  </simpara>
  <simpara>
必須注意不同形態的變數在特定情況下的不同表現。 這在  <link
   linkend="language.types.type-juggling">Type Juggling</link>一節中有更詳細的描述。 

  </simpara>

  <sect1 id="language.types.integer">
   <title>整數</title>
   <para>
整數
    <informalexample>
     <programlisting role="php">
$a = 1234; # decimal number
$a = -123; # a negative number
$a = 0123; # octal number (equivalent to 83 decimal)
$a = 0x12; # hexadecimal number (equivalent to 18 decimal)
     </programlisting>
    </informalexample>
    The size of an integer is platform-dependent, although a 
    maximum value of about 2 billion is the usual value 
    (that's 32 bits signed).
   </para>
  </sect1>

  <sect1 id="language.types.double">
   <title>浮點數</title>
   <para>
   指定浮點形態 (DOUBLES) 的變數可用以下句法 :     <informalexample>
     <programlisting role="php"> 
$a = 1.234; $a = 1.2e3;
     </programlisting>
    </informalexample>
    The size of a floating point number is platform-dependent, 
    although a maximum of ~1.8e308 with a precision of roughly 14 
    decimal digits is a common value (that's 64 bit IEEE format).
   </para>
   <warning id="warn.float-precision">
    <para>
     It is quite usual that simple decimal fractions like
     <literal>0.1</literal> or <literal>0.7</literal> cannot be
     converted into their internal binary counterparts without a
     little loss of precision. This can lead to confusing results: for
     example, <literal>floor((0.1+0.7)*10)</literal> will usually
     return <literal>7</literal> instead of the expected
     <literal>8</literal> as the result of the internal representation
     really being something like <literal>7.9999999999...</literal>.
    </para>
    <para>
     This is related to the fact that it is impossible to exactly
     express some fractions in decimal notation with a finite number
     of digits. For instance, <literal>1/3</literal> in decimal form
     becomes <literal>0.3333333. . .</literal>.
    </para>
    <para>
     So never trust floating number results to the last digit and
     never compare floating point numbers for equality. If you really
     need higher precision, you should use the <link
     linkend="ref.bc">arbitrary precision math functions</link>
     or <link linkend="ref.gmp">gmp</link> functions instead.
    </para>
   </warning>
  </sect1>

  <sect1 id="language.types.string">
   <title>文句
</title>
   <para>
指定變數為文句形態有幾種語法可以用。    </para>
   <para>
    If the string is enclosed in double-quotes ("), variables within
如果文句是用雙引號包起來的話， 含在其中的變數會被展開 (當然也受分析器分析時的限制)。 
和 C、 PERL 一樣， 想加入特別的控制符可以前置 "\"符號: 

    <table>
     <title>特別控制符號串</title>
     <tgroup cols="2">
      <thead>
       <row>
        <entry>符號串</entry>
        <entry>含意</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry><literal>\n</literal></entry>
        <entry>開新一行 (LF or 0x0A in ASCII)</entry>
       </row>
       <row>
        <entry><literal>\r</literal></entry>
        <entry> 斷行 (CR or 0x0D in ASCII)</entry>
       </row>
       <row>
        <entry><literal>\t</literal></entry>
        <entry>跳格 (HT or 0x09 in ASCII)</entry>
       </row>
       <row>
        <entry><literal>\\</literal></entry>
        <entry>backslash 反斜線</entry>
       </row>
       <row>
        <entry><literal>\$</literal></entry>
        <entry>$ 符號</entry>
       </row>
       <row>
        <entry><literal>\"</literal></entry>
        <entry>雙引號</entry>
       </row>
       <row>
        <entry><literal>\[0-7]{1,3}</literal></entry>
        <entry>
8 進制的字符 (左面用的是 REGULAR EXPRESSION 的表達方法‧) 
        </entry>
       </row>
       <row>
        <entry><literal>\x[0-9A-Fa-f]{1,2}</literal></entry>
        <entry>
 16 進制的字符  
        </entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>

   <para>
你可以在 "\" 後放上任何別的字元， 但是在程式執行時會有警告。(除非另外調設， 
否則警告不會影響程式執行。 

   </para>

   <para>
第二種定義文句的方法的方法是用單引號 "'"。 在單引號文句中只有兩個按制項： "\\" 和 
"\'"， 這是為了能在文句中加入單引號。 單引號文句中的變數並不會 被展開。 

   </para>

   <simpara>
另外還有一種界定文句的方法： 用 HERE DOC 的句式
    ("&lt;&lt;&lt;")。 注意要在 
    <literal>&lt;&lt;&lt;</literal>之後加上一個辨識字並必須在文句完後的第一行 最開頭 
加上同一個辨識字。
   </simpara>
   
   <simpara>
    The closing identifier <emphasis>must</emphasis> begin in the
    first column of the line.  Also, the identifier used must follow
    the same naming rules as any other label in PHP: it must contain
    only alphanumeric characters and underscores, and must start with
    a non-digit character or underscore.
   </simpara>

   <para>
    Here doc text behaves just like a double-quoted string, without
    the double-quotes. This means that you do not need to escape quotes
    in your here docs, but you can still use the escape codes listed
    above. Variables are expanded, but the same care must be taken
    when expressing complex variables inside a here doc as with
    strings.
    <example> 
     <title>用 Here doc 界定文句的示範</title>
     <programlisting>
&lt;?php
$str = &lt;&lt;&lt;EOD
Example of string
spanning multiple lines
using heredoc syntax.
EOD;

/* More complex example, with variables. */
class foo {
    var $foo;
    var $bar;

    function foo() {
        $this->foo = 'Foo';
        $this->bar = array('Bar1', 'Bar2', 'Bar3');
    }
}

$foo = new foo();
$name = 'MyName';

echo &lt;&lt;&lt;EOT
My name is "$name". I am printing some $foo->foo.
Now, I am printing some {$foo->bar[1]}.
This should print a capital 'A': \x41
EOT;
?>
     </programlisting>
    </example>
   </para>

   <note>
    <para>
    在 PHP 版 4 中才能用 Here doc 句法.     </para>
   </note>
   <para>
文句可以用點 '.' 串接起來。注意用 "+" 號串連文句是無效的。
<link linkend="language.operators.string">文句運算符 </link> 一節中有更詳細的紀錄。 

   </para>
   <para>
在文句中的每一個字母可以當是字母陣列中的一個個元素， 如此可以用像 C 那樣的語法來調用， 
請看下例 ： 
   </para>
   <para>
    <example>
     <title>示範文句 </title>
     <programlisting role="php">
&lt;?php
/* Assigning a string. */
$str = "This is a string";

/* Appending to it. */
$str = $str . " with some more text";

/* Another way to append, includes an escaped newline. */
$str .= " and a newline at the end.\n";

/* This string will end up being '&lt;p&gt;Number: 9&lt;/p&gt;' */
$num = 9;
$str = "&lt;p&gt;Number: $num&lt;/p&gt;";

/* This one will be '&lt;p&gt;Number: $num&lt;/p&gt;' */
$num = 9;
$str = '&lt;p&gt;Number: $num&lt;/p&gt;';

/* Get the first character of a string  */
$str = 'This is a test.';
$first = $str[0];

/* Get the last character of a string. */
$str = 'This is still a test.';
$last = $str[strlen($str)-1];
?&gt;     
     </programlisting>
    </example>
   </para>

   <sect2 id="language.types.string.conversion">
    <title>文句變換 </title>

    <simpara>
當文句被當成是數字那樣來操作時， 其形態和值跟從以下的規則：    </simpara>
    <simpara>
如果文句中有 '.'、 'e'、 'E'符號， 則文句會變成浮點數字， 反之則會被當成是整數。 
    </simpara>
    <para>
文句所代的數值視文句開頭的字母而定， 只要文句開頭的不是合理的數字符號則文句的值就會是 
0。 合理的數字符號包括正負號、 後面跟 0 到 9 的阿拉伯數字、 小數點、 
最後是可有可無的指數代表符號 ("E" 或 "e" 後面跟上一串阿拉伯數字)。 
    </para>
    <simpara>
如果在表達示中頭一項是文句則運算結果要看第二項是什麼變數形態。     </simpara>
    <informalexample>
     <programlisting role="php">
$foo = 1 + "10.5";              // $foo is double (11.5)
$foo = 1 + "-1.3e3";            // $foo is double (-1299)
$foo = 1 + "bob-1.3e3";         // $foo is integer (1)
$foo = 1 + "bob3";              // $foo is integer (1)
$foo = 1 + "10 Small Pigs";     // $foo is integer (11)
$foo = 1 + "10 Little Piggies"; // $foo is integer (11)
$foo = "10.0 pigs " + 1;        // $foo is integer (11)
$foo = "10.0 pigs " + 1.0;      // $foo is double (11)     
     </programlisting>
    </informalexample>
    <simpara>
在 Unix 手冊 strtod(3) 一條中有更關於這類變換的資料。 

    </simpara>
    <para>
如果要試用本節中示範的例子， 可以把程式碼複製到一個新的程式段中並插入下列指令行， 
它告訴你使用中的變數是什麼形態 : 

     <informalexample>
      <programlisting role="php">
echo "\$foo==$foo; type is " . gettype ($foo) . "&lt;br&gt;\n";
      </programlisting>
     </informalexample>
    </para>

   </sect2>
  </sect1>

  <sect1 id="language.types.array">
   <title>陣列</title>

   <para>
PHP 的陣列同時擁有拼雜表 HASH TABLE 和 索引表 INDEX TABLE 的特性。(關聯字索引式陣列 
ASSOCIATIVE ARRAY 和 矢量 VECTOR 就是兩個例子)
   </para>

   <sect2 id="language.types.array.single-dim">
    <title>單維陣列</title>

    <para>
在 PHP 中 數值索引式和關聯字索引式這兩類陣列其實上是一樣的。 你可用 
<function>list</function> 或  <function>array</function>
函數來建立陣列， 也可以直接指定陣列中元素的值。 
     <informalexample>
      <programlisting role="php"> 
$a[0] = "abc"; 
$a[1] = "def"; 
$b["foo"] = 13;
      </programlisting>
     </informalexample>
    </para>
    <para>
假如沒有給出陣列元素的參照標號， PHP 會在陣列最未端加入一個元素， 
並把數值存到該元素中去。 用這個特點你可以很簡單地建立一個陣列。 

     <informalexample>
      <programlisting role="php"> 
$a[] = "hello"; // $a[2] == "hello"
$a[] = "world"; // $a[3] == "world" 
      </programlisting>
     </informalexample>
    </para>
    <para>
要把陣列中的元素排序， 可按陣列的形態調用 <function>asort</function>,
     <function>arsort</function>, <function>ksort</function>,
     <function>rsort</function>, <function>sort</function>,
     <function>uasort</function>, <function>usort</function>, 
     <function>uksort</function> 等函數。     </para>
    <para>
     <function>count</function> 函數會給出陣列中有多少個元素。
    </para>
    <para>
     你可以用  <function>next</function>及
     <function>prev</function>函數來指向陣列中的不同元素， 另一個常用的同類函數是 
<function>each</function>.
    </para>
   </sect2>

   <sect2 id="language.types.array.multi-dim">
    <title>高維陣列</title>

    <para>
高維陣列(多維陣列) 的使用其實是很簡單的。 你只要在陣列後面加多一個引數 "[ ]"， 
陣列便多了一個維數： 
     <informalexample>
      <programlisting role="php"> 
$a[1]      = $f;               # one dimensional examples
$a["foo"]  = $f;   

$a[1][0]     = $f;             # two dimensional
$a["foo"][2] = $f;             # (you can mix numeric and associative indices)
$a[3]["bar"] = $f;             # (you can mix numeric and associative indices)

$a["foo"][4]["bar"][0] = $f;   # four dimensional!
      </programlisting>
     </informalexample>
    </para>
    <para>
PHP3 並不允許直接在文句之中參照多維陣列中的元素。 如下例的程式將產生錯誤的結果。 

     <informalexample>
      <programlisting role="php"> 
$a[3]['bar'] = 'Bob';
echo "This won't work: $a[3][bar]";
      </programlisting>
     </informalexample>
用 PHP3， 以上運算的結果將是 This won't work: Array[bar]！ 對付這個問題要用到 "." 
文句拼合運算符才行：      <informalexample>
      <programlisting role="php">
$a[3]['bar'] = 'Bob';
echo "This will work: " . $a[3][bar];
      </programlisting>
     </informalexample>
    </para>
    <para>
在 PHP4 版本中， 用花括號在文句中把陣列參照包起來就解決了以上的古怪問題 : 
     <informalexample>
      <programlisting role="php">
$a[3]['bar'] = 'Bob';
echo "This will work: {$a[3][bar]}";
      </programlisting>
     </informalexample>
    </para>
    <para>
要填滿一個多維的陣列有很多辦法。 但比較難弄懂的是用 
     <function>array</function> 函數來指定關聯字索引式陣列 ASSOCIATIVE ARRAY 中的值。 
以下兩段程式碼的功能是完全一樣的 : 
     <informalexample>
      <programlisting role="php"> 
# Example 1:

$a["color"]     = "red";
$a["taste"]     = "sweet";
$a["shape"]     = "round";
$a["name"]      = "apple";
$a[3]           = 4;

# Example 2:
$a = array(
     "color" => "red",
     "taste" => "sweet",
     "shape" => "round",
     "name"  => "apple",
     3       => 4
);
      </programlisting>
     </informalexample>
    </para>
    <para>
     用巢狀的 <function>array</function> 函數可以建立出多維的陣列 : 
     <informalexample>
      <programlisting role="php"> 
&lt;?php
$a = array(
     "apple"  => array(
          "color"  => "red",
          "taste"  => "sweet",
          "shape"  => "round"
     ),
     "orange"  => array(
          "color"  => "orange",
          "taste"  => "tart",
          "shape"  => "round"
     ),
     "banana"  => array(
          "color"  => "yellow",
          "taste"  => "paste-y",
          "shape"  => "banana-shaped"
     )
);

echo $a["apple"]["taste"];    # will output "sweet"
?>
      </programlisting>
     </informalexample>
    </para>

   </sect2>
  </sect1>

  <sect1 id="language.types.object">
   <title>物件</title>

   <sect2 id="language.types.object.init">
    <title>建立物件</title>

    <para>
用 NEW 指令可以把變數指定為某一物件。 
     <informalexample>
      <programlisting role="php">
&lt;?php
class foo {
    function do_foo() { 
        echo "Doing foo."; 
    }
}

$bar = new foo;
$bar->do_foo();
?>
      </programlisting>
     </informalexample>
    </para>
    <simpara>
     For a full discussion, please read the section <link
     linkend="language.oop">Classes and Objects</link>.
    </simpara>

   </sect2>
  </sect1>

  <sect1 id="language.types.type-juggling">
   <title>各類變數間的互換</title>

   <simpara>
PHP 既不需要也不支援明確地公告變數的形態。 變數的類形視它所儲存的資料而定： 
如果你把文句存到 var當中， var 會是文句形變數； 如果存入的是整數 var，它就變成整數形。 
   </simpara>
   <para>
下面用 "+" 加號的運算來示範 PHP 怎樣自動調整變數的形態。 
如果加數和被加數中任何一個是浮點數， 運算的結果將會是浮點數， 反之則結果會是整數形態。 
注意這種調整只是用在運算之中， 並不會改變加數和被加數本來的類形。 

    <informalexample>
     <programlisting role="php">
$foo = "0";  // $foo is string (ASCII 48)
$foo++;      // $foo is the string "1" (ASCII 49)
$foo += 1;   // $foo is now an integer (2)
$foo = $foo + 1.3;  // $foo is now a double (3.3)
$foo = 5 + "10 Little Piggies"; // $foo is integer (15)
$foo = 5 + "10 Small Pigs";     // $foo is integer (15)
     </programlisting>
    </informalexample>
   </para>
   <simpara>
若嫌上面的例子用的句法比較舊， 可以參考 <link
    linkend="language.types.string.conversion">文句變換</link>一節。 
   </simpara>
   <simpara>
如果不想 PHP 自動調節變數的形態而打算自己指定變數在運算中的形態可看
<link linkend="language.types.typecasting">形態套換</link>. 。 如想改變變數的類形， 
可使用 
    <function>settype</function>函數。 
   </simpara>
   <para>
假如你想試本節中的示例， 可以把程式碼部份複制出來然後加上下面一行指令， 
你告訴它變數的名字， 它告訴你變數的形態: 
    <informalexample>
     <programlisting role="php">
echo "\$foo==$foo; type is " . gettype ($foo) . "&lt;br&gt;\n";
     </programlisting>
    </informalexample>
   </para>
   <note>
    <para>
PHP 暫時還沒有定義怎把一個非陣列變數自動轉換成陣列變數。 
     <informalexample>
      <programlisting role="php">
$a = 1;       // $a is an integer
$a[0] = "f";  // $a becomes an array, with $a[0] holding "f"
      </programlisting>
     </informalexample>
    </para>
    <para>
上面的例子看起來行得通： "f" 會變成是陣列 $a 的第個元素， 現在看看下個示例： 

     <informalexample>
      <programlisting role="php">
$a = "1";     // $a is a string
$a[0] = "f";  // What about string offsets? What happens?
      </programlisting>
     </informalexample>
    </para>
    <para>
由於 PHP 用來表示文句中某個字母的句法和用來表示陣列中某個元素的句法是一樣的， 
上面的例句會產生歧義： "f" 應該代表文句變數 $a 中的首個字母還是應該代表陣列變數 $a[] 
中的第一個元素？ 

    </para>
    <para>
因此在 PHP 3.0.12 and PHP 4.0b3-RC4 兩個版本中， 並沒有定義上述的變換該怎樣做。 
解決的辦法目前還在討論當中。 

    </para>
   </note>

   <sect2 id="language.types.typecasting">
    <title>形態套換
</title>

    <para>
和 C 的句法一樣， 要把變數的形態套換成另一種形態可以用圓括號 "( )" 
把想指定的類形括起來放在變數前面。 

     <informalexample>
      <programlisting role="php">
$foo = 10;   // $foo is an integer
$bar = (double) $foo;   // $bar is a double
      </programlisting>
     </informalexample>
    </para>
    <para>
下列的套換是合法的： 
     <itemizedlist>
      <listitem>
       <simpara>(int), (integer) - 當成整數</simpara>
      </listitem>
      <listitem>
       <simpara>(real), (double), (float) - 當成浮點數</simpara>
      </listitem>
      <listitem>
       <simpara>(string) - 當成文句</simpara>
      </listitem>
      <listitem>
       <simpara>(array) - 當成陣列</simpara>
      </listitem>
      <listitem>
       <simpara>(object) - 當成物件</simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
由於括號中可以放進空格和跳格符號， 所以下面的指令是等效的: 
     <informalexample>
      <programlisting role="php">
$foo = (int) $bar;
$foo = ( int ) $bar;
      </programlisting>
     </informalexample>
    </para>
    <para>
    某些套換的結果並不能一眼看出來， 進行這樣的轉換時要留意以下幾點。 
    </para>
    <para>
    當把數字或文句套換成陣列時， 數值或整句文句會成為陣列中的首個元素。 
     <informalexample>
      <programlisting role="php">
$var = 'ciao';
$arr = (array) $var;
echo $arr[0];  // outputs 'ciao'  
      </programlisting>
     </informalexample>
    </para>
    <para>
當把數字或文句套換成物件時， 物件中會自動產生一個叫 SCALAR 的屬性， 
當中儲存了套換前變數中的內容。 
     <informalexample>
      <programlisting role="php">
$var = 'ciao';
$obj = (object) $var;
echo $obj-&gt;scalar;  // outputs 'ciao'
      </programlisting>
     </informalexample>
    </para>

   </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
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->

Index: phpdoc/hk/language/variables.xml
+++ phpdoc/hk/language/variables.xml
<?xml encoding="iso-8859-1"?>
 <chapter id="language.variables">
  <title>各類變數</title>
  
  <sect1 id="language.variables.basics">
   <title>基本知識</title>

   <simpara>
所有 PHP 的變數前面都有一個 "$" 符號， 後面跟著變數的名字。 注意變數名稱是分大小寫的。
   </simpara>

   <para>
    Variable names follow the same rules as other labels in PHP. A
    valid variable name starts with a letter or underscore, followed
    by any number of letters, numbers, or underscores. As a regular
    expression, it would be expressed thus:
    '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
   </para>
   
   <note>
    <simpara>
     For our purposes here, a letter is a-z, A-Z, and the ASCII
     characters from 127 through 255 (0x7f-0xff).
    </simpara>
   </note>

   <para>
    <informalexample>
     <programlisting role="php"> 
$var = "Bob";
$Var = "Joe";
echo "$var, $Var";      // outputs "Bob, Joe"

$4site = 'not yet';     // invalid; starts with a number
$_4site = 'not yet';    // valid; starts with an underscore
$t銛te = 'mansikka';    // valid; '?' is ASCII 228.
     </programlisting>
    </informalexample>
   </para>

   <para>
   在 PHP3 的時期， 指定給變數的都是值， 例如把一行表達式指定給變數的話， 
變數所儲存的將是表達式計算出來的值。 它的引申意義是如果你把某變數指定給另一個變數後， 
改變其中一個的內容並不會影響另外的一個。 想進一步瞭解這種指定變數方法， 請看 
<link
    linkend="language.expressions">表達式</link>一節。 
   </para>
   <para>
    PHP4 則提供了另一種指定變數的方法: 
    <emphasis>變數參照</emphasis>. 意思是新變數只是參照本來的變數中的值。 (換個說法， 
新的變數只是本來的變數的"別名"， 也可說新變數是舊變數的"指標") 無論改變哪一個變數， 
改動都同時反映在另一個變數中。 由於舊變數的值並沒有被抄到新變數中， 
所以這種指定變數的方法執行時會快一點， 但也只是一點而已。 
只有在指定大型的陣列、物件或是在大量的迴圈操作中才會看出效益來。 
   </para>
   <para>
    作參照指定的方式是在被參照的變數(舊變數)前加上個(&amp;) 符號。 
像下面的示例會連續打出兩句相同的句子: 

    <informalexample>
     <programlisting role="php">
&lt;?php
$foo = 'Bob';              // Assign the value 'Bob' to $foo
$bar = &amp;$foo;          // Reference $foo via $bar.
$bar = "My name is $bar";  // Alter $bar...
echo $foo;                 // $foo is altered too.
echo $bar;
?&gt;
     </programlisting>
    </informalexample>
   </para>

   <para>
    有一點很重要的是只有真正的變數才可以作為舊變數被參照。 
    <informalexample>
     <programlisting role="php">
&lt;?php
$foo = 25;
$bar = &amp;$foo;      // This is a valid assignment.
$bar = &amp;(24 * 7);  // Invalid; references an unnamed expression.

function test() {
   return 25;
}

$bar = &amp;test();    // Invalid.
?&gt;
     </programlisting>
    </informalexample>
   </para>

  </sect1>

  <sect1 id="language.variables.predefined">
   <title>已預設好的變數</title>
   
   <simpara>
    PHP provides a large number of predefined variables to any script
    which it runs. Many of these variables, however, cannot be fully
    documented as they are dependent upon which server is running, the
    version and setup of the server, and other factors. Some of these
    variables will not be available when PHP is run on the
    command-line.
   </simpara>

   <simpara>
    Despite these factors, here is a list of predefined variables
    available under a stock installation of PHP 3 running as a module
    under a stock installation of <ulink
    url="&url.apache;">Apache</ulink> 1.3.6.
   </simpara>

   <simpara>
    For a list of all predefined variables (and lots of other useful
    information), please see (and use) <function>phpinfo</function>.
   </simpara>

   <note>
    <simpara>
     This list is neither exhaustive nor intended to be. It is simply
     a guideline as to what sorts of predefined variables you can
     expect to have access to in your script.
    </simpara>
   </note>

   <sect2 id="language.variables.predefined.apache">
    <title>Apache variables</title>

    <simpara>
     These variables are created by the <ulink
     url="&url.apache;">Apache</ulink> webserver. If you are running
     another webserver, there is no guarantee that it will provide the
     same variables; it may omit some, or provide others not listed
     here. That said, a large number of these variables are accounted
     for in the <ulink url="&url.cgispec;">CGI 1.1
     specification</ulink>, so you should be able to expect those.
    </simpara>
    <simpara>
     Note that few, if any, of these will be available (or indeed have
     any meaning) if running PHP on the command line.
    </simpara>

    <para>
     <variablelist>
      <varlistentry>
       <term>GATEWAY_INTERFACE</term>
       <listitem>
        <simpara>
         What revision of the CGI specification the server is using;
         i.e. 'CGI/1.1'.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>SERVER_NAME</term>
       <listitem>
        <simpara>
         The name of the server host under which the current script is
         executing. If the script is running on a virtual host, this
         will be the value defined for that virtual host.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>SERVER_SOFTWARE</term>
       <listitem>
        <simpara>
         Server identification string, given in the headers when
         responding to requests.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>SERVER_PROTOCOL</term>
       <listitem>
        <simpara>
         Name and revision of the information protocol via which the
         page was requested; i.e. 'HTTP/1.0';
        </simpara>
       </listitem>
      </varlistentry>
      
      <varlistentry>
       <term>REQUEST_METHOD</term>
       <listitem>
        <simpara>
         Which request method was used to access the page; i.e. 'GET',
         'HEAD', 'POST', 'PUT'.
        </simpara>
       </listitem>
      </varlistentry>
          
      <varlistentry>
       <term>QUERY_STRING</term>
       <listitem>
        <simpara>
         The query string, if any, via which the page was accessed.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>DOCUMENT_ROOT</term>
       <listitem>
        <simpara>
         The document root directory under which the current script is
         executing, as defined in the server's configuration file.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>HTTP_ACCEPT</term>
       <listitem>
        <simpara>
         Contents of the <literal>Accept:</literal> header from the
         current request, if there is one.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>HTTP_ACCEPT_CHARSET</term>
       <listitem>
        <simpara>
         Contents of the <literal>Accept-Charset:</literal> header
         from the current request, if there is one. Example:
         'iso-8859-1,*,utf-8'.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>HTTP_ACCEPT_ENCODING</term>
       <listitem>
        <simpara>
         Contents of the <literal>Accept-Encoding:</literal> header
         from the current request, if there is one. Example: 'gzip'.
        </simpara>
       </listitem>
      </varlistentry>
      
      <varlistentry>
       <term>HTTP_ACCEPT_LANGUAGE</term>
       <listitem>
        <simpara>
         Contents of the <literal>Accept-Language:</literal> header
         from the current request, if there is one. Example: 'en'.
        </simpara>
       </listitem>
      </varlistentry>
      
      <varlistentry>
       <term>HTTP_CONNECTION</term>
       <listitem>
        <simpara>
         Contents of the <literal>Connection:</literal> header from
         the current request, if there is one. Example: 'Keep-Alive'.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>HTTP_HOST</term>
       <listitem>
        <simpara>
         Contents of the <literal>Host:</literal> header from the
         current request, if there is one.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>HTTP_REFERER</term>
       <listitem>
        <simpara>
         The address of the page (if any) which referred the browser
         to the current page. This is set by the user's browser; not
         all browsers will set this.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>HTTP_USER_AGENT</term>
       <listitem>
        <simpara>
         Contents of the <literal>User_Agent:</literal> header from
         the current request, if there is one. This is a string
         denoting the browser software being used to view the current
         page; i.e. <computeroutput>Mozilla/4.5 [en] (X11; U; Linux
         2.2.9 i586)</computeroutput>. Among other things, you can use
         this value with <function>get_browser</function> to tailor
         your page's functionality to the capabilities of the user's
         browser.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>REMOTE_ADDR</term>
       <listitem>
        <simpara>
         The IP address from which the user is viewing the current
         page.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>REMOTE_PORT</term>
       <listitem>
        <simpara>
         The port being used on the user's machine to communicate with
         the web server.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>SCRIPT_FILENAME</term>
       <listitem>
        <simpara>
         The absolute pathname of the currently executing script.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>SERVER_ADMIN</term>
       <listitem>
        <simpara>
         The value given to the SERVER_ADMIN (for Apache) directive in
         the web server configuration file. If the script is running
         on a virtual host, this will be the value defined for that
         virtual host.
        </simpara>
       </listitem>
      </varlistentry>
      
      <varlistentry>
       <term>SERVER_PORT</term>
       <listitem>
        <simpara>
         The port on the server machine being used by the web server
         for communication. For default setups, this will be '80';
         using SSL, for instance, will change this to whatever your
         defined secure HTTP port is.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>SERVER_SIGNATURE</term>
       <listitem>
        <simpara>
         String containing the server version and virtual host name
         which are added to server-generated pages, if enabled.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>PATH_TRANSLATED</term>
       <listitem>
        <simpara>
         Filesystem- (not document root-) based path to the current
         script, after the server has done any virtual-to-real
         mapping.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>SCRIPT_NAME</term>
       <listitem>
        <simpara>
         Contains the current script's path. This is useful for pages
         which need to point to themselves.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>REQUEST_URI</term>
       <listitem>
        <simpara>
         The URI which was given in order to access this page; for
         instance, '/index.html'.
        </simpara>
       </listitem>
      </varlistentry>
     </variablelist>
    </para>

   </sect2>

   <sect2 id="language.variables.predefined.environment">
    <title>Environment variables</title>

    <simpara>
     These variables are imported into PHP's global namespace from the
     environment under which the PHP parser is running. Many are
     provided by the shell under which PHP is running and different
     systems are likely running different kinds of shells, a
     definitive list is impossible. Please see your shell's
     documentation for a list of defined environment variables.
    </simpara>
    <simpara>
     Other environment variables include the CGI variables, placed
     there regardless of whether PHP is running as a server module or
     CGI processor.
    </simpara>
        
   </sect2>

   <sect2 id="language.variables.predefined.php">
    <title>PHP variables</title>
    
    <simpara>
     These variables are created by PHP itself. The
     <varname>$HTTP_*_VARS</varname> variables are available only if
     the <link linkend="ini.track-vars">track_vars</link>
     configuration is turned on. When enabled, the variables are
     always set, even if they are empty arrays. This prevents
     a malicious user from spoofing these variables.
    </simpara>

    <note>
     <para>
      As of PHP 4.0.3, <link
      linkend="ini.track-vars">track_vars</link> is always turned on,
      regardless of the configuration file setting.
     </para>
    </note>

    <para>
     If the <link
     linkend="ini.register-globals">register_globals</link> directive
     is set, then these variables will also be made available in the
     global scope of the script; i.e., separate from the
     <varname>$HTTP_*_VARS</varname> arrays. This feature should be
     used with care, and turned off if possible; while the
     <varname>$HTTP_*_VARS</varname> variables are safe, the bare
     global equivalents can be overwritten by user input, with
     possibly malicious intent. If you cannot turn off <link
     linkend="ini.register-globals">register_globals</link>, you must
     take whatever steps are necessary to ensure that the data you are
     using is safe.
    </para>
    
    <para>
     <variablelist>
      <varlistentry>
       <term>argv</term>
       <listitem>
        <simpara>
         Array of arguments passed to the script. When the script is
         run on the command line, this gives C-style access to the
         command line parameters. When called via the GET method, this
         will contain the query string.
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>argc</term>
       <listitem>
        <simpara>
         Contains the number of command line parameters passed to the
         script (if run on the command line).
        </simpara>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>PHP_SELF</term>
       <listitem>
        <simpara>
         The filename of the currently executing script, relative to
         the document root. If PHP is running as a command-line
         processor, this variable is not available.
        </simpara>
       </listitem>
      </varlistentry>
          
      <varlistentry>
       <term>HTTP_COOKIE_VARS</term>
       <listitem>
        <simpara>
         An associative array of variables passed to the current
         script via HTTP cookies. 
        </simpara>
       </listitem>
      </varlistentry>
      
      <varlistentry>
       <term>HTTP_GET_VARS</term>
       <listitem>
        <simpara>
         An associative array of variables passed to the current
         script via the HTTP GET method.
        </simpara>
       </listitem>
      </varlistentry>
      
      <varlistentry>
       <term>HTTP_POST_VARS</term>
       <listitem>
        <simpara>
         An associative array of variables passed to the current
         script via the HTTP POST method.
        </simpara>
       </listitem>
      </varlistentry>
    
      <varlistentry>
       <term>HTTP_POST_FILES</term>
       <listitem>
        <simpara>
         An associative array of variables containing information
         about files uploaded via the HTTP POST method. See <link
         linkend="features.file-upload.post-method">POST method
         uploads</link> for information on the contents of
         <varname>$HTTP_POST_FILES</varname>.
        </simpara>
        <para>
         <varname>$HTTP_POST_FILES</varname> is available only in PHP
         4.0.0 and later.
        </para>
       </listitem>
      </varlistentry>
  
    <varlistentry>
       <term>HTTP_ENV_VARS</term>
       <listitem>
        <simpara>
         An associative array of variables passed to the current
         script via the parent environment. 
        </simpara>
       </listitem>
      </varlistentry>

    <varlistentry>
       <term>HTTP_SERVER_VARS</term>
       <listitem>
        <simpara>
         An associative array of variables passed to the current
         script from the HTTP server. These variables are analogous to
         the Apache variables described above.
        </simpara>
       </listitem>
      </varlistentry>
     </variablelist>
    </para>
        
   </sect2>

  </sect1>


  <sect1 id="language.variables.scope">
   <title>變數的有效範圍</title>

   <simpara>
    變數的有效範圍是指只有在該範圍之內電腦才知道有這樣一個變數存在並可存取其所儲的值。 
大前題是所有的 PHP 變數都只有單一的有效範圍。 這有效範圍伸展到被 include() 和 
require() 的文件中。 請看示範: 

   </simpara>
   <informalexample>
    <programlisting role="php">
$a = 1;
include "b.inc";
    </programlisting>
   </informalexample>
   <simpara>
   在 b.inc 文件中 $a 變數的值也是 1 。 然而， 
在函數中的變數其有效範圍則局限在函數的本體之中。 
跳進函數時電腦不會知道在函數被調用之前有什麼變數曾被定義， 
而所有在函數執行時才定義的變數在跳出函數後都會消失。 如下例: 
   </simpara>
    
   <informalexample>
    <programlisting role="php"> 
$a = 1; /* global scope */ 

Function Test () { 
    echo $a; /* reference to local scope variable */ 
} 

Test ();
    </programlisting>
   </informalexample>

   <simpara>
    該程式並不會打出任何值因為在 echo $a 這一指令中， $a 
的有效範圍只是在函數之中，但在函數當中並沒有定義 $a 的值； 另一方面在函數外的 $a 
的有效範圍並不會伸展到函數裏去。 如你是 C 程式員的話請留意這種有效範圍的定法和 C 
不一樣： 在 C 當中所有主程式中的變數都是全域變數。 (除非在函數中另外指定。) 因為 C 
的方式會不小心在函數中改動了外部變數， 所以在 PHP 
之中有如想存取外部變數的話就必須宣告一個全域變數。 示範如下:

   </simpara>

   <informalexample>
    <programlisting role="php">
$a = 1;
$b = 2;

Function Sum () {
    global $a, $b;

    $b = $a + $b;
} 

Sum ();
echo $b;
    </programlisting>
   </informalexample>

   <simpara>
上面的例子才會印出 "3"。 在函數中宣告 $a、$b 
為全域變數之後就可以存取在函數外面的變數。 一個函數可以宣告任意多個全域變數。 
   </simpara>

   <simpara>
    另外一個存取外部變數的方法是調用 PHP 內置的 $GLOBALS[] 陣列。 
現在把前面的例子改寫一下:    </simpara>

   <informalexample>
    <programlisting role="php">
$a = 1;
$b = 2;

Function Sum () {
    $GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
} 

Sum ();
echo $b;
    </programlisting>
   </informalexample>

   <simpara>
$GLOBALS 陣列是一個關聯字索引式陣列， 變數的名字會作為在存取該陣列的索引。    
</simpara>

   <simpara>
另一個重要的變數有效範圍的概念是被宣告成 static 類型(靜態)的變數。 
靜態變數只在函數之中出現， 不過在跳出函數之後它們的值並不會消失。 考慮下面的情況:    
</simpara>

   <informalexample>
    <programlisting role="php">
Function Test () {
    $a = 0;
    echo $a;
    $a++;
}
    </programlisting>
   </informalexample>

   <simpara>
上面的函數根本起不了作用因為每次進入函數後 $a 都會被重新指定為 "0"‧ $a++ 
這一句指令一點用也沒有因為每次跳出函數時 $a 就消失了。 為了令函數成為有用的計數器， 
必須把 $a 宣告為 static:

   </simpara>

   <informalexample>
    <programlisting role="php">
Function Test () {
    static $a = 0;
    echo $a;
    $a++;
}
    </programlisting>
   </informalexample>

   <simpara>
現在 test() 函數會印出 $a 的值並把值它加 1。    </simpara>

   <simpara>
   靜態變數也可以用來編寫遞歸函數 recursive function。 這類函數會調用自己。 
寫這類函數時要避免無限循環地調用。 你一定要有辦法把遞歸終止。 下例用 $count 
變數來計數， 當它數到 10 的時候就跳出函數: 

   </simpara>

   <informalexample>
    <programlisting role="php">
Function Test () {
    static $count = 0;

    $count++;
    echo $count;
    if ($count &lt; 10) {
        Test ();
    }
    $count--;
}
    </programlisting>
   </informalexample>

  </sect1>

  <sect1 id="language.variables.variable">
   <title>用變數來調用變數</title>

   <simpara>
    有的情涗下， 用一個變數來儲存另一個變數的名字會令編程更方便。 
因為這樣一來可以動態地調用變數。 一個正常的變數宣告是這樣的: 
   </simpara>

   <informalexample>
    <programlisting role="php">
$a = "hello";
    </programlisting>
   </informalexample>

   <simpara>
而一個變數的變數則把存在其中的值當做是另一個變數的名字。 在上例的 $a 之前用兩 '$' 
號的話， hello就會被當成是另一個變數的名字： 

   </simpara>

   <informalexample>
    <programlisting role="php">
$$a = "world";
    </programlisting>
   </informalexample>

   <simpara>
到這裏為止， 一共宣告了兩個變數， 一個是 $a， 另一個是 $hello。 是以下面的指令： 

   </simpara>

   <informalexample>
    <programlisting role="php">
echo "$a ${$a}";
    </programlisting>
   </informalexample>

   <simpara>
所印出來的結果和這一句 

   </simpara>

   <informalexample>
    <programlisting>
echo "$a $hello";
    </programlisting>
   </informalexample>

   <simpara>
的結果是一樣的： hello world. 

   </simpara>

   <simpara>
在用變數的變數這法子來存取陣列的話， 要留意 $$a[1] 有兩個意思： 可以是指 $a[1] 
是一個變數的名稱、也可以指 $$a 是一個變數名稱而 [1] 是該變數中元素的索引 號。 
為了明確告訴電腦你的意圖， 用 ${$a[1]} 代表第一個意思、 ${$a}[1] 代表第二個。 
   </simpara>
  
  </sect1>

  <sect1 id="language.variables.external">
   <title>外部變數</title>

   <sect2 id="language.variables.external.form">
    <title>HTML 表 (GET and POST)
</title>

    <simpara>
當表單被提交給 PHP 程式時， 所有在表單中的變數都自動給分隔開並傳給程式。 
假如有一張如下例的表單: 
If the <link linkend="ini.track-vars">track_vars</link>
     configuration option is turned on, then these variables will be
     located in the associative arrays
     <varname>$HTTP_POST_VARS</varname>,
     <varname>$HTTP_GET_VARS</varname>, and/or
     <varname>$HTTP_POST_FILES</varname>, according to the
     source of the variable in question.
    </simpara>

    <para>
     For more information on these variables, please read <link
     linkend="language.variables.predefined">Predefined
     variables</link>.
    </para>

    <para>
     <example>
      <title>簡單的表單變數</title>
      <programlisting role="php">
&lt;form action="foo.php" method="post">
    Name: &lt;input type="text" name="username">&lt;br>
    &lt;input type="submit">
&lt;/form>
      </programlisting>
     </example>
    </para>

    <para>
當按下 SUBMIT 後， PHP 會自動指定變數 $name ， 其中會儲存表單中 Name: 這一欄所含的值。 
PHP 有個叫 track_vars 的可調項， 在開的狀態下用 POST 或 GET 
方法提交的表單欄位可以在相應的 $HTTP_POST_VARS 或 $HTTP_GET_VARS 陣列中找到。 
要打開這個功能可以改 track_vars 這個參數或使用 <?php_track_vars?> 指令。 
    </para>

    <simpara>
PHP 還可以分解表單中陣列型態的變數。 
你可利用這一特性把相關的變數分組或者是儲存容許多項選擇的表單欄位:

    </simpara>

    <para>
     <example>
      <title>複雜一些的表單
</title>
      <programlisting role="php">
&lt;form action="array.php" method="post">
    Name: &lt;input type="text" name="personal[name]">&lt;br>
    Email: &lt;input type="text" name="personal[email]">&lt;br>
    Beer: &lt;br>
    &lt;select multiple name="beer[]">
        &lt;option value="warthog">Warthog
        &lt;option value="guinness">Guinness
        &lt;option value="stuttgarter">Stuttgarter Schwabenbr&auml;u
        &lt;/select>
    &lt;input type="submit">
&lt;/form>
      </programlisting>
     </example>
    </para>

    <para>
     In PHP 3, the array form variable usage is limited to
     single-dimensional arrays. In PHP 4, no such restriction applies.
    </para>

    <sect3 id="language.variables.external.form.submit">
     <title>用 IMAGE SUBMIT 的變數名</title>

     <simpara>
      提交表單時， 可以不用標準的按鈕而用圖案代替。 句法如下:</simpara>

     <informalexample>
      <programlisting role="php">
&lt;input type=image src="image.gif" name="sub">
      </programlisting>
     </informalexample>

     <simpara>
當使用者按在該圖案上時， 傳去給伺服器的表單資料會有兩個新的值 sub_x 和 sub_y， 
分別是使用者按在圖案上的座標。 表單老手們可能會知道其實送給伺服器的的欄位是 sub.x 和 
sub.y， 不過 PHP 自動把句號變成了底線號。 

     </simpara>
    </sect3>

   </sect2>

   <sect2 id="language.variables.external.cookies">
    <title>HTTP cookies (甜餅 ?)
</title>

    <simpara>
PHP 支持由 <ulink
     url="&spec.cookies;">Netscape's Spec</ulink>所定義的 HTTP cookies。 Cookies 
是把資料存到客戶機上的一種方法。 這些資料可以用來辨別用戶的身份。 要設定 COOKIES 可用 
SetCookie() 函數。 因為 COOKIES 是 HTTP HEADER 標頭的一部份所以送出 COOKIE 
的命令必須把頁面內容輸出給瀏覽器之前執行。 這限制和使用 Header() 函數的限制是一樣的。 
至於從瀏覽器送回來的 COOKIES 則像 GET、 POST 方法一樣會自動存在變數裏。 
</simpara>

    <simpara>
如想用一個 COOKIE 存多過一個值， 只需在 COOKIE 名字後加上 []。 示範: 
    </simpara>

    <informalexample>
     <programlisting role="php">
SetCookie ("MyCookie[]", "Testing", time()+3600);
     </programlisting>
    </informalexample>

    <simpara>
注意除非路徑或網域名字不一樣， 不然你送出的 COOKIE 會取代之前同名的 COOKIE。 
因此在編寫購物籃程式時有時要加一個計數器。 就像這樣： 

    </simpara>

    <example>
     <title>SetCookie 示範</title>
     <programlisting role="php">
$Count++;
SetCookie ("Count", $Count, time()+3600);
SetCookie ("Cart[$Count]", $item, time()+3600);
     </programlisting>
    </example>

   </sect2>

   <sect2 id="language.variables.external.environment">
    <title>作業環境變數</title>

    <para>
PHP 會自動把關於作業環境的資料整理成一般的變數供程式取用。 

     <informalexample>
      <programlisting role="php">
echo $HOME;  /* Shows the HOME environment variable, if set. */
      </programlisting>
     </informalexample>
    </para>

    <para>
小心起見， 讀取環境變數時最好用      <function>getenv</function>函數， 這是因為 PHP 
一樣為表單、COOKIE 等等自動定義變數， 有時候會不小心用了相同的名字， 
到時你讀取的可能並不是真正的環境變數。 改動環境變數則可用 
     <function>putenv</function>函數。 
    </para>
   </sect2>

   <sect2 id="language.variables.external.dot-in-names">
    <title>帶 '.' 號的變數</title>

    <para>
基本上 PHP 不會擅改變數的名字， 但由於 PHP 之中 '.' 
號有特別的意思(串接文句)不可以作為變數名字， 所以帶 '.' 號的變數名稱中的 '.' 會變成 
'_': 
     <programlisting role="php">
$varname.ext;  /* invalid variable name */
     </programlisting>
上面範例中 PHP 會理解為一個變數 $varname， 後面跟著再串接另一個變數 $ext。 顯然 PHP 
理解錯了本來的用意。 
    </para>

   </sect2>

   <sect2 id="language.variables.determining-type-of">
    <title>查詢變數的形態
</title>

    <para>
     由於 PHP 會依內容自動設定變數的形態， 
有時候很難一眼看出一個變數到底取用了那一種形態。 為了讓用者取得這類資訊， PHP 
有好多個函數可以調用： 
     <function>gettype</function>, <function>is_long</function>,
     <function>is_double</function>, <function>is_string</function>,
     <function>is_array</function>,和
     <function>is_object</function>.
    </para>
   </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
 sgml-parent-document:nil
 sgml-default-dtd-file:"../../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->

[PHP-DOC] cvs: phpdoc /hk/language basic-syntax.xml constants.xml control-structures.xml expressions.xml functions.xml oop.xml operators.xml references.xml types.xml variables.xml

Reply via email to