If you're like me you've needed to use index paths (an array as the index for a multi-dimensional array) and dearly hoped that PHP had native support for it; probably even tried something like:
<?php
$TEST = array(
array( 'A', 'B', 'C' ),
array( 'X', 'Y', 'Z' ),
array( '1', '2', '3' ),
);
$INDEX = array( 1, 1 );
echo $TEST[$INDEX];
?>
only to receive the Warning: "Illegal offset type...".
I spent the last 3 hours solving that problem, here is my 11 function solution: (these functions have been tested/verified in PHP 5.3, but not yet in PHP 4)
<?php
//// mda = Multi-Dimensional Array
function mcds_mda_get( $ARRAY, $PATH ) {
$SUB = &$ARRAY;
foreach( (array)$PATH as $el ) {
$SUB = &$SUB[$el];
}
return $SUB;
}
function mcds_mda_set( $ARRAY, $PATH, $value ) {
$SUB = &$ARRAY;
foreach( (array)$PATH as $el ) {
$SUB = &$SUB[$el];
}
$SUB = $value;
return $ARRAY;
}
function mcds_mda_add( $ARRAY, $PATH, $value ) {
$SUB = &$ARRAY;
foreach( (array)$PATH as $el ) {
$SUB = &$SUB[$el];
}
$SUB = array_merge( (array)$SUB, (array)$value );
return $ARRAY;
}
function mcds_mda_delete( $ARRAY, $PATH ) {
$SUB = &$ARRAY;
$i = 0;
foreach( (array)$PATH as $el ) {
$i++;
if( $i == count($PATH) ) {
unset($SUB[$el]);
} else {
$SUB = &$SUB[$el];
}
}
return $ARRAY;
}
//// mdi = Multi-Dimensional Index (for use with mda)
function mcds_mdi_first( $ARRAY, $PATH ) {
$SUB = &$ARRAY;
$i = 0;
foreach( (array)$PATH as $el ) {
$i++;
if( $i == count($PATH) ) {
$KEYS = array_keys( $SUB );
$PATH[$i-1] = $KEYS[0];
} else {
$SUB = &$SUB[$el];
}
}
return $PATH;
}
function mcds_mdi_prev( $ARRAY, $PATH ) {
$SUB = &$ARRAY;
$i = 0;
foreach( (array)$PATH as $el ) {
$i++;
if( $i == count($PATH) ) {
$KEYS = array_keys( $SUB );
$pos = max( array_search( $el, $KEYS ) -1, 0 );
$PATH[$i-1] = $KEYS[$pos];
} else {
$SUB = &$SUB[$el];
}
}
return $PATH;
}
function mcds_mdi_next( $ARRAY, $PATH ) {
$SUB = &$ARRAY;
$i = 0;
foreach( (array)$PATH as $el ) {
$i++;
if( $i == count($PATH) ) {
$KEYS = array_keys( $SUB );
$pos = min( array_search( $el, $KEYS ) +1, count($KEYS)-1 );
$PATH[$i-1] = $KEYS[$pos];
} else {
$SUB = &$SUB[$el];
}
}
return $PATH;
}
function mcds_mdi_last( $ARRAY, $PATH ) {
$SUB = &$ARRAY;
$i = 0;
foreach( (array)$PATH as $el ) {
$i++;
if( $i == count($PATH) ) {
$KEYS = array_keys( $SUB );
$PATH[$i-1] = $KEYS[count($KEYS)-1];
} else {
$SUB = &$SUB[$el];
}
}
return $PATH;
}
function mcds_mdi_parent( $ARRAY, $PATH ) {
unset($PATH[count($PATH)-1]);
return $PATH;
}
function mcds_mdi_firstChild( $ARRAY, $PATH ) {
$SUB = &$ARRAY;
$i = 0;
foreach( (array)$PATH as $el ) {
$i++;
if( $i == count($PATH) ) {
$SUB = &$SUB[$el];
$KEYS = array_keys( $SUB );
$PATH[$i] = $KEYS[0];
} else {
$SUB = &$SUB[$el];
}
}
return $PATH;
}
function mcds_mdi_lastChild( $ARRAY, $PATH ) {
$SUB = &$ARRAY;
$i = 0;
foreach( (array)$PATH as $el ) {
$i++;
if( $i == count($PATH) ) {
$SUB = &$SUB[$el];
$KEYS = array_keys( $SUB );
$PATH[$i] = $KEYS[count($KEYS)-1];
} else {
$SUB = &$SUB[$el];
}
}
return $PATH;
}
$TEST = array(
array( 'A', 'B', 'C' ),
array( 'X', 'Y', 'Z' ),
array( '1', '2', '3' ),
);
$INDEX = array( 1, 1 );
$TEST = mcds_mda_set($TEST, $INDEX, "!Y" );
$TEST = mcds_mda_add($TEST, $INDEX, "Y2" );
$TEST = mcds_mda_add($TEST, $INDEX, array("Y3", "Y4") );
$TEST = mcds_mda_delete($TEST, array( 1, 0 ));
// $TEST = mcds_mda_get($TEST, $INDEX);
$TEST = mcds_mda_get($TEST, mcds_mdi_parent($TEST, $INDEX) );
echo "<pre>".print_r( $TEST, true )."</pre>";
?>
配列
PHP の配列は、実際には順番付けられたマップです。マップは型の一種で、 値をキーに関連付けます。 この型は、いくつかの手法で最適化されます。このため、 実際の配列またはリスト (ベクトル)、(あるマップの実装である) ハッシュテーブル、ディレクトリ、コレクション、スタック、 キュー等として使用することが可能です。 PHP の配列には他の PHP 配列を値として保持することができるため、 非常に簡単にツリー構造を表現することが可能です。
これらのデータ構造に関する説明は本マニュアルの範囲外ですが、 これらの構造に各々に関する例を少なくとも一つ見付けることが可能です。 この分野は広範囲にまたがるので、 より詳細な情報については他の書籍を参照ください。
構文
array() で指定
配列 は、言語に組み込まれた array() で作成することが可能です。この構造は、 特定の数のカンマで区切られた キー => 値 の組を引数とします。
array(
key => value,
key2 => value2,
key3 => value3,
...
)
最後の要素のあとのカンマは、書いても書かなくてもかまいません。 配列を一行で定義する場合は、ふつうは最後のカンマを省略します。つまり、 array(1, 2) のほうが array(1, 2, ) よりおすすめだということです。 しかし複数行で定義する場合は、最後のカンマをつけることが一般的です。 そうしておけば、配列の最後に要素を追加するのが容易になるからです。
PHP 5.4 以降では配列の短縮構文が追加され、 array() の代わりに [] を使えるようになりました。
例1 シンプルな配列定義
<?php
$array = array(
"foo" => "bar",
"bar" => "foo",
);
// PHP 5.4 ではこのようにも書けます
$array = [
"foo" => "bar",
"bar" => "foo",
];
?>
key は、整数 または 文字列です。 value には任意の型を指定できます。
さらに、次のような key のキャストが発生します。
- integer として妥当な形式の文字列は integer 型にキャストされます。 つまり、キーに "8" を指定すると、実際には 8 として格納されるということです。一方 "08" はキャストされません。これは十進数として妥当な形式ではないからです。
- floats もまた integer にキャストされます。つまり、 小数部分は切り捨てられるということです。たとえばキーに 8.7 を指定すると、実際には 8 として格納されます。
- bool も integer にキャストされます。つまり、 キーに true を指定すると実際には 1 に格納され、 同様にキーを false とすると実際には 0 となります。
- Null は空文字列にキャストされます。つまり、キーに null を指定すると、実際には "" として格納されます。
- array や object は、キーとして使えません。 キーとして使おうとすると Illegal offset type という警告が発生します。
PHP 5.4 以降では、文字列のオフセット指定の挙動が一貫性のあるものになりました。 その結果として、以前のバージョンとは挙動が変わることがあります。 PHP 5.4 以降で文字列のオフセットとして指定できるのは整数あるいは整数とみなせる文字列だけであり、 それ以外の場合は警告が発生します。
例2 文字列のオフセット指定の例
<?php
$str = 'abc';
var_dump($str['1']);
var_dump(isset($str['1']));
var_dump($str['1.0']);
var_dump(isset($str['1.0']));
var_dump($str['x']);
var_dump(isset($str['x']));
var_dump($str['1x']);
var_dump(isset($str['1x']));
?>
上の例の PHP 5.3 での出力は、このようになります。
string(1) "b" bool(true) string(1) "b" bool(true) string(1) "a" bool(true) string(1) "b" bool(true)
上の例の PHP 5.4 での出力は、このようになります。
string(1) "b" bool(true) Warning: Illegal string offset '1.0' in /tmp/t.php on line 7 string(1) "b" bool(false) Warning: Illegal string offset 'x' in /tmp/t.php on line 9 string(1) "a" bool(false) string(1) "b" bool(false)
配列の宣言時に同じキーで複数の要素を指定すると、 最後に指定したものがそれまでの値を上書きします。
例3 型のキャストと値の上書きの例
<?php
$array = array(
1 => "a",
"1" => "b",
1.5 => "c",
true => "d",
);
var_dump($array);
?>
上の例の出力は以下となります。
array(1) {
[1]=>
string(1) "d"
}
上の例では、すべてのキーが 1 にキャストされます。 そして後から指定した値がどんどん前の値を上安芸市定期、最終的には最後に代入された "d" だけが残ります。
PHP においては添字配列と連想配列の間に違いはなく、配列型は 1 つだけで、 同じ配列で整数のインデックスと文字列のインデックスを同時に使えます。
例4 整数と文字列のキーの混在例
<?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 はこれまでに使われた整数のキーの中で最大のものに 1 を加えた値を使います。
例5 数値添字配列でキーを省略する例
<?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"
}
一部の要素にだけキーを指定することもできます。
例6 一部の要素にだけキーを指定する例
<?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] 構文を使います。
例7 配列の要素へのアクセス
<?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"
PHP 5.4 以降では、関数やメソッドの返す結果を直接配列として扱えるようになりました。 以前は、いったん一次変数に代入しないと配列としては扱えませんでした。
例8 配列のデリファレンス
<?php
function getArray() {
return array(1, 2, 3);
}
// PHP 5.4 ではこのように書けます。
$secondElement = getArray()[1];
// 以前は、このようにするか
$tmp = getArray();
$secondElement = $tmp[1];
// あるいはこのようにしなければなりませんでした。
list(, $secondElement) = getArray();
?>
注意:
配列に定義されていないキーへアクセスしたときの挙動は、 未定義の変数にアクセスしたときと同じです。
E_NOTICEメッセージが発行され、 返される結果はNULLとなります。
角括弧構文で作成/修正
明示的に値を設定することにより、既存の配列を修正することも可能です。
これは、角括弧の中にキーを指定し、配列に値を代入することにより行います。 キーを省略することも可能です。この場合、空の角括弧 ("[]") の変数名として追加してください。
$arr[キー] = 値; $arr[] = value; // キー は 文字列 または // 非負の整数のどちらかです。 // 値 は何でもかまいません
$arr がまだ存在しない場合は、新しく作成します。 つまり、これは配列を作成する方法のひとつでもあります。 とはいえ、この方法を使うことはおすすめしません。なぜなら、既に $arr に何らかの値 (リクエスト変数からの文字列など) が入っている場合にはその値がそのまま残り、 [] が実際には 文字列アクセス演算子 を表してしまうからです。 変数を初期化するときには、直接代入するほうがよいでしょう。
ある値を変更するには、 新しい値に値を代入します。特定のキー/値の組を削除したい場合には、 unset() を使用する必要があります。
<?php
$arr = array(5 => 1, 12 => 2);
$arr[] = 56; // このスクリプトのこの位置に記述した場合、
// $arr[13] = 56; と同じです
$arr["x"] = 42; // キー"x"の新しい要素を配列に追加します
unset($arr[5]); // 配列から要素を削除します
unset($arr); // 配列全体を削除します
?>
注意:
上記のように、キーを省略して新規要素を追加する場合、 追加される数値添字は、使用されている添字の最大値 +1 (ただし、少なくとも 0 以上) になります。 まだ数値添字が存在しない場合は、添字は 0 (ゼロ) となります。
警告PHP 4.3.0 以降、上記のような添字生成動作は変更されました。 現在では、配列に追加する際に、 その配列の最大添字が負である場合は次の添え字はゼロ (0) となります。 以前は、正の添字の場合と同様に新しい添字は最大添字に +1 したものがセットされました。
次のキー生成において、オフセットとして使われる整数値 (添字の最大値) に対応するエントリーが、 必ずしも配列内に存在するわけではないことに注意してください。 しかし、その値は、多くの場合、 配列にある整数のキー値の最大値と等しいはずです。以下に例を示します。
<?php
// 簡単な配列を生成します。
$array = array(1, 2, 3, 4, 5);
print_r($array);
// 全てのアイテムを削除しますが、配列自体は削除しないでおきます。
foreach ($array as $i => $value) {
unset($array[$i]);
}
print_r($array);
// アイテムを追加します(新しい添え字は0ではなく
// 5となることに注意)
$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()関数は配列のキーを削除することが出来ます。 ただし、これによってインデックスの再構築が行われるわけではないことに 注意してください。 "通常の整数添字" (0 から始まり、1 つずつ増加) のみを使用している場合、 array_values() を用いてインデックスを再構築することができます。
<?php
$a = array(1 => 'one', 2 => 'two', 3 => 'three');
unset($a[2]);
/* これにより配列は以下の様に定義されます。
$a = array(1 => 'one', 3 => 'three');
以下ではありません:
$a = array(1 => 'one', 2 =>'three');
*/
$b = array_values($a);
// $b は、array(0 => 'one', 1 =>'three')となります
?>
配列専用の制御構造として foreach があります。 この構造は、配列の要素に簡単に連続的にアクセスする手段を提供します。
配列ですべきこととしてはならないこと
なぜ、$foo[bar] は使用できないのか?
連想配列の添字の前後は常に引用符で括る必要があります。 例えば、$foo[bar] ではなく $foo['bar'] を使用してください。 しかし、$foo[bar] はなぜ誤りなのでしょうか? 古いスクリプトで次のような構文を見たことがあるかもしれません。
<?php
$foo[bar] = 'enemy';
echo $foo[bar];
// etc
?>
これは間違っていますが、動作します。では、なぜ間違っているのでしょう?
その理由は、このコードには文字列 ('bar' - 引用符で括られている)
ではなく未定義の定数 (bar) が使用されており、PHP
が同じ名前の定数を不幸にして同じコードの中に定義する可能性があるためです。
下位互換性の維持のため、未定義の定数は同じ名前の文字列に自動的に変換されます。
そのため、このコードは動作します。
例えば、bar という名前の定義されていない定数があるとすると、
PHP は 'bar' という文字列でそれを置換して使用します。
注意: これは、添字を常にクォートするという意味ではありません。 定数や 変数 を添字として使う際には、クォートしてしまうと PHP はそれを解釈できなくなってしまいます。
<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);
// 単純な配列
$array = array(1, 2);
$count = count($array);
for ($i = 0; $i < $count; $i++) {
echo "\nChecking $i: \n";
echo "Bad: " . $array['$i'] . "\n";
echo "Good: " . $array[$i] . "\n";
echo "Bad: {$array['$i']}\n";
echo "Good: {$array[$i]}\n";
}
?>上の例の出力は以下となります。
Checking 0: Notice: Undefined index: $i in /path/to/script.html on line 9 Bad: Good: 1 Notice: Undefined index: $i in /path/to/script.html on line 11 Bad: Good: 1 Checking 1: Notice: Undefined index: $i in /path/to/script.html on line 9 Bad: Good: 2 Notice: Undefined index: $i in /path/to/script.html on line 11 Bad: Good: 2
この具体例を以下に示します。
<?php
// エラーを全て表示するよう設定
error_reporting(E_ALL);
$arr = array('fruit' => 'apple', 'veggie' => 'carrot');
// 正しい
print $arr['fruit']; // apple
print $arr['veggie']; // carrot
// 間違い。これは動作しますが、未定義の定数fruitを使用しているため、
// 同時にE_NOTICEレベルのPHPエラーを発生します
//
// Notice: Use of undefined constant fruit - assumed 'fruit' in...
print $arr[fruit]; // apple
// 検証のため、定数を定義してみましょう。
// fruitという名前の定数に値'veggie'を代入します。
define('fruit', 'veggie');
// ここでは、出力が異なることに注意してください。
print $arr['fruit']; // apple
print $arr[fruit]; // carrot
// 以下は文字列の中であるためOKです。定数は、文字列の中では解釈されな
// いため、E_NOTICEエラーはここでは発生しません。
print "Hello $arr[fruit]"; // Hello apple
// 例外が1つあり、文字列の中で波括弧で配列を括った場合には、
// 定数が解釈されます
print "Hello {$arr[fruit]}"; // Hello carrot
print "Hello {$arr['fruit']}"; // Hello apple
// これは動作せず、以下のようなパースエラーを発生します:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// 文字列の中でスーパーグローバルを使用した場合も無論同様です。
print "Hello $arr['fruit']";
print "Hello $_GET['foo']";
// 文字列結合で同じことをすることもできます。
print "Hello " . $arr['fruit']; // Hello apple
?>
error_reporting() で
(E_ALL を指定する等により)
E_NOTICE レベルのエラー出力を有効にした場合、
上記のエラーが出力されます。
デフォルトでは、
error_reporting はこれらを表示しない設定になっています。
構文の節に記述したように、角括弧 ('[' および ']') の間には、式がなければなりません。これは、 次のように書くことが可能であることを意味します。
<?php
echo $arr[somefunc($bar)];
?>
これは、関数の戻り値を配列の添字として使用する例です。PHP は定数についても認識します。以下のような E_* の使用例を見たことがあるかもしれません。
<?php
$error_descriptions[E_ERROR] = "A fatal error has occured";
$error_descriptions[E_WARNING] = "PHP issued a warning";
$error_descriptions[E_NOTICE] = "This is just an informal notice";
?>
最初の例の bar と全く同様に
E_ERROR も有効な添字であることに注意してください。
しかし、実際には最後の例は次のように書くことと同じです。
<?php
$error_descriptions[1] = "A fatal error has occured";
$error_descriptions[2] = "PHP issued a warning";
$error_descriptions[8] = "This is just an informal notice";
?>
これは、E_ERROR が 1
と等しいこと等によります。
では、なぜ $foo[bar] は動作することが可能なのでしょう? それは、bar が定数式であることを 期待される構文で使用されているためです。しかし、この場合、 bar という名前の定数は存在しません。PHP は、 この場合、あなたが文字列"bar" のようにリテラル bar を指定したが引用符を忘れたと仮定します。
では、なぜ間違っているのでしょう?
将来的に、PHP 開発チームが他の定数またはキーワードを追加したいと思うかもしれず、 問題となる可能性があります。例えば、現在でも、 単語 empty および defaultを使用することはできません。 これは、これらが特別な 予約済みのキーワードであるためです。
注意: 二重引用符で括られた文字列の中では 引用符で配列の添字を括らないことができ、このため、 "$foo[bar]" は有効です。 この理由の詳細については、上記の例や 文字列中での変数のパースを参照してください。
配列への変換
integer, float, string, boolean, resourceのいずれの型においても、 array に変換する場合、 最初のスカラー値が割り当てられている一つの要素 (添字は 0) を持つ配列を得ることになります。
objectを配列にする場合には、配列の要素として オブジェクトの属性 (メンバ変数) を持つ配列を得ることになります。 添字はメンバ変数名となりますが、いくつか注意すべき例外があります。 整数のプロパティはアクセス不能になります。 private 変数の場合、変数名の頭にクラス名がつきます。また、 protected 変数の場合は、変数名の頭に '*' がつきます。 このとき、頭に追加される値の前後に null バイトがついてきます。 その結果、予期せぬ振る舞いをすることがあります。
<?php
class A {
private $A; // これは '\0A\0A' となります
}
class B extends A {
private $A; // これは '\0B\0A' となります
public $AA; // これは 'AA' となります
}
var_dump((array) new B());
?>
上の例では 'AA' というキーがふたつあるように見えますが、 そのうちひとつは、実際は '\0A\0A' ということになります。
NULL を配列に変換すると、空の配列を得ます。
比較
array_diff() と 配列演算子 を用いると、配列を比較することができます。
例
PHP の配列型は、いろいろな使い方ができます。配列の強力な機能を示すため、 ここでいくつかの例を紹介します。
<?php
// これは、
$a = array( 'color' => 'red',
'taste' => 'sweet',
'shape' => 'round',
'name' => 'apple',
4 // キーは0になります
);
$b = array('a', 'b', 'c');
// は、完全にこれと同じです。
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name'] = 'apple';
$a[] = 4; // キーは0になります
$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// 上のコードを実行すると、$a は次のような配列
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4) となり、$b は
// array(0 => 'a', 1 => 'b', 2 => 'c') あるいは単に array('a', 'b', 'c') となります
?>
例9 array() の使用例
<?php
// マップを行う配列
$map = array( 'version' => 4,
'OS' => 'Linux',
'lang' => 'english',
'short_tags' => true
);
// 数値キーのみを有する
$array = array( 7,
8,
0,
156,
-10
);
// これは、array( 0 => 7, 1 => 8, ...) と同じです
$switching = array( 10, // key = 0
5 => 6,
3 => 7,
'a' => 4,
11, // key = 6 (最大の添字は5です)
'8' => 2, // key = 8 (整数!)
'02' => 77, // key = '02'
0 => 12 // 値10は12で上書きされます
);
// 空の配列
$empty = array();
?>
例10 コレクション
<?php
$colors = array('red', 'blue', 'green', 'yellow');
foreach ($colors as $color) {
echo "Do you like $color?\n";
}
?>
上の例の出力は以下となります。
Do you like red? Do you like blue? Do you like green? Do you like yellow?
PHP 5 以降では、配列を参照渡しすることでその値を直接変更できるようになりました。 それ以前のバージョンでは、以下のような回避策が必要です。
例11 ループ内での要素の変更
<?php
// PHP 5
foreach ($colors as &$color) {
$color = strtoupper($color);
}
unset($color); /* これ以降の $color への書き込みが
配列の要素を書き換えてしまわないことを保証する */
// 旧バージョンでの回避策
foreach ($colors as $key => $color) {
$colors[$key] = strtoupper($color);
}
print_r($colors);
?>
上の例の出力は以下となります。
Array
(
[0] => RED
[1] => BLUE
[2] => GREEN
[3] => YELLOW
)
この例は、1 から始まる配列を作成します。
例12 1 から始まる添字
<?php
$firstquarter = array(1 => 'January', 'February', 'March');
print_r($firstquarter);
?>
上の例の出力は以下となります。
Array
(
[1] => 'January'
[2] => 'February'
[3] => 'March'
)
例13 配列に代入する
<?php
// ディレクトリから全てのアイテムを配列に代入する
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
$files[] = $file;
}
closedir($handle);
?>
配列には順番が付けられます。異なったソート関数を用いて順番を変更することも可能です。 より詳細な情報については、配列関数 を参照ください。 count() 関数を使用することで、 配列の要素数を数えることが可能です。
例14 配列のソート
<?php
sort($files);
print_r($files);
?>
配列の値は何でも良いため、その値を他の配列とすることも可能です。 これにより、再帰的な配列や多次元の配列を作成することが可能です。
例15 再帰および多次元配列
<?php
$fruits = array ( "fruits" => array ( "a" => "orange",
"b" => "banana",
"c" => "apple"
),
"numbers" => array ( 1,
2,
3,
4,
5,
6
),
"holes" => array ( "first",
5 => "second",
"third"
)
);
// 上の配列の内容を取得するための例
echo $fruits["holes"][5]; // "second" を表示します
echo $fruits["fruits"]["a"]; // "orange" を表示します
unset($fruits["holes"][0]); // "first" を削除します
// 新しい多次元配列を作成します
$juices["apple"]["green"] = "good";
?>
配列への代入においては、常に値がコピーされることに注意してください。 配列をリファレンスでコピーする場合には、 リファレンス演算子を使う必要があります。
<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 が変更されます。
// $arr1 は array(2,3) のままです。
$arr3 = &$arr1;
$arr3[] = 4; // $arr1 と $arr3 は同じ内容になります。
?>
Please note that adding the magic __toString() method to your objects will not allow you to seek an array with it, it still throws an Illegal Offset warning.
The solution is to cast it to a string first, like this
$array[(string) $stringableObject]
On 5.4 I would also assume that the shortened array syntax would be usable to define an array:
<?php
$myArray = []; // instead of array();
?>
Nothing major but it could be of convenience.
Here's an easier way to access associative array values by their numeric index:
<?php
//sample associative array:
$myAssocArray = array('a'=>'apple', 'b'=>'banana', 'c'=>'carrot', 'd'=>'dragon fruit');
$numKeys = array_values($myAssocArray);
echo $numKeys[0]; // => apple
echo $numKeys[1]; // => banana
echo $numKeys[2]; // => carrot
echo $numKeys[3]; // => dragon fruit
?>
This is a simple solution for taking previous and next items, even if we are at the ends of the array.
<?php
$current_key; // the key of the item we want to search from
if (isset($array[$current_key+1])) {
$array_next = $array[$current_key+1]; // get the next item if there is
} else {
$array_next = $array[0]; // if not take the first (this means this is the end of the array)
}
if (isset($array[$current_key-1])) {
$array_prev = $array[$current_key-1]; // get the previous item if there is
} else {
$array_prev = $array[count($array)-1]; // if not take the last item (this means this is the beginning of the array)
}
?>
Hi, you also can try goAssocArrayNumeric() on two-dimensional or three-dimensional arrays.
<?php
//Now it's a two-dimensional array
$myTwoDimArray = array('a'=>array('a0'=>'apple','a1'=>'avocado','a2'=>'apricot'), 'b'=>array('b0'=>'banana','b1'=>'blackberry','b2'=>'breadfruit'), 'c'=>array('c0'=>'carrot','c1'=>'coco','c2'=>'coffee'));
echo $myTwoDimArray[0][0]; //won't work! But,
//using the same function used to access associative arrays numerically, we may access 2-dimensional arrays numerically.
function goAssocArrayNumeric($arrAssoc, $key=-1)
{
$i = -1;
foreach ($arrAssoc as $k => $v)
{
$i++;
if($i == $key)
{
return $v;
}
}
return FALSE;
}
//usage: applying it twice.
echo goAssocArrayNumeric(goAssocArrayNumeric($myTwoDimArray,0),0);//apple
echo goAssocArrayNumeric(goAssocArrayNumeric($myTwoDimArray,2),1);//coco
echo goAssocArrayNumeric(goAssocArrayNumeric($myTwoDimArray,2),2);//coffee
?>
Thanks!
Prince.
Hi, here's a way to access an associative array via it's numeric index.
<?php
//sample associative array:
$myAssocArray = array('a'=>'apple', 'b'=>'banana', 'c'=>'carrot', 'd'=>'dragon fruit');
echo $assocArray[0];
//Above won't work! Because you can't access an associative array numerically. But,
function goAssocArrayNumeric($arrAssoc, $key=-1)
{
$i = -1;
foreach ($arrAssoc as $k => $v)
{
$i++;
if ($i == $key)
{
return $v;
}
}
return FALSE;
}
//usage:
echo goAssocArrayNumeric($myAssocArray,0);//apple
echo goAssocArrayNumeric($myAssocArray,3);//dragon fruit
?>
Hope it helps!
Thanks.
Beware: you can't access an associative array via it's numeric index:
<?php
$a = array(
'foo' => 'bar',
'sasfas' => 'addasda',
'safafsa' => 'hfdhfdf'
);
echo $a[0]; // Undefined index, not 'bar'
?>
please note that when arrays are copied, the "reference status" of their members is preserved (http://www.php.net/manual/en/language.references.whatdo.php).
This is another way to get value from a multidimensional array, but for versions of php >= 5.3.x
<?php
function array_value_recursive($key, array $arr){
$val = null;
array_walk_recursive($arr, function($v, $k) use($key, &$val){
$val = $k == $key ? $v : (!is_null($val) ? $val : false);
});
return $val;
}
$arr = array(
'foo' => 'foo',
'bar' => array(
'baz' => 'baz',
'candy' => 'candy',
'vegetable' => array(
'carrot' => 'carrot',
)
),
'fruits' => 'fruits',
);
var_dump(array_value_recursive('carrot', $arr)); // string(6) "carrot"
var_dump(array_value_recursive('apple', $arr)); // bool(false)
var_dump(array_value_recursive('baz', $arr)); // string(3) "baz"
var_dump(array_value_recursive('candy', $arr)); // string(5) "candy"
var_dump(array_value_recursive('pear', $arr)); // bool(false)
?>
Possibly unexpected behaviour:
<?php
$array = array();
var_dump($array['key']); // E_NOTICE (undefined key)
$null = null;
var_dump($null['key']); // no E_NOTICE
?>
I was in need to get value of key which resides at any level in an multidimensional array. Unfortunately there is no such array function. So I write my own as below...
<?php
function array_get_key_val($key, $heystack) {
if (is_array($heystack)) {
foreach ($heystack as $k => $v) {
if ($k == $key) {
return $v;
}
elseif (is_array($v)) {
return array_get_key_val($key, $v);
}
}
}
return FALSE;
}
?>
Hope this will help to few.
I'm want to save values in array and display its, can to simple way:
<?php
$arr1 = array();//begin array
$index = 0;//array's index
$value_return = array();//Values me need
for($i = 0; $i<10; $i++)
{
$arr1[$i] = rand(10, 100);//use to be function random for get values from 10 to 100.
if($arr1[$i]%2 == 0)//Get values me need.
{
$value_return[$index] = $arr1[$i];//save values in this array
$index += 1;//get space save for index.
}
}
//display result.
foreach($value_return as $value_display)
echo "</br>".$value_display."</br>";
print_r($arr1);
?>
Sometimes you may need an array of constants including concatenated strings.
That works fine in this case:
<?php
define("GLUE", "&");
function array_to_string($a) {
$r = "";
foreach ($a as $key => $value) { $r .= "$key => $value<br>"; };
return $r;
}
// DECLARING ARRAY (1)
$array = array("one", "two", "one".GLUE."two");
echo array_to_string($array);
?>
This seems rather strange behavior in a CLASS nevertheless:
<?php
class wrong_class {
// DECLARING ARRAY (2)
private $array = array("one", "two", "one".GLUE."two");
function __toString() {
return array_to_string($this->array);
}
}
$wc = new wrong_class();
echo $wc;
/*
Parse error: parse error, expecting `')'' in ... code on line 21
*/
?>
Anyway, if you force this declaring method inside a CLASS, you could change the object map directly:
<?php
class proper_class {
function __construct() {
// DECLARING ARRAY (3)
$this->array = array("one", "two", "one".GLUE."two");
}
function __toString() {
return array_to_string($this->array);
}
}
$pc = new proper_class();
echo $pc;
?>
Multidimensional arrays work great for checking search options if they exist in a $_GET string. The following saved me a lot of time.
<?php
$advanced_option['color'] = array("red", "blue", "green");
$advanced_option['state'] = array("new", "broken");
$advanced_option['state'] = array("on","off");
foreach($advanced_option as $y => $advanced_option[$y])
{
// HERE WARE ARE GOING INTO EACH ARRAY'S VALUES/ITEMS
$sub_array = $advanced_option[$y];
foreach($sub_array as $z => $sub_array[$z])
{
// IF THE SEARCH OPTI0N EXISTS IN THE GET STRING, SET AN ARRAY NAMED AFTER THAT VALUE TO BE CHECKED (FOR CHECKBOXES & RADIOBUTTONS)
if ($_GET[$y] == $advanced_option[$y][$z])
{
$checked[$advanced_option[$y][$z]] = "checked";
}
}
}
?>
In case you had to get an element from a function-returned array without having to save the array to a variable, here's a workaround I've come up with.
<?php
$stuff = 'something random here';
// To get the first element in the array, use reset
echo reset(explode(' ', $stuff));
// Returns "something"
// To get the last element, use end
echo end(explode(' ', $stuff));
// Returns "here"
// For an in-between element, you can use array_search on the flipped array
$i = 1; //key for the element
echo array_search($i, array_flip(explode(' ', $stuff)));
// Returns "random"
?>
Heres a simple function I wrote to remove a value from an array, without leaving a hole:
<?php
function removeFromArray(&$array, $key){
foreach($array as $j=>$i){
if($i == $key){
$array = array_values(unset($array[$j]));
return true;
break;
}
}
?>
Returns true on success, or false on failure. The array will be automatically updated
It is true that "array assignment always involves value copying", but the copy is a "lazy copy". This means that the data of the two variables occupy the same memory as long as no array element changes.
E.g., if you have to pass an array to a function that only needs to read it, there is no advantage at all in passing it by reference.
Like in Perl, you can use curly braces ({}) instead of square brackets ([]) to access array members:
<?php
$a = array ();
$a[7] = 'seven';
$a{'hello'} = 'world';
print $a{7} . ' ' . $a['hello'];
?>
Prints 'seven world'.
I couldn't find a way to Trim an array in PHP so i wrote this little function that seemed to do the trick. It will trim the array down to a specified size
<?php
//Utility Function to Trim Array
function trim_array(array $array,$int){
$newArray = array();
for($i=0; $i<$int; $i++){
array_push($newArray,$array[$i]);
}
return (array)$newArray;
}
?>
Example:
var_dump($treatList);
array(3) {
["id"]=>
string(3) "476"
["categoryID"]=>
string(2) "49"
["title"]=>
string(55) "80% off Sidewalk Crawling Classes from Urban Adventures"
$treatList = trim_array($listist,2);
Will result in:
var_dump($treatList);
array(2) {
["id"]=>
string(3) "476"
["categoryID"]=>
string(2) "49"
function array_closest_key($needle,$haystack){
foreach($haystack as $key => $value){
if($needle <= $value){
return $key;
}
}
}
Get the closest key to the specified $needle out of $haystack.
<?php
/**
* Functions for examining and manipulating matrices (n-dimensional arrays) of data
* with string dot-separated paths. For example, you might do this with multidimensional
* array:
* $var = $array['someKey']['cats']['dogs']['potato'];
*
* Accomplishing this can be a nightmare if you don't know the depth of the path or the array
* is of a variable dimension.
*
* You can accomplish the same by using $array as a Matrix:
* $array = new Matrix($array);
* $var = $array->get('someKey.cats.dogs.potato);
*
* @author Daniel Tomasiewicz <www.fourstaples.com>
*/
class Matrix {
private $data;
public function __construct(array $data = array()) {
$this->data = $data;
}
/**
* Gets the value at the specified path.
*/
public function get($path = null) {
if($path === null) {
return $this->data;
}
$segs = explode('.', $path);
$target =& $this->data;
for($i = 0; $i < count($segs)-1; $i++) {
if(isset($target[$segs[$i]]) && is_array($target[$segs[$i]])) {
$target =& $target[$segs[$i]];
} else {
return null;
}
}
if(isset($target[$segs[count($segs)-1]])) {
return $target[$segs[count($segs)-1]];
} else {
return null;
}
}
/**
* Sets a value to a specified path. If the provided value is
* null, the existing value at the path will be unset.
*/
public function set($path, $value = null) {
if(is_array($path)) {
foreach($path as $p => $v) {
$this->set($p, $v);
}
} else {
$segs = explode('.', $path);
$target =& $this->data;
for($i = 0; $i < count($segs)-1; $i++) {
if(!isset($target[$segs[$i]])) {
$target[$segs[$i]] = array();
}
$target =& $target[$segs[$i]];
}
if($segs[count($segs)-1] == '*') {
foreach($target as $key => $value) {
$target[$key];
}
} elseif($value === null && isset($target[$segs[count($segs)-1]])) {
unset($target[$segs[count($segs)-1]]);
} else {
$target[$segs[count($segs)-1]] = $value;
}
}
}
/**
* Returns a flattened version of the data (one-dimensional array
* with dot-separated paths as its keys).
*/
public function flatten($path = null) {
$data = $this->get($path);
if($path === null) {
$path = '';
} else {
$path .= '.';
}
$flat = array();
foreach($data as $key => $value) {
if(is_array($value)) {
$flat += $this->flatten($path.$key);
} else {
$flat[$path.$key] = $value;
}
}
return $flat;
}
/**
* Expands a flattened array to an n-dimensional matrix.
*/
public static function expand($flat) {
$matrix = new Matrix();
foreach($flat as $key => $value) {
$matrix->set($key, $value);
}
return $matrix;
}
}
?>
If you ever wondered if you can do something like:
<?php
$a = function_that_returns_an_array()['some_index']['some_other_index'] ;
?>
The answer is no, you can't. But you can use the following function. I named it i() because it's a short name and stands for "to index".
<?php
/**
* Usage: i( $array, $index [, $index2, $index3 ...] )
*
* This is functionally equivalent to $array[$index1][$index2][$index3]...
*
* It can replace the more prolix
*
* $tmp = some_function_that_returns_an_array() ;
* $value = $tmp['some_index']['some_other_index'] ;
*
* by doing the job with a single line of code as in
*
* $value = i( some_function_that_returns_an_array(), 'some_index', 'some_other_index' ) ;
*
* Note that since this function is slower than direct indexing, it should only be used in cases like the one
* described above, for improving legibility.
*
* @param $array
* @param $index
* @param [optional] $index2, index3, ...
* @throws Exception when the indexes do not exist
*/
function i(){
$args = func_get_args();
$array = $args[0];//gets the fist parameter, $array
$indexes = $args;
unset($indexes[0]);//because indexes[0] is actually not an index, but the first parameter, $array
foreach( $indexes as $index ){
if( (! is_array($array)) || (! array_key_exists( $index, $array )) ){
throw new Exception("Array index out of bounds. Parameters:".print_r($args,true));
}
$array = $array[$index];
}
return $array;
}
?>
Here's a function to recursively convert objects to arrays and remove the special characters from private and protected variables. I use it with XML_Serializer to convert objects to XML.
<?php
function object_to_array($mixed) {
if(is_object($mixed)) $mixed = (array) $mixed;
if(is_array($mixed)) {
$new = array();
foreach($mixed as $key => $val) {
$key = preg_replace("/^\\0(.*)\\0/","",$key);
$new[$key] = object_to_array($val);
}
}
else $new = $mixed;
return $new;
}
?>
Just in case someone finds it usefull.
If you want to capitalize the first letter of each word in the array you could:
<?php
$myarray = array("one","two","three","four","etc..");
$map = array_map('ucfirst', $myarray);
$j = join(' , ', $map);
echo $j;
?>
This will return: One , Two , Three , Four , Etc..
Probably it's not worth of posting it, but just thought beginners might find it usefull.
This is a modification of a function like this which works with two dimensional arrays. Pass a 2d array to this function and my function will return an array of the arrays with the specified key-value pair (specified by $key and $value).
<?php
function seekKey($array, $key, $value)
{
$ret = array();
for ($i=0;$i<count($array);$i++)
{
if ($array[$i][$key]==$value)
$ret[] = $array[$i];
}
return $ret;
}
?>
You can actually create arrays in arrays; just consider the following code:
<?php
function LoadData($file)
{
$lines = file($file) or die('Could not open file');
foreach($lines as $line)
{
$i[] = array($line);
print_r($i[1])
}
LoadData('file.csv');
?>
A (.csv-)file is loaded into the function LoadData and stored in the array $lines. Then foreach puts the values from the $lines-array into $line and $i is defined as an array of the array $line. Please note that this type of code could take up much of CPU-usage; it generates a multi-dimensional array.
When $i is printed (in the example, value 1 of the array) it would display:
Array ( [0] => Array (
[0] => 7;75;X;0;0;1;0;3;Gr;Br;Do;0;0;0;0;0;0;0;0;
[1] => ;200;K;0;0;0;0;0;Gr;0;0;0;0;ZL;0;0;0;0;0;
[2] => ;260;Z;;;;;;Gr;;;;;VL;;;;;;
[3] => ;270;K;;;;1;;Gr;Br;Li;;;;;;;;;
[4] => ;500;V;;;;;;Br;;;;;;;;;;;
[5] => 6;60;X;;;;;;;;;;;;;;;;;
[6] => ;80;K;;;;;;Gr;;;;;ZL;;;;;;
[7] => ;210;Z;;;;;;Gr;;;;;;;;;;;
)
A simple function to check if you can use your variable as an array offset validly and without getting it typecasted.
<?php
function is_safe_offset($offset) {
return array_pop(@array_flip(array($offset => 0))) === $offset;
}
$a = 8;
var_dump(is_safe_offset($a)); // true
$b = '8';
var_dump(is_safe_offset($b)); // false
$c = '08';
var_dump(is_safe_offset($c)); // true
$d = 'foo';
var_dump(is_safe_offset($d)); // true
$e = 3.8;
var_dump(is_safe_offset($e)); // false
$f = false;
var_dump(is_safe_offset($f)); // false
$g = null;
var_dump(is_safe_offset($g)); // false
$h = array();
var_dump(is_safe_offset($h)); // false
$i = new StdClass;
var_dump(is_safe_offset($i)); // false
?>
Hello,
to check if an element was set is actually pretty simple:
<?php
$array = ('first' => 1,
'sec' => 2
);
$out = (isset($array['third'])) ? $array['third'] : 'third not set...';
echo $out;
?>
greets,
genix
Trying to get array element that was not set, throws ERROR_NOTICE and returns NULL. Example:
<?php /* php v.4.4.7 */
$array = array(
'apple' => 'green',
'orange' => 'orange',
);
$pear_color = $array['pear']; // Notice: Undefined index: pear in /path/to/file.php on line 123
var_dump($pear_color); // NULL
?>
Haven't found that mentioned on this page.
Note that NULL is not exactly a scalar value, so the following two lines of code do NOT produce identical arrays.
<?php
$x = (array) null; // $x ends up an empty array (zero elements)
$y = array(null); // $y ends up an array containing one element (a null)
?>
Re: fmouse,
the phenomenom you're describing pertains to superglobals, not arrays, and it only applies in a very specific scope. Check out http://de.php.net/manual/en/language.variables.variable.php :
"Please note that variable variables cannot be used with PHP's Superglobal arrays within functions or class methods. The variable $this is also a special variable that cannot be referenced dynamically."
>fmouse
Variable variables can be used with arrays as discussed in the variable variable section.
Also, from your code, $somevar can be an array and still work fine.
$fum = "somevar";
$$fum = array(); // $somevar is now an array
$foo = $$fum;
print_r( $foo); // we get an empty array printed
print_r() doesn't just print arrays, it prints any variable type.
If you pass it a variable, that hasn't been defined yet, it won't know how to print it.
You would get this same results by passing any undefined variable such as:
print_r( $bar ); // PHP Notice: undefined variable ...$bar
Using variables as array names no longer works in PHP5.
$fum = "somevar";
$foo = $$fum;
# Still works if $somevar isn't an array. $foo contains the value of $somevar
but ....
$fum = "_POST";
print_r($$fum);
print_r(${$fum});
Neither form of indirection works in this context. $$fum comes back empty.
If you have PHP4 code that used this kind of indirection you can work around the change in PHP5 using an eval().
$fum = "_POST";
$foo = eval("return $$fum;");
print_r($foo);
This works!
Sorting double dimensional arrays by a specified key bothe for Strings and for integers:
Ex:
$personDetails = array( array("firstName" => "Nancy", "lastName" => "Grace", "age" => 22), array("firstName" => "Andy", "lastName" => "Peter", "age" => 28), array("firstName" => "Jim", "lastName" => "Gary", "age" => 25), array("firstName" => "Lary", "lastName" => "James", "age" => 28), array("firstName" => "Peter", "lastName" => "David", "age" => 17), array("firstName" => "Raj", "lastName" => "King", "age" => 9), array("firstName" => "John", "lastName" => "Baxter","age" => 35) );
//To sort the array by firstName:-
function sortFirstName($p1, $p2) {
return strnatcmp($p1['firstName'], $p2['firstName']);
}
usort($personDetails, 'sortFirstName');
//To sort by an integer Field
function sortByInteger(&$personDetails, $field) {
$sort = "return strnatcmp(\$p1['$field'], \$p2['$field']);";
usort($personDetails, create_function('$p1,$p2', $sort));
return $personDetails;
}
$personDetails = sortByInteger($personDetails, 'age');
//To sort the array in Descending order by a key, It can be done by adding "-" sign before strnatcmp() function.
I hope this helps
"If you convert a NULL value to an array, you get an empty array."
This turns out to be a useful property. Say you have a search function that returns an array of values on success or NULL if nothing found.
$values = search(...);
Now you want to merge the array with another array. What do we do if $values is NULL? No problem:
$combined = array_merge((array)$values, $other);
Voila.
z on 22-Apr-2005 12:10 wrote:
-----------------------------------------------
Here's a simple function to insert a value into some position in an array
<?php
function array_insert($array,$pos,$val)
{
$array2 = array_splice($array,$pos);
$array[] = $val;
$array = array_merge($array,$array2);
return $array;
}
?>
and now for example...
<?php
$a = array("John","Paul","Peter");
$a = array_insert($a,1,"Mike");
?>
Now $a will be "John","Mike","Paul","Peter"
-----------------------------------------------
Im learning to use PHP and reading about array_splice found that
<?php
function array_insert($array,$pos,$val)
{
$array2 = array_splice($array,$pos);
$array[] = $val;
$array = array_merge($array,$array2);
return $array;
}
$a = array("John","Paul","Peter");
$a = array_insert($a,1,"Mike");
print_r($a);
?>
would output the same as
<?php
$b = array("John","Paul","Peter");
array_splice($b,1,0,array("Mike"));
print_r($b);
?>
<?php
//Simple Login Script using associative array.
//You may modify the codes and use $_POST['FORM_FIELD_DATA'] for your web-page.
//You may spice-up the codes with more form field validation & security features.
//$user_name=$_POST['user_name'];
//$password=$_POST['password'];
$test_user_name = 'michelle_smith'; //for testing purpose only
$test_password = 'msmith321'; //for testing purpose only
$user_name = $test_user_name;
$password = $test_password;
// here user_name is key and password is the value of an array..
// website owner has to add new user/site member manually in $login_array
$login_array = array(
'user_name' => 'password',
'alex_duff' => 'alx321',
'xena78' => 'xena321',
'dela_pena' => 'delp321',
'shawn_1981' => 'shw81',
'michelle_smith' => 'msmith321');
ksort ($login_array);
reset($login_array);
if (isset($login_array[$user_name]))
{
$pass_check = $login_array[$user_name];
if ($password === $pass_check)
{
echo "Welcome, $user_name!\n<br>"; //may redirect to specific webpage.
}
else
{
echo "Please try again!"; //may redirect to Error page.
}
}
else
{
echo "Please register with us. Thanks!"; //may redirect to registration page.
exit();
}
echo("\n<br>");
echo 'Thanks to Thies C. Arntzen, Stig Bakken, Shane Caraveo, Andi Gutmans, Rasmus Lerdorf, Sam Ruby, Sascha Schumann, Zeev Suraski, Jim Winstead, Andrei Zmievski for wonderful PHP!';
?>
Its worth noting that there does not appear to be any functional limitations on the length or content of string indexes. The string indexes for your arrays can contain any characters, including new line characters, and can be of any length:
<?php
$key = "XXXXX";
$test = array($key => "test5");
for ($x = 0; $x < 500; $x++) {
$key .= "X";
$value = "test" . strlen($key);
$test[$key] = $value;
}
echo "<pre>";
print_r($test);
echo "</pre>";
?>
Keep in mind that using extremely long array indexes is not a good practice and could cost you lots of extra CPU time. However, if you have to use a long string as an array index you won't have to worry about the length or content.
<?php
//EXAMPLE of Multi-Dimentional Array where as an array's keys are an array itself.
//It's so easy to create one like this.
$movie_to_watch = array ('Action'=>
array('Kanu Reeves' => 'Matrix Reloaded',
'Pearce Brosnan' => 'Die Another Day',
'Tom Cruz' => 'Mission Impossible',
'Jason Statham' => 'Crank',
'Danzel Washington' => 'Man on Fire'),
'Comedy' =>
array ('Charlie Chaplin' => 'City Lights',
'Jim Carrey' => 'Cable Guy',
'Rowan Atkinson' => 'The Ultimate Disaster'));
$type_wanted = 'Action'; //You may switch type from Action to Comedy.
$hero_wanted = 'Pearce Brosnan'; // You may switch hero from Pearce Brosnan to Jim Carrey.
print ("$hero_wanted 's $type_wanted movie is " . $movie_to_watch[$type_wanted][$hero_wanted].".");
// produces browser output as under:
// Pearce Brosnan 's Action movie is Die Another Day.
?>
Hey..
here is a function which helps to avoid using empty/isset
checkings for arrays.
(it's acts simillar to 'default' modifier in Smarty)
Using this function you will avoid 'Undefined index' or
'Undefined offset' error.
<?php
$_POST['id']['other'] = 'val1';
/*
key exist (same as $_POST['id'][other])
*/
echo getRequestParam('id[other]', 'default value');
/*
key doesn't exist, we get default value (same as $_POST['var'])
*/
echo getRequestParam('var', 'default value');
function getRequestParam( $var, $default = '', $method = 'post' )
{
preg_match_all('!(\w+)!i',$var, $match );
array_shift($match);
$_vars = $match[0];
$ret = null;
if( strtoupper($method) == 'POST' ) {
$ret = _findRequestParam($_vars, $_POST);
}
elseif( strtoupper($method) == 'GET' ) {
$ret = _findRequestParam($_vars, $_GET);
}
elseif( strtoupper($method) == 'COOKIE' ) {
$ret = _findRequestParam($_vars, $_COOKIE);
}
elseif( strtoupper($method) == 'SESSION' ) {
$ret = _findRequestParam($_vars, $_SESSION);
}
if (! $ret )
return $default;
else
return $ret;
}
/**
@access private
*/
function _findRequestParam($vars, $find_in , $curr_key = 0)
{
static $ret;
if( array_key_exists($vars[$curr_key], $find_in) ) {
if( count( $vars)-1 == $curr_key ) {
$ret = $find_in[$vars[$curr_key]];
}
elseif( $curr_key < count( $vars)-1 ) {
_findRequestParam( $vars, $find_in[$vars[$curr_key]], $curr_key+1 );
}
}
return $ret;
}
?>
Hope this will help someone!
Another note on unquoted array indices. Because it is first interpreted as a constant, it must obey the naming convention of constants. i.e. a letter or underscore followed by optional letter, digit and/or underscore characters.
Therefore while the following array declaration is legal:
$a = array('1st'=>'First','2nd'=>'Second');
Trying to access either array item as follows causes an error:
$first = "$a[1st]";
$second = "$a[2nd]";
<b>Mark Gukov</b> wrote below:
Regarding the fact that there's no need to quote arrays keys when enclosed in double quotes: it only applies to single dimensional arrays.
The following works fine:
<?php
$r['a'] = 'apple';
echo "$r[a] is tasty.";
?>
...but in the case of multi-dimensional arrays:
<?php
$r['a']['b'] = 'banana';
echo "$r[a][b] is tasty.";
?>
would result in "Array[c] is tasty."
-----------------------------------------------------------------
However, the following runs fine;
$r['a']['b'] = 'banana';
echo "{$r[a][b]} is tasty.";
Just box it!
It's slightly faster to use array_splice to remove an element of an array:
array_splice($array, $index, 1)
than to do it using the suggested method of unset and reindex:
unset($array[$index]);
$array = array_values($array);
The difference, however, is very small. With 950 iterations I had times of
unset and reindex: 0.22837495803833
splice: 0.22392416000366
This Indonesian number speller function is twice
faster(*) than the one provided in class Terbilang by
anghuda(at)gmail(dot)com (25-May-2006 08:52):
http://www.lesantoso.com/terbilang.html
(*) 2.1 vs. 4.2 seconds in processing 10000 random numbers
On array recursion...
Given the following code:
<?
$myarray = array('test',123);
$myarray[] = &$myarray;
print_r($myarray);
?>
The print_r() will display *RECURSION* when it gets to the third element of the array.
There doesn't appear to be any other way to scan an array for recursive references, so if you need to check for them, you'll have to use print_r() with its second parameter to capture the output and look for the word *RECURSION*.
It's not an elegant solution, but it's the only one I've found, so I hope it helps someone.
About the automatic conversion of bare strings...
My opinion is that it never should have been implemented. Isn't it easier to NOT implement this "handy" feature in the first place? It is such a convenient way for "smart" programmers to write unsafe, not-futureproof code. Please remove this feature from future versions of PHP, please. (Hey, if you could change the OOP mechanisms between PHP 4 and PHP 5, why can't you make this change, right?)
This page should include details about how associative arrays are implemened inside PHP; e.g. using hash-maps or b-trees.
This has important implictions on the permance characteristics of associative arrays and how they should be used; e.g. b-tree are slow to insert but handle collisions better than hashmaps. Hashmaps are faster if there are no collisions, but are slower to retrieve when there are collisions. These factors have implictions on how associative arrays should be used.
Regarding the fact that there's no need to quote arrays keys when enclosed in double quotes: it only applies to single dimensional arrays.
The following works fine:
<?php
$r['a'] = 'apple';
echo "$r[a] is tasty.";
?>
...but in the case of multi-dimensional arrays:
<?php
$r['a']['b'] = 'banana';
echo "$r[a][b] is tasty.";
?>
would result in "Array[c] is tasty."
Regarding the message of phoenixbytes:
The line foreach($bad as $baddies); will just yield in $baddies the last value of the array $bad.
I think that wasn't your intention, in that case there are faster and better ways than foreach.
I think what you wanted to do is:
<?php
foreach($bad as $baddies) // make a collection
{
if (preg_match("/$baddies/i", $mailto)) // find a match
{
$addrmail = "false";
}
else
{
$addrmail = "true";
}
} // foreach end
?>
in response to ch dot martin at gmail dot com
If you are using the following code:
<?php
$r = array('05' => "abc", '35' => "def");
foreach ($r as $key=>$value)
var_dump($key);
?>
and you need the array key '35' to be a string (for looping maybe), you can make sure the key is a string by appending a 0 on the front.
'035' instead of '35'
Extremely irritating quirk regarding the variable types of array keys:
<?php
$r = array('05' => "abc", '35' => "def");
foreach ($r as $key=>$value)
var_dump($key);
?>
The first var_dump for '05' is:
string(2) "05"
as expected. But the second, '35', turns out as:
int(35)
Php apparently decided to make the 35 became an int, but not the 05 (presumably because it leads with a zero). As far as I can see, there is absolutely no way of making string(2) "35" an array key.
this is simpler tha function display_angka_bilangan by ktaufik(at)gmail(dot)com (16-Feb-2005 12:40)
<?
/*
*
* Class : Terbilang
* Spell quantity numbers in Indonesian or Malay Language
*
*
* author: huda m elmatsani
* 21 September 2004
* freeware
*
* example:
* $bilangan = new Terbilang;
* echo $bilangan -> eja(137);
* result: seratus tiga puluh tujuh
*
*
*/
Class Terbilang {
function terbilang() {
$this->dasar = array(1=>'satu','dua','tiga','empat','lima','enam',
'tujuh','delapan','sembilan');
$this->angka = array(1000000000,1000000,1000,100,10,1);
$this->satuan = array('milyar','juta','ribu','ratus','puluh','');
}
function eja($n) {
$i=0;
while($n!=0){
$count = (int)($n/$this->angka[$i]);
if($count>=10) $str .= $this->eja($count). " ".$this->satuan[$i]." ";
else if($count > 0 && $count < 10)
$str .= $this->dasar[$count] . " ".$this->satuan[$i]." ";
$n -= $this->angka[$i] * $count;
$i++;
}
$str = preg_replace("/satu puluh (\w+)/i","\\1 belas",$str);
$str = preg_replace("/satu (ribu|ratus|puluh|belas)/i","se\\1",$str);
return $str;
}
}
?>
phoenixbytes: The regex you have posted for matching email addresses is incorrect. Among other things, it does not allow '+' before the '@' (which is perfectly valid and can be quite useful to separate extensions of a single address). RFC 822 [1] defines the grammar for valid email addresses, and (the extemely long) regex implementing can be found at [2]. Even the "Add Note" page here at php.net says:
[quote]
And if you're posting an example of validating email addresses, please don't bother. Your example is almost certainly wrong for some small subset of cases. See this information from O'Reilly Mastering Regular Expressions book for the gory details.
[/quote]
A note to others: please do your homework before writing another email-matching regex.
[1] http://www.ietf.org/rfc/rfc0822.txt?number=822
[2] http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html.
i use the array() function for deciding upon an email address's validity, i have a 'wap stalker' of my site that loves to exploit every hole i leave, so i used the following script to avoid being email bombed with my own file sender script, the array() is used to filter out undesirable email providers and, of course, any and all of my own addresses. before all that i used a REGEX to make sure it's an actual email address before going any further.
$mailto = "mail.domain.org"; // the input to be tested
if (preg_match("/^[A-Z0-9._%-]+@[A-Z0-9._%-]+\.[A-Z]{2,6}$/i", $mailto)) // see if it's really an email address
{
$bad = array('mytrashmail.com', 'mymail.ro', 'acasa.ro', 'gala.net', 'phoenixbytes'); // pick out the victims
foreach($bad as $baddies); // make a collection
if (preg_match("/$baddies/i", $mailto)) // find a match
{
$addrmail = "false";
}
else
{
$addrmail = "true";
}
}
else
{
$addrmail = "false";
}
$addrmail can then be used in an argument.
$baddies can be used to give a list, if necessary.
i hope this helps someone.
Passing variables into the array constructor:
Just a NOOB pointer, I couldn't find other examples for this. If you want to pass the value of an existing variable into the array() constructor, you can quote it or not, both methods are valid.
<?
$foo_value = 'foo string';
$bar_value = 'bar string';
$myArray = array(
'foo_key' => $foo_value, // not quoted
'bar_key' => "$bar_value"); // quoted
foreach ($myArray as $k => $v) {
echo "\$myArray[$k] => $v.<br />\n";
}
?>
Both of these will work as expected, but the unqoted $foo_value method above is marginally faster because adding quotes adds an additional string de-reference.
if you need to check a multidimensonal array for values it's handy to store it like
$ar['key1'][0]
$ar['key2'][0]
$ar['key3'][0]
$ar['key1'][1]
$ar['key2'][1]
$ar['key3'][1]
and to loop the keys.
Fill the array (from a database-request):
while($rf=mysql_fetch_row($rs))
{
$nr=$rf[0];
$channel['nr'][$nr]=$rf[1];
$channel['chatter'][$nr]=$rf[2];
}
Call the values:
foreach(array_keys($channel['nr']) as $test)
{
print ' nr:'.$test.'<br>';
print 'value nr: '.$channel['nr'][$test].'<br>';
print ' chatter: '.$channel['chatter'][$test].'<br>';
}
This is useful, if you have to look later for an element
inside the array:
if(in_array($new_value,$channel['nr'])) print 'do something.';
Hope this helps someone.
Regarding the previous comment, beware of the fact that reference to the last value of the array remains stored in $value after the foreach:
<?php
foreach ( $arr as $key => &$value )
{
$value = 1;
}
// without next line you can get bad results...
//unset( $value );
$value = 159;
?>
Now the last element of $arr has the value of '159'. If we remove the comment in the unset() line, everything works as expected ($arr has all values of '1').
Bad results can also appear in nested foreach loops (the same reason as above).
So either unset $value after each foreach or better use the longer form:
<?php
foreach ( $arr as $key => $value )
{
$arr[ $key ] = 1;
}
?>
Regarding the previous comment, thw following code does the job:
<?php
foreach($arr as $key => &$value) {
$value = 1;
}
?>
Regarding the previous comment, the fact that this code has no effect is perfectly expected:
<?php
foreach($arr as $value) {
$value = 1;
}
?>
The reason that this doesn't work, is because each time that PHP goes through the loop, it _copies_ the value of the array element into $value. So if you assign a new value to the data in $value, it has no effect on the actual array, because you only changed the value of the copy that was put in $value.
As was discovered in the previous post, the only way to get around this problem is to change the value in the original array. Hence, a typical foreach should instead look like this:
<?php
foreach($arr as $key => $value) {
$arr[$key] = 1;
}
?>
[Editor's note: You can achieve what you're looking for by referencing $single, rather than copying it by value in your foreach statement. See http://php.net/foreach for more details.]
Don't know if this is known or not, but it did eat some of my time and maybe it won't eat your time now...
I tried to add something to a multidimensional array, but that didn't work at first, look at the code below to see what I mean:
<?php
$a1 = array( "a" => 0, "b" => 1 );
$a2 = array( "aa" => 00, "bb" => 11 );
$together = array( $a1, $a2 );
foreach( $together as $single ) {
$single[ "c" ] = 3 ;
}
print_r( $together );
/* nothing changed result is:
Array
(
[0] => Array
(
[a] => 0
[b] => 1
)
[1] => Array
(
[aa] => 0
[bb] => 11
)
) */
foreach( $together as $key => $value ) {
$together[$key]["c"] = 3 ;
}
print_r( $together );
/* now it works, this prints
Array
(
[0] => Array
(
[a] => 0
[b] => 1
[c] => 3
)
[1] => Array
(
[aa] => 0
[bb] => 11
[c] => 3
)
)
*/
?>
It is a kind of simple muti-dimensional array list.
I have made it just to give a simple idea.
<?php
echo "Here we'll see how to create a multi-dimensional array.\n";
$a=array('fruits'=>array('a'=>'orange',
'b'=>'grape',c=>'apple'),
'numbers'=>array(1,2,3,4,5,6),
'holes'=>array('first',5=>'second',
'third')
);
foreach($a as $list=>$things){
foreach($things as $newlist=>$counter){
echo $counter;
}
}
?>
Here's a simple function to insert a value into some position in an array
<?php
function array_insert($array,$pos,$val)
{
$array2 = array_splice($array,$pos);
$array[] = $val;
$array = array_merge($array,$array2);
return $array;
}
?>
and now for example...
<?php
$a = array("John","Paul","Peter");
$a = array_insert($a,1,"Mike");
?>
Now $a will be "John","Mike","Paul","Peter"
Beware that if you're using strings as indices in the $_POST array, that periods are transformed into underscores:
<html>
<body>
<?php
printf("POST: "); print_r($_POST); printf("<br/>");
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<input type="hidden" name="Windows3.1" value="Sux">
<input type="submit" value="Click" />
</form>
</body>
</html>
Once you click on the button, the page displays the following:
POST: Array ( [Windows3_1] => Sux )
Something that tripped me up:
If you mix string and integer keys, be careful if you are doing a comparison on the to find if a string key exists.
For example, this will not do what you expect it to do:
<?php
$exampleArray = array();
$exampleArray['foo'] = 'bar';
$exampleArray[] = 'Will create 0 index';
$keyWeAreLookingFor = "correctKey";
foreach ($exampleArray as $key => $value){
if ($key == $keyWeAreLookingFor){
print "Found Key";
}
}
?>
It will print "Found Key", because (I presume) when PHP makes the comparison between the string "correctKey" and the index 0, it casts the string to an integer, rather than casting 0 to the string "0" and then doing the comparison.
Using === fixes the problem:
<?php
foreach ($exampleArray as $key => $value){
if ($key === $keyWeAreLookingFor){
print "Found Key";
}
}
?>
Used to creating arrays like this in Perl?
@array = ("All", "A".."Z");
Looks like we need the range() function in PHP:
<?php
$array = array_merge(array('All'), range('A', 'Z'));
?>
You don't need to array_merge if it's just one range:
<?php
$array = range('A', 'Z');
?>
On array copying a deep copy is done of elements except those elements which are references, in which case the reference is maintained. This is a very important thing to understand if you intend on mixing references and recursive arrays.
By Example:
$a = array( 1 );
$aref_a = array( &$a );
$copy_aref_a = $aref_a;
$acopy_a = array( $a );
$copy_acopy_a = $acopy_a;
$a[] = 5;
$acopy_a[0][] = 6;
print_r( $aref_a ); //Shows: ( (1,5) )
print_r( $copy_aref_a ); //Shows: ( (1,5) )
print_r( $acopy_a ); //Shows: ( (1, 6) )
print_r( $copy_acopy_a ); //Shows: ( (1) )
For you who works for localized "say" number to letter ( ex , 7=> seven, 8=>eight) for Bahasa Indonesia.
Indonesia "say" or "Terbilang" is based on 3 digit number.
thousands, millions and trillions .... will be based on the 3 digit number.
In Indonesia you say 137 as "Seratus Tiga Puluh Tujuh"
<?php
//build random 3 digit number to be "said" in Bahasa Indonesia
$x=rand(0,9);
$y=rand(0,9);
$z=rand(0,9);
function display_angka_bilangan($n) {
$angka = array(
1 => 'satu',
2 => 'dua',
3 => 'tiga',
4 => 'empat',
5 => "lima",
6 => 'enam',
7 => 'tujuh',
8 => 'delapan',
9 => 'sembilan'
);
return $angka[$n];
}
// Terbilang X-------Say X
if ($x==1){$terbilangx="seratus ";}
elseif ($x==0){$terbilangx='';}
else {$terbilangx=''.display_angka_bilangan($x).' '.'ratus ';}
// Terbilang Y ------Say Y
if ($y==0){$terbilangy='';}
elseif ($y==1 && $z==1){$terbilangy="sebelas";$terbilangz='';}
elseif ($y==1 && $z==0){$terbilangy="sepuluh ";$terbilangz='';}
elseif ($y==1 && $z!==1 && $z!==0){$terbilangy=''.display_angka_bilangan($z).' belas ';}
else {$terbilangy=''.display_angka_bilangan($y).' '.'puluh ';}
// Terbilang z ------Say z
if ($z==0){$terbilangz="";}
elseif ($z==0 && $y==1){$terbilangz="";}
elseif ($z==1 && $y==1){$terbilangz="";}
elseif($y==0) {$terbilangz="".display_angka_bilangan($z);}
elseif ($y==1 && $z!==1 && $z!==0) {$terbilangz="";}
else {$terbilangz="".display_angka_bilangan($z);};
$terbilang=$terbilangx.$terbilangy.$terbilangz;
echo $x.$y.$z." ";
echo $terbilang;
?>
Hope it is useful
ktaufik(at)gmail(dot)com
[Editor's Note: (Second example.) These are not "arrays in arrays". These are single-dimensional arrays containing stdClass objects; all objects are referenced by default in PHP5. You can see in the var_dump output that they point to the same object.]
Attention with Arrays in Arrays!
If you copy (=) an array which contains arrays it will be REFERENCED not COPIED.
Example:
<?php
/* GOOD ONE */
echo "<b>Here copy (=) works correct:</b><br>";
/* Initialise Array 1 */
$x1 = array(array(10,20),array(30,40));
/* COPY Array */
$x2 = $x1;
/* Change some values in Array 2 */
$x2[0][0]=77;
$x2[1][1]=99;
echo "<b>Original:</b><pre>";
var_dump($x1);
echo "</pre><b>Changed Copy:</b><pre>";
var_dump($x2);
/* BAAAAAAAD ONE */
echo "</pre><hr><b>Here copy (=) FAILS:</b><br>";
/* Initialise Array 1 */
$a1[0]->bla[0]->id=10;
$a1[0]->bla[1]->id=20;
$a1[1]->bla[0]->id=30;
$a1[1]->bla[1]->id=40;
/* COPY Array */
$a2 = $a1;
/* Change some values in Array 2 (!) */
$a2[0]->bla[0]->id=77;
$a2[1]->bla[1]->id=99;
echo "<b>Original:</b><pre>";
var_dump($a1);
echo "</pre><b>Changed Copy:</b><pre>";
var_dump($a2);
echo "</pre>";
php?>
The output of $a1 and $a2 will be the same..
Programmers new to PHP may find the following surprising:
<?php
$x[1] = 'foo';
$x[0] = 'bar';
echo "Original array:\n";
var_dump($x);
array_pop($x);
echo "Array after popping last element:\n";
var_dump($x);
?>
The surprise is that element 0 is deleted, not element 1. Apparently the notion of "last element" has more to do with how the array is stored internally than with which element has the highest numeric index. I recently translated a Perl program to PHP and was bitten by this one.
My solution was to identify all the places in my code where I could prove that the array elements were assigned sequentially. In those cases it is safe to use array_pop, array_splice, etc. since the array indices correspond with the array layout. For the other cases, my solution was to write replacements for the built-in array functions such as this one:
<?php
function safe_pop(&$a)
{
if (!isset($a))
return;
if (!is_array($a))
return;
if (count($a) == 0)
return;
unset($a[max(array_keys($a))]);
}
?>
Negative and positive array indices have different behavior when it comes to string<->int conversion. 1 and "1" are treated as identical indices, -1 and "-1" are not. So:
$arr["1"] and $arr[1] refer to the same element.
$arr["-1"] and $arr[-1] refer to different elements.
The following code:
<?
$arr[1] = "blue";
$arr["1"] = "red";
$arr[-1] = "blue";
$arr["-1"] = "red";
var_dump($arr);
?>
produces the output:
array(3) {
[1]=>
string(3) "red"
[-1]=>
string(4) "blue"
["-1"]=>
string(3) "red"
}
This code should create an array with either two or four elements. Which one should be the "correct" behavior is an exercise left to the reader....
It is quite simple, but don't forget when you'll using foreach with forms arrays.
If your field name is:
<input type="checkbox" name="foo['bar'][]" ...
It doesn't work.
This should work:
<input type="checkbox" name="foo[bar][]" ...
I was having trouble getting javascript arrays and php arrays to work together with a Check All checkboxe. Here is a simple solution. Clicking the 'Check All' checkbox will check all checkboxes on the form.
<script language="JavaScript">
function chkAll(frm, arr, mark) {
for (i = 0; i <= frm.elements.length; i++) {
try{
if(frm.elements[i].name == arr) {
frm.elements[i].checked = mark;
}
} catch(er) {}
}
}
</script>
<form name='foo'>
<input type="checkbox" name="ca" value="1" onClick="chkAll(this.form, 'formVar[chkValue][]', this.checked)">
<?php
for($i = 0; $i < 5; $i++){
echo("<input type='checkbox' name='formVar[chkValue][]' value='$i'>");
}
?>
</form>
Dean M.
I didn't find this anywhere in the docs and i think it is worth a mention:
$a[] = &$a;
print_r($a);
// will output:
/*
Array
(
[0] => Array
*RECURSION*
)
*/
// this means that $a[0] is a reference to $a ( that is detected by print_r() ). I guess this is what the manual calls 'recursive arrays'.
"Using NULL as a key will evaluate to an empty string. Using an emptry string as key will create (or overwrite) a key with an empty string and its value, it is not the same as using empty brackets."
If you create an array like this:
$foo = array(null => 'bar');
And then want to access 'bar', you must use this syntax:
echo $foo['']; // notice the two single quotes
This will of course cause a fatal error:
echo $foo[];
Dereferencing arrays takes some time, but is not terribly expensive.
I wrote two dummy loops to test performance:
for ($i =0; $i < count($a); $i++) {
$x = $a[$b[$i]];
$y = $a[$b[$i]];
$z = $a[$b[$i]];
}
for ($i =0; $i < count($a); $i++) {
$q = $b[$i];
$x = $a[$q];
$y = $a[$q];
$z = $a[$q];
}
The first loop is 6.5% slower than the second. Meaning that dereferencing arrays is not terribly expensive, unless you do it a whole lot. I would expect that each extra reference costs about 3% in speed. The lesson is that if you're going to be using a specific value in an array for a number of operations, you can gain a little speed by assigning it to a temp variable (or creating a reference with $q = &$b[$i]) but it's not worth getting crazy over.
I tested this with iterations of 10,000 and 100,000 on php 4.2 and the results were consistent.
Recursive arrays and multi-dimensional arrays are the same thing and completely identical.
The following confirms this:
$fruits1["european"]["green"] = "Apple";
$fruits2 = array ( "european" => array ( "green" => "Apple"));
print ($fruits1 === $fruits2);
Result: 1 (= true)
Arrays can be merged using + as discussed in the notes for array_merge.
http://www.php.net/manual/en/function.array-merge.php
For all of you having problems when using php arrays in an HTML form input field name, and wanting to validate the form using javascript for example, it is much easier to specify an id for the field as well, and use this id for validation.
Example:
<input type="text" id="lastname" name="fields[lastname]">
then in the javascript check:
if(formname.lastname.value == "") {
alert("please enter a lastname!");
}
This works very well. If you have any problems with it, let me know.
