配列の先頭のデータを取得する関数。
┌──────────────────────────────────────┐
│array_shift($配列);                                                         │
└──────────────────────────────────────┘
配列の末尾のデータを取得する関数。
┌──────────────────────────────────────┐
│array_pop($配列);                                                           │
└──────────────────────────────────────┘
これらは、添字が連番じゃない時とか、非常に便利だ。

た・だ・し、重大な欠点がある。
取得した値を配列から除去してしまうという作用だ。
元々、そういう目的の関数を参照用に流用しているだけの話だ。

じゃどうすればよいか。
一旦、値渡しで何らかの一時配列に渡して、後は好きにやってくれってのが思い当たる。
┌──────────────────────────────────────┐
│$ワーク = $配列;                                                            │
│array_pop($ワーク);                                                         │
└──────────────────────────────────────┘

でも、なんかまどろっこしい。
一行でやれないものか。。。

ダミーで一関数噛ませてやって、ワーク変数的に扱えばいいじゃん。
ってことで、人畜無害な足し算関数「array_merge()」を使用。
┌──────────────────────────────────────┐
│array_pop(array_merge($配列));                                              │
└──────────────────────────────────────┘

しかしながら、敵もさるもの、ワーニングを吐いてしまう。
┌──────────────────────────────────────┐
│Strict Standards: Only variables should be passed by reference in …        │
└──────────────────────────────────────┘

う～ん、これでどうだ。(なんか無理やり)
┌──────────────────────────────────────┐
│@array_pop(array_merge($配列));                                             │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│$array = array(                                                             │
│  1 => array('id' => 1, 'code' => 'a'),                                     │
│  2 => array('id' => 2, 'code' => 'b'),                                     │
│  3 => array('id' => 3, 'code' => 'c')                                      │
│);                                                                          │
└──────────────────────────────────────┘
例えば上記のような二次元配列があって、code列だけを抽出したい場合に、
簡単に実現できる方法はないものだろうか

以下のような力技が思いつくがもっとスマートにできないものか
┌──────────────────────────────────────┐
│function array_keys2($array, $key) {                                        │
│  $return = array();                                                        │
│  foreach ($array as $value1) {                                             │
│    foreach ($value1 as $key2 => $value2) {                                 │
│      if ($key2 === $key){                                                  │
│        $return[] = $value2;                                                │
│      }                                                                     │
│    }                                                                       │
│  }                                                                         │
│  return $return;                                                           │
│}                                                                           │
└──────────────────────────────────────┘

ある配列に値を追加していきたいのだが、既に値があるものは回避して
新入りだけを追加したい場合の方法(もっと簡単な方法がありそうだが)。

【案１】とりあえず追加だけしちゃって一意にしなおす方法
┌──────────────────────────────────────┐
│$配列[] = $値;                                                              │
│$配列 = array_unique($配列);                                                │
└──────────────────────────────────────┘
これだと、結構キー(添字)が歯抜けになってしまうので、
「array_merge(array_unique($配列))」も併用したいところ。

【案２】追加前にないことを確認する方法
┌──────────────────────────────────────┐
│if (!in_array($値, $配列)) {                                                │
│  $配列[] = $値;                                                            │
│}                                                                           │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│array_unique($配列)                                                         │
└──────────────────────────────────────┘
だけだとキーが歯抜けになる

でも、さらにこうすると
┌──────────────────────────────────────┐
│array_merge(array_unique($配列));                                           │
└──────────────────────────────────────┘
前詰になる。

┌──────────────────────────────────────┐
│list($a, $b, $c) = array($a, $b, $c);                                       │
└──────────────────────────────────────┘
だね。

「echo TRUE;」は「1」(※)で、「echo FALSE;」は「」(空文字)だったりするわけだが
んじゃ、連想配列のキーにしてみたら…？
┌──────────────────────────────────────┐
│$a[TRUE]  = 'a';                                                            │
│$a[FALSE] = 'b';                                                            │
└──────────────────────────────────────┘
ってのを用意して、
┌──────────────────────────────────────┐
│print_r($a);                                                                │
└──────────────────────────────────────┘
ってやるわけですよ。

結果はこう。
┌──────────────────────────────────────┐
│Array ( [1] => a [0] => b )                                                 │
└──────────────────────────────────────┘

ま、想定通りといえば想定通り、意外といえば意外かも。

直接こんな書き方はしないだろうが、変数とかを介して
意図せずして(？)こういうケース(論理型をキーにしてしまうケース)に出くわすのでは。

※でもね、この「1」は「=== TRUE」では真だが「=== 1」や「=== '1'」では偽だ。
  まぎれもなく、「TRUE」のようだ。これ注意ね。

┌──────────────────────────────────────┐
│$array = array(1, 2, 3, 4, 5);                                              │
└──────────────────────────────────────┘
上記みたいな配列があって、先頭から 3件だけ抽出したい場合、どうするか？

┌──────────────────────────────────────┐
│$result = array();                                                          │
│for ($i = 0; $ < 3; $i++) {                                                 │
│  $result[$i] = $array[$i];                                                 │
│}                                                                           │
└──────────────────────────────────────┘
こんな感じ？

いやいや一発でできるんです。
┌──────────────────────────────────────┐
│$result = array_slice($array, 0, 3);                                        │
└──────────────────────────────────────┘

すごいぞ、「array_slice()」！

ちなみに、元の配列に3件以上なくても(エラーなく)動作してくれます
＃この場合、当然ながら元の配列と結果は同じになりますね
やっぱりすごいぞ、「array_slice()」！

┌──────────────────────────────────────┐
│shuffle($配列);                                                             │
└──────────────────────────────────────┘
配列から適当に値を取得する場合、添字を乱数で作成する方法もあるが、
「shuffle()」で適当に並び替えて、「$配列[0]」と先頭を取得する方法もある。

こっちだと、乱数で作成する添字の範囲(つまり配列が何件あるか)とか
気にしなくてよく、シンプルにできる。

ただし、並び替えた配列の添字(キー)は新たに割り当てられるので
元の姿をとどめないものだと思って使うべきだ。
(元の姿なんか関係ない場合にはかなり有効)

元の姿をとどめたい場合には、一旦ダミー配列にコピーしてから、
そっちを並び替えればよい。
┌──────────────────────────────────────┐
│$ダミー配列 = 配列;                                                         │
│shuffle($ダミー配列);                                                       │
└──────────────────────────────────────┘

値がしっかりと昇順になっているものと、なっていないものがあった場合
これを判定したいとする。

例えば以下の二つの配列のうち、$bは不正だとはじきたい場合などだ。
┌──────────────────────────────────────┐
│$a = array(0=>0, 1=>1, 2=>2);                                               │
│$b = array(0=>0, 1=>2, 2=>1);                                               │
└──────────────────────────────────────┘

一旦、ダミーをつくりそれを「arsort()」で昇順ソートする。
┌──────────────────────────────────────┐
│$a_dummy = $a;                                                              │
│arsort($a_dummy);                                                           │
└──────────────────────────────────────┘
んでもって、元の配列と比較して、差分がなければ(変化がなければ)
昇順だったってことになる

しかし、ここで注意しなければならないのは「array_diff()」を使わないこと
┌──────────────────────────────────────┐
│if (array_diff($a, $a_dummy)) {                                             │
│  echo '昇順でない';                                                        │
│}                                                                           │
└──────────────────────────────────────┘
この関数は並び順度外視で、要素の比較だけに専念するので
差分なしと判定されてしまう。

正しくは「!==」で厳密に比較してあげればよい。
┌──────────────────────────────────────┐
│if ($a !== $a_dummy) {                                                      │
│  echo '昇順でない';                                                        │
│}                                                                           │
└──────────────────────────────────────┘
これなら並び順が違うだけでも、検出してくれる。

なお、降順で判定したい場合は、「asort()」を「arsort()」にすればいい。

多次元配列の値のみをまとめて一次元配列として取り出す方法はないものか？
最終的には「implode()」とかで、CSV形式で一列にしたりしたい。
ってことで、そんな関数がないかと探しているが見当たらないので
関数を作ってしまうことにした。

ふたパターンつくってしまった(結果は同じ)。
┌──────────────────────────────────────┐
│function getValueInArray($array) {                                          │
│  static $return = array();                                                 │
│  foreach($array as $value) {                                               │
│    if (is_array($value)) {                                                 │
│      getValueInArray($value);                                              │
│    } else {                                                                │
│      $return[] = $value;                                                   │
│    }                                                                       │
│  }                                                                         │
│  return $return;                                                           │
│}                                                                           │
├──────────────────────────────────────┤
│function getValueInArray($array) {                                          │
│  $return = array();                                                        │
│  foreach($array as $value) {                                               │
│    if (is_array($value)) {                                                 │
│      $return = array_merge($return, getValueInArray($value));              │
│    } else {                                                                │
│      $return[] = $value;                                                   │
│    }                                                                       │
│  }                                                                         │
│  return $return;                                                           │
│}                                                                           │
└──────────────────────────────────────┘

例えば以下のような多次元配列を投入すると、
┌──────────────────────────────────────┐
│$array = array('a',                                                         │
│               'B' => array('ba', 'bb'),                                    │
│               'C' => array('CA' => array('caa')));                         │
├──────────────────────────────────────┤
│├a        ←これと                                                         │
│├B                                                                         │
││├ba     ←これと                                                         │
││└bb     ←これと                                                         │
│└C                                                                         │
│  └CA                                                                      │
│    └caa  ←これを採取する                                                 │
└──────────────────────────────────────┘
以下のような結果となる(print_r()で出力)
┌──────────────────────────────────────┐
│Array ( [0] => a [1] => ba [2] => bb [3] => caa )                           │
└──────────────────────────────────────┘