PHP的8 種原始數據類型【基礎】

時間 2019-11-09

標籤 php 原始數據類型基礎欄目 PHP 简体版

原文原文鏈接

前言

搬運：PHP官方文檔php

四種標量類型

boolean(布爾型)

這是最簡單的類型。boolean表達了真值，能夠爲TRUE或FLASE。
要指定一個布爾值，使用關鍵字 TRUE 或 FALSE。兩個都不區分大小寫。正則表達式

<?php
$foo = True; // assign the value TRUE to $foo
?>

一般運算符所返回的 boolean 值結果會被傳遞給控制流程。數據庫

<?php
// == 是一個操做符，它檢測兩個變量是否相等，並返回一個布爾值
if ($action == "show_version") {
    echo "The version is 1.23";
}

// 這樣作是沒必要要的...
if ($show_separators == TRUE) {
    echo "<hr>\n";
}

// ...由於可使用下面這種簡單的方式：
if ($show_separators) {
    echo "<hr>\n";
}
?>

要明確地將一個值轉換成 boolean，用 (bool) 或者 (boolean) 來強制轉換。可是不少狀況下不須要用強制轉換，由於當運算符，函數或者流程控制結構須要一個 boolean 參數時，該值會被自動轉換。

當轉換爲 boolean 時，如下值被認爲是 FALSE：api

- 布爾值 FALSE 自己
- 整型值 0（零）
- 浮點型值 0.0（零）
- 空字符串，以及字符串 "0"
- 不包括任何元素的數組
- 不包括任何成員變量的對象（僅 PHP 4.0 適用）
- 特殊類型 NULL（包括還沒有賦值的變量）
- 從空標記生成的 SimpleXML 對象

其它非零值（不論正負）同樣，被認爲是 TRUE！數組

<?php
var_dump((bool) "");        // bool(false)
var_dump((bool) 1);         // bool(true)
var_dump((bool) -2);        // bool(true)
var_dump((bool) "foo");     // bool(true)
var_dump((bool) 2.3e5);     // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array());   // bool(false)
var_dump((bool) "false");   // bool(true)
?>

integer（整型）

一個 integer 是集合 ℤ = {..., -2, -1, 0, 1, 2, ...} 中的一個數。app

整型值可使用十進制，十六進制，八進制或二進制表示，前面能夠加上可選的符號（- 或者 +）；二進制表達的 integer 自 PHP 5.4.0 起可用；要使用八進制表達，數字前必須加上 0（零）。要使用十六進制表達，數字前必須加上 0x。要使用二進制表達，數字前必須加上 0b。函數

Example #1 整數文字表達oop

<?php
$a = 1234; // 十進制數
$a = -123; // 負數
$a = 0123; // 八進制數 (等於十進制 83)
$a = 0x1A; // 十六進制數 (等於十進制 26)
?>

整型數的字長和平臺有關，儘管一般最大值是大約二十億（32 位有符號）。64 位平臺下的最大值一般是大約 9E18。PHP 不支持無符號整數。Integer 值的字長能夠用常量 PHP_INT_SIZE來表示，自 PHP 4.4.0 和 PHP 5.0.5後，最大值能夠用常量 PHP_INT_MAX 來表示。

若是給定的一個數超出了 integer 的範圍，將會被解釋爲 float。一樣若是執行的運算結果超出了 integer 範圍，也會返回 float。測試

Example #2 64 位系統下的整數溢出優化

<?php
$large_number = 9223372036854775807;
var_dump($large_number);                     // int(9223372036854775807)

$large_number = 9223372036854775808;
var_dump($large_number);                     // float(9.2233720368548E+18)

$million = 1000000;
$large_number =  50000000000000 * $million;
var_dump($large_number);                     // float(5.0E+19)
?>

PHP 中沒有整除的運算符。1/2 產生出 float 0.5。值能夠捨棄小數部分強制轉換爲 integer，或者使用 round() 函數能夠更好地進行四捨五入。

<?php
var_dump(25/7);         // float(3.5714285714286) 
var_dump((int) (25/7)); // int(3)
var_dump(round(25/7));  // float(4) 
?>

轉換爲整型
要明確地將一個值轉換爲 integer，用 (int) 或 (integer) 強制轉換。不過大多數狀況下都不須要強制轉換，由於當運算符，函數或流程控制須要一個 integer 參數時，值會自動轉換。還能夠經過函數 intval() 來將一個值轉換成整型。

從布爾值轉換
FALSE 將產生出 0（零），TRUE 將產生出 1（壹）。

從浮點型轉換
當從浮點數轉換成整數時，將向下取整。

float（浮點型，也稱做 double)

浮點型（也叫浮點數 float，雙精度數 double 或實數 real）能夠用如下任一語法定義：

<?php
$a = 1.234; 
$b = 1.2e3; 
$c = 7E-10;
?>

浮點數的字長和平臺相關，儘管一般最大值是 1.8e308 並具備 14 位十進制數字的精度（64 位 IEEE 格式）。
因爲內部表達方式的緣由，比較兩個浮點數是否相等是有問題的。不過仍是有迂迴的方法來比較浮點數值的；要測試浮點數是否相等，要使用一個僅比該數值大一丁點的最小偏差值。該值也被稱爲機器極小值（epsilon）或最小單元取整數，是計算中所能接受的最小的差異值。

$a 和 $b 在小數點後五位精度內都是相等的。

<?php
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;

if(abs($a-$b) < $epsilon) {
    echo "true";
}
?>

NaN
某些數學運算會產生一個由常量 NAN 所表明的結果。此結果表明着一個在浮點數運算中未定義或不可表述的值。任何拿此值與其它任何值進行的鬆散或嚴格比較的結果都是 FALSE。
因爲 NAN 表明着任何不一樣值，不該拿 NAN 去和其它值進行比較，包括其自身，應該用 is_nan() 來檢查。

string（字符串）

一個字符串 string 就是由一系列的字符組成，其中每一個字符等同於一個字節。這意味着 PHP 只能支持 256 的字符集，所以不支持 Unicode 。

Note: string 最大能夠達到 2GB。

語法

一個字符串能夠用 4 種方式表達：

- 單引號
- 雙引號
- heredoc 語法結構
- nowdoc 語法結構（自 PHP 5.3.0 起）

單引號

定義一個字符串的最簡單的方法是用單引號把它包圍起來（字符 '）。

要表達一個單引號自身，需在它的前面加個反斜線（）來轉義。要表達一個反斜線自身，則用兩個反斜線（\）。其它任何方式的反斜線都會被當成反斜線自己：也就是說若是想使用其它轉義序列例如 r 或者 n，並不表明任何特殊含義，就單純是這兩個字符自己。

Note: 不像雙引號和 heredoc 語法結構，在單引號字符串中的變量和特殊字符的轉義序列將不會被替換。

<?php
echo 'this is a simple string';

// 能夠錄入多行
echo 'You can also have embedded newlines in 
strings this way as it is
okay to do';

// 輸出： Arnold once said: "I'll be back"
echo 'Arnold once said: "I\'ll be back"';

// 輸出： You deleted C:\*.*?
echo 'You deleted C:\\*.*?';

// 輸出： You deleted C:\*.*?
echo 'You deleted C:\*.*?';

// 輸出： This will not expand: \n a newline
echo 'This will not expand: \n a newline';

// 輸出： Variables do not $expand $either
echo 'Variables do not $expand $either';
?>

雙引號

轉義字符

序列                  含義
\n                    換行（ASCII 字符集中的 LF 或 0x0A (10)）
\r                    回車（ASCII 字符集中的 CR 或 0x0D (13)）
\t                    水平製表符（ASCII 字符集中的 HT 或 0x09 (9)）
\v                    垂直製表符（ASCII 字符集中的 VT 或 0x0B (11)）（自 PHP 5.2.5 起）
\e                    Escape（ASCII 字符集中的 ESC 或 0x1B (27)）（自 PHP 5.4.0 起）
\f                    換頁（ASCII 字符集中的 FF 或 0x0C (12)）（自 PHP 5.2.5 起）
\\                    反斜線
\$                    美圓標記
\"                    雙引號
\[0-7]{1,3}           符合該正則表達式序列的是一個以八進制方式來表達的字符
\x[0-9A-Fa-f]{1,2}    符合該正則表達式序列的是一個以十六進制方式來表達的字符

和單引號字符串同樣，轉義任何其它字符都會致使反斜線被顯示出來。PHP 5.1.1 之前，{$var} 中的反斜線還不會被顯示出來；用雙引號定義的字符串最重要的特徵是變量會被解析。

Heredoc 結構

第三種表達字符串的方法是用 heredoc 句法結構：<<<。在該運算符以後要提供一個標識符，而後換行。接下來是字符串 string 自己，最後要用前面定義的標識符做爲結束標誌。

結束時所引用的標識符必須在該行的第一列，並且，標識符的命名也要像其它標籤同樣遵照 PHP 的規則：只能包含字母、數字和下劃線，而且必須以字母和下劃線做爲開頭。

要注意的是結束標識符這行除了可能有一個分號（;）外，絕對不能包含其它字符。這意味着標識符不能縮進，分號的先後也不能有任何空白或製表符。更重要的是結束標識符的前面必須是個被本地操做系統承認的換行，好比在 UNIX 和 Mac OS X 系統中是 n，而結束定界符（可能其後有個分號）以後也必須緊跟一個換行。
若是不遵照該規則致使結束標識不「乾淨」，PHP 將認爲它不是結束標識符而繼續尋找。若是在文件結束前也沒有找到一個正確的結束標識符，PHP 將會在最後一行產生一個解析錯誤。
Heredocs 結構不能用來初始化類的屬性。自 PHP 5.3 起，此限制僅對 heredoc 包含變量時有效。
Example #1 非法的示例

<?php
class foo {
    public $bar = <<<EOT
bar
    EOT;
}
?>

Heredoc 結構就象是沒有使用雙引號的雙引號字符串，這就是說在 heredoc 結構中單引號不用被轉義，可是上文中列出的轉義序列還可使用。變量將被替換，但在 heredoc 結構中含有複雜的變量時要格外當心。

Example #2 Heredoc 結構的字符串示例

<?php
$str = <<<EOD
Example of string
spanning multiple lines
using heredoc syntax.
EOD;

/* 含有變量的更復雜示例 */
class foo
{
    var $foo;
    var $bar;

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

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

echo <<<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;
?>

以上例程會輸出：

My name is "MyName". I am printing some Foo.
Now, I am printing some Bar2.
This should print a capital 'A': A

Example #3 Heredoc 結構在參數中的示例

<?php
var_dump(array(<<<EOD
foobar!
EOD
));
?>

在 PHP 5.3.0 之後，也能夠用 Heredoc 結構來初始化靜態變量和類的屬性和常量：

Example #4 使用 Heredoc 結構來初始化靜態值

<?php
// 靜態變量
function foo()
{
    static $bar = <<<LABEL
Nothing in here...
LABEL;
}

// 類的常量、屬性
class foo
{
    const BAR = <<<FOOBAR
Constant example
FOOBAR;

    public $baz = <<<FOOBAR
Property example
FOOBAR;
}
?>

自 PHP 5.3.0 起還能夠在 Heredoc 結構中用雙引號來聲明標識符：
Example #5 在 heredoc 結構中使用雙引號

<?php
echo <<<"FOOBAR"
Hello World!
FOOBAR;
?>

Nowdoc 結構

就象 heredoc 結構相似於雙引號字符串，Nowdoc 結構是相似於單引號字符串的。Nowdoc 結構很象 heredoc 結構，可是 nowdoc 中不進行解析操做。這種結構很適合用於嵌入 PHP 代碼或其它大段文本而無需對其中的特殊字符進行轉義。與 SGML 的 <![CDATA[ ]]> 結構是用來聲明大段的不用解析的文本相似，nowdoc 結構也有相同的特徵。

一個 nowdoc 結構也用和 heredocs 結構同樣的標記 <<<，可是跟在後面的標識符要用單引號括起來，即 <<<'EOT'。Heredoc 結構的全部規則也一樣適用於 nowdoc 結構，尤爲是結束標識符的規則。

Example #6 Nowdoc 結構字符串示例

<?php
$str = <<<'EOD'
Example of string
spanning multiple lines
using nowdoc syntax.
EOD;

/* 含有變量的更復雜的示例 */
class foo
{
    public $foo;
    public $bar;

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

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

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

以上例程會輸出：

My name is "$name". I am printing some $foo->foo.
Now, I am printing some {$foo->bar[1]}.
This should not print a capital 'A': \x41

Note:
不象 heredoc 結構，nowdoc 結構能夠用在任意的靜態數據環境中，最典型的示例是用來初始化類的屬性或常量：
Nowdoc 結構是在 PHP 5.3.0 中加入的。

Example #7 靜態數據的示例

<?php
class foo {
    public $bar = <<<'EOT'
bar
EOT;
}
?>

變量解析

當字符串用雙引號或 heredoc 結構定義時，其中的變量將會被解析。

這裏共有兩種語法規則：一種簡單規則，一種複雜規則。簡單的語法規則是最經常使用和最方便的，它能夠用最少的代碼在一個 string 中嵌入一個變量，一個 array 的值，或一個 object 的屬性。

複雜規則語法的顯著標記是用花括號包圍的表達式。

簡單語法

當 PHP 解析器遇到一個美圓符號（$）時，它會和其它不少解析器同樣，去組合儘可能多的標識以造成一個合法的變量名。能夠用花括號來明確變量名的界線。

<?php
$juice = "apple";

echo "He drank some $juice juice.".PHP_EOL;
// Invalid. "s" is a valid character for a variable name, but the variable is $juice.
echo "He drank some juice made of $juices.";
?>

以上例程會輸出：

He drank some apple juice.
He drank some juice made of .

相似的，一個 array 索引或一個 object 屬性也可被解析。數組索引要用方括號（]）來表示索引結束的邊際，對象屬性則是和上述的變量規則相同。

Example #8 簡單語法示例

<?php
$juices = array("apple", "orange", "koolaid1" => "purple");

echo "He drank some $juices[0] juice.".PHP_EOL;
echo "He drank some $juices[1] juice.".PHP_EOL;
echo "He drank some juice made of $juice[0]s.".PHP_EOL; // Won't work
echo "He drank some $juices[koolaid1] juice.".PHP_EOL;

class people {
    public $john = "John Smith";
    public $jane = "Jane Smith";
    public $robert = "Robert Paulsen";
    
    public $smith = "Smith";
}

$people = new people();

echo "$people->john drank some $juices[0] juice.".PHP_EOL;
echo "$people->john then said hello to $people->jane.".PHP_EOL;
echo "$people->john's wife greeted $people->robert.".PHP_EOL;
echo "$people->robert greeted the two $people->smiths."; // Won't work
?>

以上例程會輸出：

He drank some apple juice.
He drank some orange juice.
He drank some juice made of s.
He drank some purple juice.
John Smith drank some apple juice.
John Smith then said hello to Jane Smith.
John Smith's wife greeted Robert Paulsen.
Robert Paulsen greeted the two .

若是想要表達更復雜的結構，請用複雜語法。

複雜（花括號）語法

複雜語法不是由於其語法複雜而得名，而是由於它可使用複雜的表達式。

任何具備 string 表達的標量變量，數組單元或對象屬性均可使用此語法。只需簡單地像在 string 之外的地方那樣寫出表達式，而後用花括號 { 和 } 把它括起來便可。因爲 { 沒法被轉義，只有 $ 緊挨着 { 時纔會被識別。能夠用 {\$ 來表達 {$。下面的示例能夠更好的解釋：

<?php
// 顯示全部錯誤
error_reporting(E_ALL);

$great = 'fantastic';

// 無效，輸出: This is { fantastic}
echo "This is { $great}";

// 有效，輸出： This is fantastic
echo "This is {$great}";
echo "This is ${great}";

// 有效
echo "This square is {$square->width}00 centimeters broad."; 

// 有效，只有經過花括號語法才能正確解析帶引號的鍵名
echo "This works: {$arr['key']}";

// 有效
echo "This works: {$arr[4][3]}";

// 這是錯誤的表達式，由於就象 $foo[bar] 的格式在字符串之外也是錯的同樣。
// 換句話說，只有在 PHP 能找到常量 foo 的前提下才會正常工做；這裏會產生一個
// E_NOTICE (undefined constant) 級別的錯誤。
echo "This is wrong: {$arr[foo][3]}"; 

// 有效，當在字符串中使用多重數組時，必定要用括號將它括起來
echo "This works: {$arr['foo'][3]}";

// 有效
echo "This works: " . $arr['foo'][3];

echo "This works too: {$obj->values[3]->name}";

echo "This is the value of the var named $name: {${$name}}";

echo "This is the value of the var named by the return value of getName(): {${getName()}}";

echo "This is the value of the var named by the return value of \$object->getName(): {${$object->getName()}}";

// 無效，輸出： This is the return value of getName(): {getName()}
echo "This is the return value of getName(): {getName()}";
?>

也能夠在字符串中用此語法經過變量來調用類的屬性。

<?php
class foo {
    var $bar = 'I am bar.';
}

$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo "{$foo->$bar}\n";
echo "{$foo->$baz[1]}\n";
?>

以上例程會輸出：

I am bar.
I am bar.

函數、方法、靜態類變量和類常量只有在 PHP 5 之後纔可在 {$} 中使用。然而，只有在該字符串被定義的命名空間中才能夠將其值做爲變量名來訪問。只單一使用花括號 ({}) 沒法處理從函數或方法的返回值或者類常量以及類靜態變量的值。
轉換成字符串

一個值能夠經過在其前面加上 (string) 或用 strval() 函數來轉變成字符串。在一個須要字符串的表達式中，會自動轉換爲 string。好比在使用函數 echo 或 print 時，或在一個變量和一個 string 進行比較時，就會發生這種轉換。類型和類型轉換能夠更好的解釋下面的事情，也可參考函數 settype()。

一個布爾值 boolean 的 TRUE 被轉換成 string 的 "1"。Boolean 的 FALSE 被轉換成 ""（空字符串）。這種轉換能夠在 boolean 和 string 之間相互進行。

一個整數 integer 或浮點數 float 被轉換爲數字的字面樣式的 string（包括 float 中的指數部分）。使用指數計數法的浮點數（4.1E+6）也可轉換。

數組 array 老是轉換成字符串 "Array"，所以，echo 和 print 沒法顯示出該數組的內容。要顯示某個單元，能夠用 echo $arr['foo'] 這種結構。

資源 resource 總會被轉變成 "Resource id #1" 這種結構的字符串，其中的 1 是 PHP 在運行時分配給該 resource 的惟一值。不要依賴此結構，可能會有變動。要獲得一個 resource 的類型，能夠用函數 get_resource_type()。

NULL 老是被轉變成空字符串。

如上面所說的，直接把 array，object 或 resource 轉換成 string 不會獲得除了其類型以外的任何有用信息。可使用函數 print_r() 和 var_dump() 列出這些類型的內容。

大部分的 PHP 值能夠轉變成 string 來永久保存，這被稱做串行化，能夠用函數 serialize() 來實現。若是 PHP 引擎設定支持 WDDX，PHP 值也可被串行化爲格式良好的 XML 文本。

字符串轉換爲數值

當一個字符串被看成一個數值來取值，其結果和類型以下：

若是該字符串沒有包含 '.'，'e' 或 'E' 而且其數字值在整型的範圍以內（由 PHP_INT_MAX 所定義），該字符串將被當成 integer 來取值。其它全部狀況下都被做爲 float 來取值。

該字符串的開始部分決定了它的值。若是該字符串以合法的數值開始，則使用該數值。不然其值爲 0（零）。合法數值由可選的正負號，後面跟着一個或多個數字（可能有小數點），再跟着可選的指數部分。指數部分由 'e' 或 'E' 後面跟着一個或多個數字構成。

<?php
$foo = 1 + "10.5";                // $foo is float (11.5)
$foo = 1 + "-1.3e3";              // $foo is float (-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 = 4 + "10.2 Little Piggies"; // $foo is float (14.2)
$foo = "10.0 pigs " + 1;          // $foo is float (11)
$foo = "10.0 pigs " + 1.0;        // $foo is float (11)     
?>

兩種複合類型

array（數組）

PHP 中的數組其實是一個有序映射。映射是一種把 values 關聯到 keys 的類型。此類型在不少方面作了優化，所以能夠把它當成真正的數組，或列表（向量），散列表（是映射的一種實現），字典，集合，棧，隊列以及更多可能性。因爲數組元素的值也能夠是另外一個數組，樹形結構和多維數組也是容許的。

語法

定義數組 array()
能夠用 array() 語言結構來新建一個數組。它接受任意數量用逗號分隔的鍵（key） => 值（value）對

array(  key =>  value
     , ...
     )
// 鍵（key）但是是一個整數 integer 或字符串 string
// 值（value）能夠是任意類型的值

最後一個數組單元以後的逗號能夠省略。一般用於單行數組定義中，例如經常使用 array(1, 2) 而不是 array(1, 2, )。對多行數組定義一般保留最後一個逗號，這樣要添加一個新單元時更方便。

自 5.4 起可使用短數組定義語法，用 [] 替代 array()。

Example #1 一個簡單數組

<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
);

// 自 PHP 5.4 起
$array = [
    "foo" => "bar",
    "bar" => "foo",
];
?>

key 能夠是 integer 或者 string。value 能夠是任意類型。

此外 key 會有以下的強制轉換：

包含有合法整型值的字符串會被轉換爲整型。例如鍵名 "8" 實際會被儲存爲 8。可是 "08" 則不會強制轉換，由於其不是一個合法的十進制數值。
浮點數也會被轉換爲整型，意味着其小數部分會被捨去。例如鍵名 8.7 實際會被儲存爲 8。
布爾值也會被轉換成整型。即鍵名 true 實際會被儲存爲 1 而鍵名 false 會被儲存爲 0。
Null 會被轉換爲空字符串，即鍵名 null 實際會被儲存爲 ""。
數組和對象不能被用爲鍵名。堅持這麼作會致使警告：Illegal offset type。

若是在數組定義中多個單元都使用了同一個鍵名，則只使用了最後一個，以前的都被覆蓋了。

Example #2 類型強制與覆蓋示例

<?php
$array = array(
    1    => "a",
    "1"  => "b",
    1.5  => "c",
    true => "d",
);
var_dump($array);
?>

以上例程會輸出：

array(1) {
  [1]=>
  string(1) "d"
}

上例中全部的鍵名都被強制轉換爲 1，則每個新單元都會覆蓋前一個的值，最後剩下的只有一個 "d"。

PHP 數組能夠同時含有 integer 和 string 類型的鍵名，由於 PHP 實際並不區分索引數組和關聯數組。

若是對給出的值沒有指定鍵名，則取當前最大的整數索引值，而新的鍵名將是該值加一。若是指定的鍵名已經有了值，則該值會被覆蓋。

Example #3 混合 integer 和 string 鍵名

<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
    100   => -100,
    -100  => 100,
);
var_dump($array);
?>

以上例程會輸出：

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

key 爲可選項。若是未指定，PHP 將自動使用以前用過的最大 integer 鍵名加上 1 做爲新的鍵名。

Example #4 沒有鍵名的索引數組

<?php
$array = array("foo", "bar", "hallo", "world");
var_dump($array);
?>

以上例程會輸出：

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hallo"
  [3]=>
  string(5) "world"
}

還能夠只對某些單元指定鍵名而對其它的空置：

Example #5 僅對部分單元指定鍵名

<?php
$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);
var_dump($array);
?>

以上例程會輸出：

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

能夠看到最後一個值 "d" 被自動賦予了鍵名 7。這是因爲以前最大的整數鍵名是 6。

用方括號語法訪問數組單元

數組單元能夠經過 array[key] 語法來訪問。

Example #6 訪問數組單元

<?php
$array = array(
    "foo" => "bar",
    42    => 24,
    "multi" => array(
         "dimensional" => array(
             "array" => "foo"
         )
    )
);

var_dump($array["foo"]);
var_dump($array[42]);
var_dump($array["multi"]["dimensional"]["array"]);
?>

以上例程會輸出：

string(3) "bar"
int(24)
string(3) "foo"

方括號和花括號能夠互換使用來訪問數組單元（例如 $array[42] 和 $array{42} 在上例中效果相同）。

自 PHP 5.4 起能夠用數組間接引用函數或方法調用的結果。以前只能經過一個臨時變量。

自 PHP 5.5 起能夠用數組間接引用一個數組原型。

Example #7 數組間接引用

<?php
function getArray() {
    return array(1, 2, 3);
}

// on PHP 5.4
$secondElement = getArray()[1];

// previously
$tmp = getArray();
$secondElement = $tmp[1];

// or
list(, $secondElement) = getArray();
?>

試圖訪問一個未定義的數組鍵名與訪問任何未定義變量同樣：會致使 E_NOTICE 級別錯誤信息，其結果爲 NULL。

用方括號的語法新建／修改

能夠經過明示地設定其中的值來修改一個已有數組。

這是經過在方括號內指定鍵名來給數組賦值實現的。也能夠省略鍵名，在這種狀況下給變量名加上一對空的方括號（[]）。

$arr[key] = value;
$arr[] = value;
// key 能夠是 integer 或 string
// value 能夠是任意類型的值

若是 $arr 還不存在，將會新建一個，這也是另外一種新建數組的方法。不過並不鼓勵這樣作，由於若是 $arr 已經包含有值（例如來自請求變量的 string）則此值會保留而 [] 實際上表明着字符串訪問運算符。初始化變量的最好方式是直接給其賦值。。

要修改某個值，經過其鍵名給該單元賦一個新值。要刪除某鍵值對，對其調用 unset() 函數。

<?php
$arr = array(5 => 1, 12 => 2);

$arr[] = 56;    // This is the same as $arr[13] = 56;
                // at this point of the script

$arr["x"] = 42; // This adds a new element to
                // the array with key "x"
                
unset($arr[5]); // This removes the element from the array

unset($arr);    // This deletes the whole array
?>

如上所述，若是給出方括號但沒有指定鍵名，則取當前最大整數索引值，新的鍵名將是該值加上 1（可是最小爲 0）。若是當前尚未整數索引，則鍵名將爲 0。
注意這裏所使用的最大整數鍵名不必定當前就在數組中。它只要在上次數組從新生成索引後曾經存在過就好了。如下面的例子來講明

下面的例子來講明：

<?php
// 建立一個簡單的數組
$array = array(1, 2, 3, 4, 5);
print_r($array);

// 如今刪除其中的全部元素，但保持數組自己不變:
foreach ($array as $i => $value) {
    unset($array[$i]);
}
print_r($array);

// 添加一個單元（注意新的鍵名是 5，而不是你可能覺得的 0）
$array[] = 6;
print_r($array);

// 從新索引：
$array = array_values($array);
$array[] = 7;
print_r($array);
?>

以上例程會輸出：

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

實用函數

有不少操做數組的函數，參見數組函數一節

unset() 函數容許刪除數組中的某個鍵。但要注意數組將不會重建索引。若是須要刪除後重建索引，能夠用 array_values() 函數。

<?php
$a = array(1 => 'one', 2 => 'two', 3 => 'three');
unset($a[2]);
/* will produce an array that would have been defined as
   $a = array(1 => 'one', 3 => 'three');
   and NOT
   $a = array(1 => 'one', 2 =>'three');
*/

$b = array_values($a);
// Now $b is array(0 => 'one', 1 =>'three')
?>

foreach 控制結構是專門用於數組的。它提供了一個簡單的方法來遍歷數組。

和在語法一節中規定的同樣，在方括號（「[」和「]」）之間必須有一個表達式。這意味着能夠這樣寫：

<?php
echo $arr[somefunc($bar)];
?>

轉換爲數組

對於任意 integer，float，string，boolean 和 resource 類型，若是將一個值轉換爲數組，將獲得一個僅有一個元素的數組，其下標爲 0，該元素即爲此標量的值。換句話說，(array)$scalarValue 與 array($scalarValue) 徹底同樣。

若是一個 object 類型轉換爲 array，則結果爲一個數組，其單元爲該對象的屬性。鍵名將爲成員變量名，不過有幾點例外：整數屬性不可訪問；私有變量前會加上類名做前綴；保護變量前會加上一個 '*' 作前綴。這些前綴的先後都各有一個 NULL 字符。這會致使一些不可預知的行爲：

能夠用 array_diff() 和數組運算符來比較數組。

直接改變數組的值自 PHP 5 起能夠經過引用傳遞來作到。以前的版本須要須要採起變通的方法：

Example #10 在循環中改變單元

<?php
// PHP 5
foreach ($colors as &$color) {
    $color = strtoupper($color);
}
unset($color); /* ensure that following writes to
$color will not modify the last array element */

// Workaround for older versions
foreach ($colors as $key => $color) {
    $colors[$key] = strtoupper($color);
}

print_r($colors);
?>

以上例程會輸出：

Array
(
    [0] => RED
    [1] => BLUE
    [2] => GREEN
    [3] => YELLOW
)

數組(Array) 的賦值老是會涉及到值的拷貝。使用引用運算符經過引用來拷貝數組。

<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 is changed,
             // $arr1 is still array(2, 3)
             
$arr3 = &$arr1;
$arr3[] = 4; // now $arr1 and $arr3 are the same
?>

object（對象）

對象初始化
要建立一個新的對象 object，使用 new 語句實例化一個類：

<?php
class foo
{
    function do_foo()
    {
        echo "Doing foo."; 
    }
}

$bar = new foo;
$bar->do_foo();
?>

詳細討論參見手冊中類與對象章節。

轉換爲對象

若是將一個對象轉換成對象，它將不會有任何變化。若是其它任何類型的值被轉換成對象，將會建立一個內置類 stdClass 的實例。若是該值爲 NULL，則新的實例爲空。數組轉換成對象將使鍵名成爲屬性名並具備相對應的值。對於任何其它的值，名爲 scalar 的成員變量將包含該值。

<?php
$obj = (object) 'ciao';
echo $obj->scalar;  // outputs 'ciao'
?>

兩種特殊類型：

resource（資源）

資源 resource 是一種特殊變量，保存了到外部資源的一個引用。資源是經過專門的函數來創建和使用的。全部這些函數及其相應資源類型見附錄。
參見 get_resource_type()。

轉換爲資源
因爲資源類型變量保存有爲打開文件、數據庫鏈接、圖形畫布區域等的特殊句柄，所以將其它類型的值轉換爲資源沒有意義。

釋放資源
因爲 PHP 4 Zend 引擎引進了引用計數系統，能夠自動檢測到一個資源再也不被引用了（和 Java 同樣）。這種狀況下此資源使用的全部外部資源都會被垃圾回收系統釋放。所以，不多須要手工釋放內存。

因爲 PHP 4 Zend 引擎引進了引用計數系統，能夠自動檢測到一個資源再也不被引用了（和 Java 同樣）。這種狀況下此資源使用的全部外部資源都會被垃圾回收系統釋放。所以，不多須要手工釋放內存。
持久數據庫鏈接比較特殊，它們不會被垃圾回收系統銷燬。參見數據庫永久鏈接一章。

NULL

特殊的 NULL 值表示一個變量沒有值。NULL 類型惟一可能的值就是 NULL。

在下列狀況下一個變量被認爲是 NULL：

被賦值爲 NULL。
還沒有被賦值。
被 unset()。

使用 (unset) $var 將一個變量轉換爲 null 將不會刪除該變量或 unset 其值。僅是返回 NULL 值而已。

(已完結)

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。