reset

Производит сброс курсора массива (PHP 3, PHP 4, PHP 5)

Синтаксис:

mixed reset(array arr)

Функция reset() устанавливает внутренний курсор массива arr на его начало и возвращает значение начального элемента.

Пример использования функции reset():

<?php
$array = array("step one", "step two", "step three", "step four");

// by default, the pointer is on the first element echo current($array) . "<br />n"; // "step one"

// skip two steps next($array);
next($array);
echo current($array) . "<br />n"; // "step three"

// reset pointer, start again on step onereset($array);
echo current($array) . "<br />n"; // "step one"
?>

end

Производит перенос курсора в конец массива (PHP 3, PHP 4, PHP 5)

Синтаксис:

mixed end(array arr)

Функция end() устанавливает внутренний курсор массива arr на последний элемент и возвращает значение этого элемента.

Пример использования функции end():

<?php
$fruits = array("apple", "banana", "cranberry");
echo end($fruits); // cranberry
?>

next

Производит перенос курсора вперед (PHP 3, PHP 4, PHP 5)

Синтаксис:

mixed next(array arr)

Функция next() возвращает значение элемента, на котором в данный момент находится курсор, и перемещает курсор массива на следующий элемент. Возвращает false, если элементов больше не осталось.

Также false возвращается, если встречается элемент с пустым значением, следовательно для корректной работы с массивом, содержащим пустые элементы, лучще использовать функцию each().

Пример использования функции next():

<?php
$transport = array("foot", "bike", "car", "plane");
$mode = current($transport); // $mode = "foot";
$mode = next($transport); // $mode = "bike";
$mode = next($transport); // $mode = "car";
$mode = prev($transport); // $mode = "bike";
$mode = end($transport); // $mode = "plane";
?>

prev

Производит перенос курсора назад и возвращает предыдущее значени (PHP 3, PHP 4, PHP 5)

Синтаксис:

mixed prev(array arr)

Функция prev() перемещает курсор массива на предыдущий элемент и возвращает его значение. Возвращает false, если элементов больше не осталось.

Также false возвращается, если встречается элемент с пустым значением, следовательно для корректной работы с массивом, содержащим пустые элементы, лучще использовать функцию each().

Пример использования функции prev():

<?php
$transport = array("foot", "bike", "car", "plane");
$mode = current($transport); // $mode = "foot";
$mode = next($transport); // $mode = "bike";
$mode = next($transport); // $mode = "car";
$mode = prev($transport); // $mode = "bike";
$mode = end($transport); // $mode = "plane";
?>

current

Определение текущего элемента массива (PHP 3, PHP 4, PHP 5)

Синтаксис:

mixed current(array arr)

Каждый массив имеет внутренний указатель(курсор) текущего элемента. Обычно он указывает на первый элемент массива.

Функция current() возвращает значение элемента, на котором в данный момент находится курсор массива, при этом не сдвигая курсор.

Если указатель находиться за пределами массива, или массив пустой, то функция возвратит FALSE.

Пример использования функции current():

<?php
$transport = array("foot", "bike", "car", "plane");
$mode = current($transport); // $mode = "foot";
$mode = next($transport); // $mode = "bike";
$mode = current($transport); // $mode = "bike";
$mode = prev($transport); // $mode = "foot";
$mode = end($transport); // $mode = "plane";
$mode = current($transport); // $mode = "plane";
?>

pos

Определение текущего элемента массива.

Синтаксис:

mixed pos(array arr)

Эта функция синоним функции current().

key

Функция возвращает индекс текущего элемента массива (PHP 3, PHP 4, PHP 5)

Синтаксис:

mixed key(array arr)

Функция key() возвращает индекс текущего элемента массива.

Пример использования функции key():

<?php
$array = array(
"fruit1" => "apple",
"fruit2" => "orange",
"fruit3" => "grape",
"fruit4" => "apple",
"fruit5" => "apple");

// этот цикл пройдется по всему массиву
// и выведет имя ключа элемента массива
// значение которого равно "apple"

while ($fruit_name = current($array)) {
if ($fruit_name == "apple") {
echo key($array)."*<br />";
}
next($array);
}
?>

each

Получение текущего элемента массива (PHP 3, PHP 4, PHP 5)

Синтаксис:

array each(array arr)

Функция each() возвращает пару"индекс и значение" текущего элемента массива, на который указывает внутренний курсор, и сдвигает курсор массива на следующий элемент.

Пример использования функции each():

<?php
$foo = array("bob", "fred", "jussi", "jouni", "egon", "marliese");
$bar = each($foo);
print_r($bar);
?>

Массив $bar будет иметь ключи и значения:

Array(
[1] => bob
[value] => bob
[0] => 0
[key] => 0
)

<?php
$foo = array("Robert" => "Bob", "Seppo" => "Sepi");
$bar = each($foo);
print_r($bar);
?>

Массив $bar будет иметь ключи и значения:

Array(
[1] => Bob
[value] => Bob
[0] => Robert
[key] => Robert
)

Пример использования функции each():

Пролистывание массива

<?php
$fruit = array("a" => "apple", "b" => "banana", "c" => "cranberry");

reset($fruit);
while (list($key, $val) = each($fruit)) {
echo "$key => $val";
}
?>

Пример выведет:

a => appleb => bananac => cranberry

array_walk

Применение пользовательской функции к элементам массива (PHP3 >= 3.0.3, PHP4, PHP5)

Синтаксис:

bool array_walk(array arr, callback function [, mixed userdata])

Функция array_walk() применяет пользовательскую функцию function к каждому элементу массива arr. В пользовательскую функцию передаются три или два (в случае, если аргумент userdata не указан) аргумента: значение текущего элемента, его индекс и аргумент userdata.

В случае, если function требует более трех аргументов, при каждом ее вызове будет выдаваться предупреждение. Чтобы блокировать выдачу этих предупреждений, поставте знак "@" перед функцией array_walk() или воспользуйтесь функцией error_reporting().

Функция function будет получать значения и индексы массива arr по занчению, т.е. не сможет вносить в него изменения. Если это необходимо, передайте аргумент arr по ссылке, указав перед его именем "&", и тогда все изменения отразяться в массиве.

В PHP 4 необходимо явно вызывать функцию reset(), чтобы установить внутренний курсор на первый элемент.

Пример использования функции array_walk():

<?php
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");

function test_alter(&$item1, $key, $prefix)
{
$item1 = "$prefix: $item1";
}

function test_print($item2, $key)
{
echo "$key. $item2<br />n";
}

echo "Before ...:n";
array_walk($fruits, "test_print");

array_walk($fruits, "test_alter", "fruit");
echo "... and after:n";

array_walk($fruits, "test_print");
?>

Приведенный пример выведет следующее:

Before ...:d. lemona. orangeb. bananac. apple
... and after:d. fruit: lemona. fruit: orangeb. fruit: bananac. fruit: apple

Функции для работы с массивами

Эти функции позволят различными способами оперировать с массивами. Массивы идеально подходят для хранения, изменения и работы с наборами переменных.
Поддерживаются одно- и многоразмерные массивы, как созданные пользователем, так и возвращенные в качестве результата какой-либо функцией.
Существуют специальные функции для работы с базами данных, облегчающие работу с массивами данных, возвращаемых в результате выполнения запросов; также существуют функции, возвращающие массивы в качестве результата.
Эти функции всегда доступны.
Для использования этих функций не требуется проведение установки, поскольку они являются частью ядра PHP.

Перечисленные ниже константы всегда доступны как часть ядра PHP.

CASE_LOWER(integer)

CASE_LOWER используется с функцией array_change_key_case() для указания необходимости преобразования ключей массива в нижний регистр символов. По умолчанию функцией array_change_key_case() используется именно эта константа.
CASE_UPPER (integer)

CASE_UPPER используется с функцией array_change_key_case() для указания необходимости преобразования ключей массива в верхний регистр символов.
Флаги типа сортировки:
SORT_ASC(integer)

SORT_ASC - сортировка в порядке возрастания (по умолчанию)

SORT_DESC (integer)

SORT_DESC - сортировка в порядке убывания
SORT_REGULAR (integer)

SORT_REGULAR - сравнивать элементы как есть (по умолчанию)

SORT_NUMERIC (integer)

SORT_NUMERIC - сравнивать элементы как числа
SORT_STRING (integer)

SORT_STRING - сравнивать элементы как строки
EXTR_OVERWRITE (integer)

EXTR_SKIP (integer)

EXTR_PREFIX_SAME (integer)

EXTR_PREFIX_ALL (integer)

EXTR_PREFIX_INVALID (integer)

EXTR_IF_EXISTS (integer)

EXTR_PREFIX_IF_EXISTS (integer)

EXTR_REFS (integer)

array

Создание и инициализация массива (PHP 3, PHP 4, PHP 5)

Синтаксис:

array array([mixed ...])

Функция возвращает созданный массив. Индексы и значения в массиве разделяются оператором =>.

Пары index=>value разделяются запятыми, они определяют индекс и значение.

Индекс может быть как числовым, так и строковым. В ассоциированных массивах индекс всегда ведет себя как строковой. В случае, если индекс не указан, будет подставляться автоинкремент (на 1 больше), начиная с 0.

Если при создании массива были указаны два элемента с одинаковыми индексами, то последний элемент заменяет первый.

Пример использования функции array():

<?php
$arr=array( // Далее мы создадим двумерный массив
"fruit" => array("a"=>"orange", "b"=>"banan", "c"=>"apple"),

// эта запись эквивалентна записи: $arr["fruit"]["a"]="orange"; и т.д.
"number" => array(1,2,3,4,5,6),

// эта запись эквивалентна записи: $arr["number"][]=1; и т.д.
"hotel" => array("first", 5=>"second", "third")
);

?>

$arr=array(1, 1, 1, 1, 2=>5, 19, 3=>20);

print_r($arr);

// Далее распечатка этого массива
Array(
[0] => 1
[1] => 1
[2] => 5
[3] => 20
[4] => 19
)

$arr=array(1 => "Январь", "Февраль", "Март");

print_r($arr);
// распечаткаArray(
[1] => Январь
[2] => Февраль
[3] => Март
)

range

Создает массив и заполняет его значениями (PHP 3 >= 3.0.8, PHP 4, PHP 5)

Синтаксис:

array range(int low, int high[, int step])

Функция range() возвращает массив с значениями от low по high включительно. Если low > high, то последовательность будет от high до low.

Дополнительный параметр step был введен в PHP 5.0.

Если третий параметр указан, то числа будут вводиться от low до high с шагом step. Если он не указан, то шаг будет равен 1.

Пример использования функции range():

<?php
// array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
foreach (range(0, 12) as $number) {
echo $number;
}

// The step parameter was introduced in 5.0.0
// array(0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
foreach (range(0, 100, 10) as $number) {
echo $number;
}

// Use of character sequences introduced in 4.1.0
// array("a", "b", "c", "d", "e", "f", "g", "h", "i");
foreach (range("a", "i") as $letter) {
echo $letter;
}
// array("c", "b", "a");
foreach (range("c", "a") as $letter) {
echo $letter;
}
?>

array_reverse

Расстановка элементов массива в обратном порядке.
Синтаксис:

array array_reverse(array arr [, bool preserve_keys])

Функция array_reverse() возвращает массив, элементы которого следуют в обратном порядке относительно массива, переданного в параметре. При этом связи между ключами и значениями не теряются, если дополнительный параметр preserve_keys = TRUE.

Пример использования функции array_reverse():

<?php$input  = array("php", 4.0, array("green", "red"));
$result = array_reverse($input);
$result_keyed = array_reverse($input, true);
?>

Этот пример сделает оба массива $result и $result_keyed с одинаковыми значениями, но различными ключами. Распечатка массивов $result и $result_keyed будет следующей:

Array(
[0] => Array
(
[0] => green
[1] => red
)

[1] => 4
[2] => php
)
Array(
[2] => Array
(
[0] => green
[1] => red
)

[1] => 4
[0] => php
)

Примечание: Второй параметр preserve_keys был добавлен в PHP 4.0.3.

Функция поддерживается PHP 4, PHP 5

natcasesort

Выполняет естественную сортировку массива без учета регистра символов.
Синтаксис:

void natcasesort(array arr)

Функция natcasesort() сортирует массив arr в естественном для человека порядке с сохранением индексных ассициаций.
Эта функция схожа с natsort(), только не учитывает регистр символов.
Пример использования функции natcasesort():

<?php$array1 = $array2 = array("IMG0.png", "img12.png", "img10.png",
"img2.png", "img1.png", "IMG3.png");

sort($array1);
echo "Стандартная сортировкаn";
print_r($array1);

natcasesort($array2);
echo "nЕстественная сортировка (без учета регистра)n";
print_r($array2);
?>

Приведенный пример выведет следующее:

Стандартная сортировкаArray(
[0] => IMG0.png
[1] => IMG3.png
[2] => img1.png
[3] => img10.png
[4] => img12.png
[5] => img2.png
)

Естественная сортировка (без учета регистра)
Array(
[0] => IMG0.png
[4] => img1.png
[3] => img2.png
[5] => IMG3.png
[2] => img10.png
[1] => img12.png
)

Функция поддерживается PHP 4, PHP 5

uasort

Пользовательская сортировка ассоциативного массива с сохранением индексных ассоциаций.
Синтаксис:

bool uasort(array arr, function cmp_function)

Функция uasort() сортирует массив arr с сохранением индексных ассоциаций, используя для сравнения индексов элементов пользовательскую функцию, указанную аргументом cmp_function.
Эта функция используется главным образом когда соответствие индексов и значений массива существенно.
Функция uasort() возвращает true в случае успешного завершения сортировки, и false в противном случае.
Замечание: Смотрите функции usort() и uksort() для написания пользовательской функции.
Функция поддерживается PHP 3 >=3.0.4, PHP 4, PHP 5

uksort

Пользовательская сортировка массива по ключам.
Синтаксис:

bool uksort(array arr, function cmp_function)

Функция uksort() сортирует массив arr по индексам с сохранением индексных ассоциаций, используя для сравнения индексов элементов пользовательскую функцию, указанную в аргументе cmp_function. В эту функцию передаются два сравниваемых индекса элементов, а она должна вернуть положительное или отрицательное число или 0.

Функция uksort() возвращает true в случае успешного завершения сортировки, и FALSE в противном случае.
Довольно часто нам приходится сортировать что-то по более сложному критерию, чем просто по алфавиту. Например, пусть в $Files храниться список имен файлов и подкаталогов в текущем каталоге. Возможно, мы захотим вывести этот список не только в лексографическом порядке, но также чтобы все каталоги предшествовали файлам. В этом случае нам стоит воспользоваться функцией uksort(), написав предварительно функцию сравнения с двумя параметрами, как того требует uksort().

1 пример использования функции uksort():

// Эта функция должна сравнивать значения $f1 и $f2 и возвращать:
// -1, если $f1<$f2,
// 0, если $f1==$f2
// 1, если $f1>$f2
// Под < и > понимаем следование этих имен в выводимом спискеfunction FCmp($f1,$f2)
{ // Каталог всегда предшествует файлу
if(is_dir($f1) && !is_dir($f2)) return -1;
// Файл всегда идет после каталога
if(!is_dir($f1) && is_dir($f2)) return 1;
// Иначе сравниваем лексиграфически
if($f1<$f2) return -1; elseif($f1>$f2) return 1; else return 0;
}
// Пусть $Files содержит массив с ключами - именами файлов
// в текущем каталоге. Отсортируем его.uksort($Files,"FCmp"); //передаем функцию сортировки "

array_multisort()

Сортировать несколько массивов или многомерные массивы (PHP 4, PHP 5)

Описание:

bool array_multisort ( array ar1 [, mixed arg [, mixed ... [, array ...]]] )

Функция array_multisort() может быть использована для сортировки сразу нескольких массивов или одного многомерного массива в соответствии с одной или несколькими размерностями. Эта функция сохраняет соответствие между ключами и соответствующими им значениями.

Входные массивы рассматриваются как столбцы таблицы, которую нужно отсортировать по строкам - такой подход напоминает поведение выражения SQL ORDER BY. Первый массив имеет проиоритет в процессе сортировки.

Структура аргументов этой функции немного необычна, но удобна. Первым аргументом должен быть массив. Последующие аргументы могут быть как массивами, так и значениями, определяющими порядок сортировки, приведенными в нижеследующем списке.

Значения, определяющие порядок сортировки:

SORT_ASC - сортировать в возрастающем порядке
SORT_DESC - сортировать в убывающем порядке

Флаги типа сортировки:

SORT_REGULAR - сравнивать элементы обычным образом
SORT_NUMERIC - сравнивать элементы, как если бы они были числами
SORT_STRING - сравнивать элементы, как если бы они были строками

Недопустимым является указание двух флагов сортировки одинакового типа после каждого массива. Флаги сортировки, переданные после аргумента ar1, применяются только к этому аргументу - перед тем, как функция начнет обрабатывать следующий массив, эти флаги снова принимают значения по умолчаниюt SORT_ASC и SORT_REGULAR.

Возвращает TRUE в случае успешного завершения или FALSE в случае возникновения ошибки.

Сортировка нескольких массивов

$ar1 = array ("10", 100, 100, "a");
$ar2 = array (1, 3, "2", 1);
array_multisort ($ar1, $ar2);

В вышеприведенном примере, после того, как будет осуществлена сортировка, первый массив будет содержать 10, "a", 100, 100. Второй - 1, 1, "2", 3. Элементы второго массива, соответствующие идентичным элементам первого (100 и 100), также будут отсортированы.

Сортировка многомерного массива

$ar = array (array ("10", 100, 100, "a"), array (1, 3, "2", 1));
array_multisort ($ar[0], SORT_ASC, SORT_STRING,
$ar[1], SORT_NUMERIC, SORT_DESC);

В вышеприведенном примере, после сортировки, первый массив будет содержать 10, 100, 100, "a" (его элементы были отсортированы в возрастающем порядке так, как если бы они были строками), а второй массив будет содержать 1, 3, "2", 1 (элементы отсортированы как числа, в порядке убывания).

usort()

Отсортировать массив по значениям используя пользовательскую функцию для сравнения элементов (PHP 3 >= 3.0.3, PHP 4, PHP 5)

Описание:

bool usort ( array &array, callback cmp_function )

Эта функция сортирует элементы массива, используя для сравнения значений пользовательскую функцию. Если вам нужно отсортировать массив по необычному критерию, вы должны использовать эту функцию.

Функция, используемая для сравнения, должна возвращать целое число, меньшее, равное или большее нуля, если первый аргумент соответственно меньше, равен или больше второго.

Замечание: Если два элемента исходного массива равны, их порядок в отсортированном массиве неопределён. До PHP 4.0.6 пользовательские функции сохраняли для таких элеменов порядок в оригинальном массиве, но новый алгоритм сортировки, появившейся в версии 4.1.0 больше не использует это решение и не имеет другого эффективного.

Возвращает TRUE в случае успешного завершения или FALSE в случае возникновения ошибки.

Пример использования usort()

<?php
function cmp($a, $b)
{
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
}

$a = array(3, 2, 5, 6, 1);

usort($a, "cmp");

while (list($key, $value) = each($a)) {
echo "$key: $value
";
}
?>

Результат выполнения данного примера:

0: 1
1: 2
2: 3
3: 5
4: 6

Замечание: Очевидно, что для этого тривиального случая более подходит функция sort().

Пример использования функцией usort() многомерных массивов

<?php
function cmp($a, $b)
{
return strcmp($a["fruit"], $b["fruit"]);
}

$fruits[0]["fruit"] = "lemons";
$fruits[1]["fruit"] = "apples";
$fruits[2]["fruit"] = "grapes";

usort($fruits, "cmp");

while (list($key, $value) = each($fruits)) {
echo "\$fruits[$key]: " . $value["fruit"] . "
";
}
?>

При сортировке многомерного массива переменные $a и $b содержат ссылки на первые два индекса массива.

Результат выполнения данного примера:

$fruits[0]: apples
$fruits[1]: grapes
$fruits[2]: lemons

Пример использования usort() с методом класса

<?php
class TestObj {
var $name;

function TestObj($name)
{
$this->name = $name;
}

/* This is the static comparing function: */
function cmp_obj($a, $b)
{
$al = strtolower($a->name);
$bl = strtolower($b->name);
if ($al == $bl) {
return 0;
}
return ($al > $bl) ? +1 : -1;
}
}

$a[] = new TestObj("c");
$a[] = new TestObj("b");
$a[] = new TestObj("d");

usort($a, array("TestObj", "cmp_obj"));

foreach ($a as $item) {
echo $item->name . "
";
}
?>

Результат выполнения данного примера:

b
c
d

shuffle

Перемешивание элементов массива.
Синтаксис:

void shuffle(array arr)

Функция shuffle() "перемешивает" список, переданный ей первым параметром arr, так, чтобы его значения распределялись случайным образом. При этом измениться сам массив и ассоциативные массивы воспринимаются как списки.
Пример использования функции shuffle():

<?php
$numbers = range(1, 20);
srand((float)microtime() * 1000000);
shuffle($numbers);
while (list(, $number) = each($numbers)) {
echo "$number ";
}

?>

Замечание: Начиная с PHP 4.2.0, больше нет необходимости инициализировать генератор случайных чисел функциями srand()
или mt_srand(), поскольку теперь это происходит автоматически.
Функция поддерживается PHP 3 >= 3.0.8, PHP 4, PHP 5

sort

Сортировка массива по возрастанию.
Синтаксис:

bool sort(array arr [, int sort_flags])

Функция sort() предназначена для сортировки массивов в порядке возрастания.
Замечание: Эта функция изменяет ключи у отсортированных значений. Т.е. любой ассоциативный массив воспринимается этой функцией как список. После упорядочивания последовательность ключей превращается в 0,1,2,..., а значения нужным образом перераспределяются. Как видим, связи между параметрами ключ=>значение не сохраняются, более того - ключи просто пропадают, поэтому сортировать что-либо, отличное от списка, вряд ли целесообразно.
Пример использования функции sort():

<?php$fruits = array("lemon", "orange", "banana", "apple");
sort($fruits);
reset($fruits);
while (list($key, $val) = each($fruits)) {
echo "fruits[" . $key . "] = " . $val . "n";
}
?>

Этот пример выведет:

fruits[0] = applefruits[1] = bananafruits[2] = lemonfruits[3] = orange

Аргумент sort_flags задает следующие флаги сортировки:
SORT_REGULAR - сравнивает элементы "как есть";
SORT_NUMERIC - сравнивает элементы как числа;
SORT_STRING - сравнивает элементы как строки.
Функция поддерживается PHP 3, PHP 4, PHP 5

rsort

Сортировка массива по убыванию.
Синтаксис:

bool rsort ( array array [, int sort_flags])

Функция rsort() сортирует массив array в порядке убывания (от высших значений к низшим).

Функция возвращает TRUE в случае успешного завершения, и FALSE в противном случае.
Пример использования функции rsort():

<?php$fruits = array("lemon", "orange", "banana", "apple");
rsort($fruits);
reset($fruits);
while (list($key, $val) = each($fruits)) {
echo "$key = $valn";
}
?>

Этот пример выведет:

0 = orange
1 = lemon
2 = banana
3 = apple

Аргумент sort_flags задает следующие флаги сортировки:
SORT_REGULAR - сравнивает элементы "как есть"
SORT_NUMERIC - сравнивает элементы как числа SORT_STRING - сравнивает элементы как строки
Функция поддерживается PHP 3, PHP 4, PHP 5

asort

Сортировка ассоциативного массива по возрастанию.
Синтаксис:

bool asort(array arr [, int sort_flags])

Функция asort() сортирует массив, указанный в ее параметре, так, чтобы его значения шли в алфавитном (если это строки) или возрастающем (для чисел) порядке. При этом сохраняются связи между ключами и соответствующими им значениями, т.е. некоторые пары ключ=>значение просто "всплывают" наверх, а некоторые - наоборот, "опускаются".

Функция возвращает true в случае успешного завершения, и false в случае возникновения ошибки.
Пример использования функции asort():

<?php$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
asort($fruits);
reset($fruits);
while (list($key, $val) = each($fruits)) {
echo "$key = $valn";
}
?>

Пример выведет следующее:

c = appleb = bananad = lemona = orange

Массив $fruits был отсортирован в возрастающем символьном порядке, при этом индексы массива были сохранены.
Метод сортировки может быть изменен при помощи необязательного параметра sort_flags.
Этот параметр может указать, как сравнивать значения (как строки или как числа). Он может принимать следующие предопределенные значения:
SORT_REGULAR - нормальное сравение значений;
SORT_NUMERIC - сравнивать как числа;
SORT_STRING - сравнивать как строки.
Этот параметр был введен в PHP начиная с 4 версии.
Функция поддерживается PHP 3, PHP 4, PHP 5

arsort

Сортировка ассоциативного массива по убыванию.
Синтаксис:

bool arsort(array arr [, int sort_flags])

Функция arsort() сортирует массив arr по убыванию с сохранением индексных ассоциаций.
Эта функция используется главным образом там, где существенен порядок элемента в массиве.
Функция возвращает true в случае успешной сортировки, и false в случае возникновения ошибки.
Пример использования функции arsort():

<?php$arr=array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
arsort($arr);
reset($arr);
while(list ($key, $val) = each ($arr)) {
echo "$key = $vall";
}

Пример выведет:

a = oranged = lemonb = bananac = apple

Массив $arr был отсортирован в убывающем символьном порядке, при этом индексы массива были сохранены.
Метод сортировки может быть изменен при помощи необязательного параметра sort_flags.
Этот параметр может указать, как сравнивать значения (как строки или как числа). Он может принимать следующие предопределенные значения:
SORT_REGULAR - нормальное сравение значений;
SORT_NUMERIC - сравнивать как числа;
SORT_STRING - сравнивать как строки.
Этот параметр был введен в PHP начиная с 4 версии.
Функция поддерживается PHP 3, PHP 4, PHP 5

ksort

Сортировка массива по возрастанию ключей.
Синтаксис:

bool ksort(array arr [, int sort_flags])

Функция ksort() сортирует массив в порядке возрастания ключей с сохранением взаимосвязей ключей и значений. Эта функция особенно полезна при сортировке ассоциативных массивов.
Функция возвратит true, если все прошло успешно, и false в противном случае.
Пример использования функции ksort():

<?php$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
ksort($fruits);
reset($fruits);
while (list($key, $val) = each($fruits)) {
echo "$key = $valn";
}
?>

Данный пример выведет:

a = orangeb = bananac = appled = lemon

Аргумент sort_flags задает следующие флаги сортировки:
SORT_REGULAR - сравнивает элементы "как есть"
SORT_NUMERIC - сравнивает элементы как числа SORT_STRING - сравнивает элементы как строки
Функция поддерживается PHP 3, PHP 4, PHP 5

krsort

Сортировка массива по убыванию индексов.
Синтаксис:

bool krsort(array arr [, int sort_flags])

Функция krsort() сортирует ключи в массиве arr в обратном порядке. При этом связка ключей и значений сохраняется. Эта функци полезна при сортировке ассоциативных массивов.
Функция возвращает true в случае успешного завершения, и false в противном случае.
Пример использования функции krsort():

<?php$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
krsort($fruits);
reset($fruits);
while (list($key, $val) = each($fruits)) {
echo "$key = $valn";
}
?>

Данный пример выведет:

d = lemonc = appleb = bananaa = orange

Аргумент sort_flags задает следующие флаги сортировки:
SORT_REGULAR - сравнивает элементы "как есть"
SORT_NUMERIC - сравнивает элементы как числа SORT_STRING - сравнивает элементы как строки
Функция поддерживается PHP 3 >= 3.0.13, PHP 4, PHP 5

natsort

Выполняет "естественную" сортировку массива.
Синтаксис:

void natsort(array arr)

Функция natsort() сортирует массив arr в естественном для человека порядке с сохранением индексных ассициаций.
Пример использования функции natsort():

<?php$array1 = $array2 = array("img12.png", "img10.png", "img2.png", "img1.png");

sort($array1);
echo "Стандартная сортировкаn";
print_r($array1);

natsort($array2);
echo "nЕстественная сортировкаn";
print_r($array2);
?>

Этот пример выведет следующее:

Стандартная сортировкаArray(
[0] => img1.png
[1] => img10.png
[2] => img12.png
[3] => img2.png
)

Естественная сортировкаArray(
[3] => img1.png
[2] => img2.png
[1] => img10.png
[0] => img12.png
)

Функция поддерживается PHP 4, PHP 5

array_flip

Меняет местами индексы и значения массива.
Синтаксис:

array array_flip(array arr)

Эта функция "пробегает" по массиву и меняет местами его ключи и значения. Исходный массив arr не изменяется, а результирующий массив просто возвращается. Если в массиве присутствовало несколько элементов с одинаковыми значениями, учитываться будет только последний из них.

Значения массива arr должны быть либо целыми числами, либо строковыми значениями. Иначе пара ключ / значение не будут обработаны.

Функция array_flip() возвратит FALSE, если обработка массива вызвала ошибку.

Пример использования функции array_flip():

$trans = array_flip ($trans);
$original = strtr ($str, $trans);

Пример использования функции array_flip():

многократное повторение значения 
<php$trans = array ("a" => 1, "b" => 1, "c" => 2);
$trans = array_flip ($trans);
print_r($trans);

Приведенный выше пример выведет следующее:

Array(
[1] => b
[2] => c
)

Функция поддерживается PHP 4, PHP 5

array_change_key_case

Функция устанавливает значения ключей массива в верхний или нижний регистр.
Синтаксис:

array array_change_key_case(array arr[, int registr])

Функция array_change_key_case() возвращает исходный массив arr, ключи которого преобразованы в верхний или нижний регистр.
Необязательный параметр registr может принимать следующие значения:
CASE_LOWER - все ключи массива преобразуются в нижний регистр (значение по умолчанию);
CASE_UPPER - в верхний регистр.
Данная функция не изменяет ключи, состоящие из чисел.
Пример использования функции array_change_key_case():

$array = array("FirSt" => 1, "SecOnd" => 4);
print_r(array_change_key_case($array, CASE_UPPER));
print_r(array_change_key_case($array, CASE_LOWER));

Пример выведет следующее:

Array(
[FIRST] => 1
[SECOND] => 2
)
Array(
[first] => 1
[second] => 2
)

Функция поддерживается PHP 4 >= 4.2.0, PHP 5

array_combine

Функция объединяет два массива, причем значения первого становяться ключами, а значения второго - значениями.
Синтаксис:

array array_combine(array keys, array values)

Функция array_combine() возвращает массив, ключами которого являются значения массива keys, а значениями - значения массива values.
Функция возвратит FALSE, если размерность массивов keys и values не совпадают, или эти массивы не содержат значений.
Пример использования функции array_combine():

<?php$a = array("green", "red", "yellow");
$b = array("avocado", "apple", "banana");
$c = array_combine($a, $b);

print_r($c);
?>

Пример выведет следующее:

Array(
[green] => avocado
[red] => apple
[yellow] => banana
)

Функция поддерживается PHP 5

array_key_exists

Проверка существования заданного ключа в массиве.
Синтаксис:

bool array_key_exists(mixed key, array search)

Функция array_key_exists() возвратит TRUE, если в массиве search присутствует элемент с индексом key.
В противном случае возвратит FALSE.

Пример использования функции array_key_exists():

<?php$search_array = array("first" => 1, "second" => 4);
if (array_key_exists("first", $search_array)) {
echo "The <I>first</I> element is in the array";
}
?>

В PHP 4.0.6. имя этой функции key_exists().

Функция поддерживается PHP 4 >= 4.0.1, PHP 5

array_product()

Вычислить произведение значений массива (PHP 5 >= 5.1.0RC1)

Описание:

number array_product ( array array )

array_product() возвращает произведение значений массива как целое число или число с плавающей точкой.

Пример использования array_product()

<?php

$a = array(2, 4, 6, 8);
echo "product(a) = " . array_product($a) . "\n";

?>

Результат выполнения данного примера:

product(a) = 384

array_reduce()

Итеративно уменьшить массив к единственному значению, используя функцию обратного вызова (PHP 4 >= 4.0.5, PHP 5)

Описание:

mixed array_reduce ( array input, callback function [, int initial] )

array_reduce() итеративно применяет функцию function к элементам массива input и, таким образом, сводит массив к единственному значению. Если указан дополнительный параметр initial, он будет использован в начале процесса, или в качестве окончательного результата, если массив пуст.

Пример использованияarray_reduce()

<?php
function rsum($v, $w)
{
$v += $w;
return $v;
}

function rmul($v, $w)
{
$v *= $w;
return $v;
}

$a = array(1, 2, 3, 4, 5);
$x = array();
$b = array_reduce($a, "rsum");
$c = array_reduce($a, "rmul", 10);
$d = array_reduce($x, "rsum", 1);
?>

В результате переменная $b содержит 15, $c содержит 1200 (= 1*2*3*4*5*10), и $d содержит 1.

array_walk_recursive()

Рекурсивно применить пользовательскую функцию к каждому элементу массива (PHP 5)

Описание:

bool array_walk_recursive ( array &input, callback funcname [, mixed userdata] )

Применяет пользовательскую функцию funcname к каждому элементу массива input. Эта функция обрабатывает каждый элемент многомерного массива. Обычно у функции funcname два параметра. Значение массива array в качестве первого параметра, и ключ/индекс в качестве второго. Если указан дополнительный параметр userdata, он будет передан в качестве третьего параметра в функцию обратного вызова funcname.

Возвращает TRUE в случае успешного завершения или FALSE в случае возникновения ошибки.

Замечание: Если требуется, чтобы функция funcname изменила значения в массиве, определите первый параметр funcname как ссылку. Тогда все изменения будут применены к элементам массива.

Пример использования array_walk_recursive()

<?php
$sweet = array('a' => 'apple', 'b' => 'banana');
$fruits = array('sweet' => $sweet, 'sour' => 'lemon');

function test_print($item, $key)
{
echo "$key holds $item\n";
}

array_walk_recursive($fruits, 'test_print');
?>

Вывод вышеприведённой программы:

a holds apple
b holds banana
sour holds lemon

Обратите внимание, что ключ 'sweet' никогда не отображается. Никакой ключ, соответствующий значению типа array, не будет передан в функцию.

array_keys

Возвращает список из ключей массива.
Синтаксис:

array array_keys(array arr [,mixed search_value])

Функция возвращает массив, значениями которого являются все строковые и числовые ключи массива arr. Если задан необязательный параметр search_value, то она вернет только те ключи, которым соответствуют значению search_value.
Пример испольльзования функции array_keys():

<?php$arr = array(0 => 100, "color" => "red", 15);
print_r(array_keys($arr));

$arr = array("blue", "red", "green", "blue", "blue");
print_r(array_keys($arr, "blue"));

$array = array ("color" => array("blue", "red", "green"), "size" => array("small", "medium", "large"));
print_r(array_keys ($array));
?>

Приведенный выше пример выведет следующее:

Array(
[0] => 0
[1] => color
)
Array(
[0] => 0
[1] => 3
[2] => 4
)
Array(
[0] => color
[1] => size
)

Функция array_keys() появилась в PHP 4.

Ее эквивалент для PHP 3:

function array_keys ($arr, $term="") {
$t = array();
while (list($k,$v) = each($arr)) {
if ($term && $v != $term) {
continue;
}
$t[] = $k;
}
return $t;
}

Функция поддерживается PHP 4, PHP 5

array_values

Удаление ассоциативных индексов массива.
Синтаксис:

array array_values(array arr)

Функция array_values() возвращает список всех значений в ассоциативном массиве arr. При этом она заменяет все строковые ключи на числовые.
Пример использования функции array_values():

$arr = array("size" => "XL", "color" => "gold");
print_r(array_values($arr));

Этот пример выведет:

Array(
[0] => XL
[1] => gold
)

Функция поддерживается PHP 4, PHP 5

in_array

Осуществляет проверку массива на наличие значения.
Синтаксис:

bool in_array ( mixed needle, array haystack [, bool strict])

Функция in_array() возвратит TRUE, если в массиве haystack содержится элемент со значением needle, и FALSE в противном случае.
Если установить третий необязательный параметр strict в значение TRUE, то функция in_array() при проверке также будет сравнивать типы значений.
Замечание: Если параметр needle является строкой, то при сравнении регистр символов учитывается.
Замечание: В PHP версии ниже 4.2.0 параметр needle не мог быть массивом.
Пример использования функции in_array():

<?php$os = array("Mac", "NT", "Irix", "Linux");
if (in_array("Irix", $os)) {
echo "Got Irix";
}
if (in_array("mac", $os)) {
echo "Got mac";
}
?>

Второе условие не сработает, т.к. поиск в массиве идет с учетом регистра.
Пример выведет:

Got Irix

Пример использования функции in_array(): Использование параметра strict

<?php$a = array(array("p", "h"), array("p", "r"), "o");

if (in_array(array("p", "h"), $a)) {
echo "ph was foundn";
}

if (in_array(array("f", "i"), $a)) {
echo "fi was foundn";
}

if (in_array("o", $a)) {
echo "o was foundn";
}
?>

Пример выведет:

ph was found
o was found

Функция поддерживается PHP 4, PHP 5

array_count_values

Возвращает количество значений массива.
Синтаксис:

array array_count_values(array arr) 

Эта функция подсчитывает, сколько раз каждое значение встречается в массиве arr, и возвращает ассоциативный массив с ключами -
элементами массива и значениями - количеством повторов этих элементов. Иными словами, функция array_count_values()
подсчитывает частоту появления значений в массиве arr.
Пример использования функции array_count_values():

$arr = array(1, "hello", 1, "world", "hello");
print_r(array_count_values($arr));

Пример выведет следующее:

Array(
[1] => 2
[hello] => 2
[world] => 1
)

Функция поддерживается PHP 4, PHP 5

sizeof

Возвращает число элементов массива.
Синтаксис:

int sizeof(array arr)

Функция sizeof() возвращает количество элементов в массиве arr на подобие действия функции count().

count

Возвращает число элементов в массиве или объекте.
Синтаксис:

int count(mixed var [, int mode])

Функция count() возвращает число элементов в массиве или объекте var. В случае, если var - скалярная переменная, то функция возвращает 1, если такая переменная существует, или 0, если такой переменной нет.
Надо отметить, что 0 возвращается и тогда, когда указан массив, не содержащий элементов (NULL).

Если задан необязательный параметр mode, то будет подсчитано общее количество элементов в массиве. Это может быть полезно при нахождении количества элементов в многомерных массивах.
Пример использования функции count():

<?php$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
$result = count($a);
// $result == 3

$b[0] = 7;
$b[5] = 9;
$b[10] = 11;
$result = count($b);
// $result == 3;
?>

Пример использования функции count(): (PHP >= 4.2.0)

<?php$food = array("fruits" => array("orange", "banana", "apple"),
"veggie" => array("carrot", "collard", "pea"));

// recursive countecho count($food, COUNT_RECURSIVE); // выведет 8

// normal countecho count($food); // выведет 2
?>

Функция поддерживается PHP 3, PHP 4, PHP 5

array_sum

Возвращает сумму всех элементов массива.
Синтаксис:

mixed array_sum(array arr)

Функция array_sum() возвращает сумму всех числовых элементов массива. От типа значений в массиве зависит тип возвращаемого числа (integer или float).

Пример использования функции array_sum():

<?php$a = array(2, 4, 6, 8);
echo "sum(a) = " . array_sum($a) . "<BR>";

$b = array("a" => 1.2, "b" => 2.3, "c" => 3.4);
echo "sum(b) = " . array_sum($b) . "<BR>";
?>

Этот пример выведет следующее:

sum(a) = 20
sum(b) = 6.9

Функция поддерживается PHP 4 >=4.0.4, PHP 5

array_rand

Производит случайную выборку индексов массива.
Синтаксис:

mixed array_rand(array arr [, int num_req])

Функция array_rand() будет полезной, если вы хотите выбрать одно или несколько случайных значений из массива. Эта функция возвращает в массиве выбранные случайным образом индексы элементов массива arr.
Аргумент num_req указывает число возвращаемых индексов. В случае, если выбирается один элемент, то функция array_rand() возвратит случайный ключ в виде значения.
Пример использования функции array_rand():

<?phpsrand((double)microtime() *1000000);
// здесь мы проинициализировали генератор случайных чисел
//$arr = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
$rand_keys = array_rand($arr, 2);
echo $arr[$rand_keys[0]]."<BR>";
echo $arr[$rand_keys[1]]."<BR>";
?>

Функция поддерживается PHP 4, PHP 5

array_diff

Определение исключительного пересечения массивов.
Синтаксис:

array array_diff(array arr1, array arr2 [, array ...])

Данная функция возвращает массив, который содержит значения, имеющиеся только в массиве arr1 ( и не имеющиеся в любых других).
При этом индексы сохраняются.

$arr1 = array("a" => "green", "red", "blue", "red");
$arr2 = array("b" => "green", "yellow", "red");
$result = array_diff($arr1, $arr2);
// $result = array("blue")

Повторение одного и того же значения "red" в массиве arr1 обрабатывается как одно значение.
Стоит отметить, что два элемента считаются одинаковыми, только если их строковое представление идентично. Т.е. (string) $elem1 === (string) $elem2.

Также стоит отметить, что данная функция корректно обрабатывает только одно измерение N-мерного массива. Если есть необходимость обрабатывать более глубокие уровни вложенности, можно использовать конструкцию array_diff($arr1[0], $arr2[0]);.

Функция поддерживается PHP 4 >= 4.0.1, PHP 5

array_merge_recursive

Рекурсивное слияние сложных массивов.
Синтаксис:

array array_merge_recursive(array arr1, array arr2 [, array ...])

Функция array_merge_recursive() объединяет элементы массивов, переданных в ее параметрах таким образом, что значения одного массива присоединяются к значениям предудущих.
Функция возвращает массив, состоящий из объединенных массивов.
Если массивы, переданные в параметрах этой функции, имеют одинаковые строковые ключи, тогда значения, соответствующие этим ключам, сливаются в один массив. При этом если одно из значений само является массивом, то оно будет слито с соответствующим значением в другом массиве.
Но если в массивах присутствуют одинаковые числовые ключи, то тогда значение такого ключа, упомянутое последним, не заменит исходное значение, а будет слито с ним.
Пример использования функции array_merge_recursive():

<?php$arr1 = array("color" => array("favorite" =>"red"), 5);
$arr2 = array(10, "color" => array("favorite" =>"green", "blue"));
$result = array_merge_recursive($arr1, $arr2);
print_r($result_;
?>

Пример выведет:

Array(
[color] => Array
(
[favorite] => Array
(
[0] => red
[1] => green
)

[0] => blue
)

[0] => 5
[1] => 10
)

Функция поддерживается PHP 4 >=, PHP 5

array_diff_key()

Вычислить расхождение в массивах, сравнивая ключи (PHP 5 >= 5.1.0RC1)

Описание:

array array_diff_key ( array array1, array array2 [, array ...] )

array_diff_key() возвращает массив, содержащий все значения array1, имеющие ключи, не содержащиеся в последующих параметрах. Обратите внимание, что ассоциации сохраняются. Эта функция схожа с array_diff() за исключением того, что сравниваются ключи, а не значения.

Пример использования array_diff_key()

<?php
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);

var_dump(array_diff_key($array1, $array2));
?>

Результат выполнения данного примера:

array(2) {
["red"]=>
int(2)
["purple"]=>
int(4)
}

Два ключа пар key => value считаются равными только, если (string) $key1 === (string) $key2 . Другими словами, строгая проверка считает, что строковое представление должно быть идентичным.

Замечание: Обратите внимание, что эта функция обрабатывает только одно измерение n-размерного массива. Естественно, вы можете обрабатывать и более глубокие уровни вложенности, например, используя array_diff_key($array1[0], $array2[0]);.

array_diff_ukey()

Вычислить расхождение в массивах, используя функцию обратного вызова для сравнения ключей (PHP 5 >= 5.1.0RC1)

Описание:

array array_diff_ukey ( array array1, array array2 [, array ..., callback key_compare_func] )

array_diff_ukey() возвращает массив, содержащий все значения array1, имеющие ключи, не содержащиеся в последующих параметрах. Обратите внимание, что ассоциации сохраняются. Эта функция схожа с array_diff() за исключением того, что сравниваются ключи, а не значения.

Для сравнения используется функция, определённая пользователем. Она должна возвращать целое число меньшее, равное или большее нуля, если первый ключ, соответственно, меньше, равен или больше второго.

Пример использования array_diff_ukey()

<?php
function key_compare_func($key1, $key2)
{
if ($key1 == $key2)
return 0;
else if ($key1 > $key2)
return 1;
else
return -1;
}

$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);

var_dump(array_diff_ukey($array1, $array2, 'key_compare_func'));
?>

Результат выполнения данного примера:

array(2) {
["red"]=>
int(2)
["purple"]=>
int(4)
}

Замечание: Обратите внимание, что эта функция обрабатывает только одно измерение n-размерного массива. Естественно, вы можете обрабатывать и более глубокие уровни вложенности, например, используя array_diff_ukey($array1[0], $array2[0], 'callback_func');.

array_intersect_key()

Вычислить пересечение массивов, сравнивая ключи (PHP 5 >= 5.1.0RC1)

Описание:

array array_intersect_key ( array array1, array array2 [, array ...] )

array_intersect_key() возвращает массив, содержащий значения array1, имеющие ключи, содержащиеся во всех последующих параметрах..

Пример использования array_intersect_key()

<?php
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);

var_dump(array_intersect_key($array1, $array2));
?>

Результат выполнения данного примера:

array(2) {
["blue"]=>
int(1)
["green"]=>
int(3)
})

В нашем примере только ключи 'blue' и 'green' содержатся в обоих массивах и поэтому возвращаются. Также обратите внимание, что значения, соответствующие ключам 'blue' и 'green' различны в исходных массивах. Совпадение происходит, так как сравниваются только ключи. Возвращаемые значения берутся из array1.

Два ключа пар key => value считаются равными только, если (string) $key1 === (string) $key2 . Другими словами, строгая проверка считает, что строковое представление должно быть идентичным.

array_intersect_uassoc()

Вычислить пересечение массивов с дополнительной проверкой индекса, осуществляемой при помощи функции, определённой пользователем (PHP 5)

Описание:

array array_intersect_uassoc ( array array1, array array2 [, array ..., callback key_compare_func] )

array_intersect_uassoc() возвращает массив, содержащий значения array1, содержащиеся во всех последующих параметрах. Обратите внимание, что в отличие от array_intersect(), для сравнения используются ключи.

Для сравнения используется функция, определённая пользователем. Она должна возвращать целое число меньшее, равное или большее нуля, если первый параметр, соответственно, меньше, равен или больше второго.

Пример использования array_intersect_uassoc()

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");

print_r(array_intersect_uassoc($array1, $array2, "strcasecmp"));
?>

Результат выполнения данного примера:

Array
(
[b] => brown
)

array_intersect_ukey()

Вычислить пересечение массивов, используя функцию обратного вызова для сравнения ключей (PHP 5 >= 5.1.0RC1)

Описание:

array array_intersect_ukey ( array array1, array array2 [, array ..., callback key_compare_func] )

array_intersect_ukey() возвращает массив, содержащий значения array1, имеющие ключи, содержащиеся во всех последующих параметрах.

Для сравнения используется функция, определённая пользователем. Она должна возвращать целое число меньшее, равное или большее нуля, если первый ключ, соответственно, меньше, равен или больше второго.

Пример использования array_intersect_ukey()

<?php
function key_compare_func($key1, $key2)
{
if ($key1 == $key2)
return 0;
else if ($key1 > $key2)
return 1;
else
return -1;
}

$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);

var_dump(array_intersect_ukey($array1, $array2, 'key_compare_func'));
?>

Результат выполнения данного примера:

array(2) {
["blue"]=>
int(1)
["green"]=>
int(3)
})

В нашем примере только ключи 'blue' и 'green' содержатся в обоих массивах и поэтому возвращаются. Также обратите внимание, что значения, соответствующие ключам 'blue' и 'green' различны в исходных массивах. Совпадение происходит, так как сравниваются только ключи. Возвращаемые значения берутся из array1.

array_uintersect_assoc()

Вычислить пересечение массивов с дополнительной проверкой индексов, используя для сравнения значений функцию обратного вызова (PHP 5)

Описание:

array array_uintersect_assoc ( array array1, array array2 [, array ..., callback data_compare_func] )

array_uintersect_assoc() возвращает массив, содержащий все значения array1 присутствующие во всех последующих аргументах. Обратите внимание, что при сравнении используются ключи в отличие от array_uintersect(). Значения сравниваются при помощи функции обратного вызова.

Пример использования array_uintersect_assoc()

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");

print_r(array_uintersect_assoc($array1, $array2, "strcasecmp"));
?>

Результат выполнения данного примера:

Array
(
[a] => green
)

Для сравнения используется функция, определённая пользователем. Она должна возвращать целое число меньшее, равное или большее нуля, если первый параметр, соответственно, должен считаться меньше, равен или больше второго.

array_uintersect_uassoc()

Вычислить пересечение массивов с дополнительной проверкой индекса, используя для сравнения индексов и значений функцию обратного вызова (PHP 5)

Описание:

array array_uintersect_uassoc ( array array1, array array2 
[, array ..., callback data_compare_func, callback key_compare_func] )

array_uintersect_uassoc() возвращает массив, содержащий все значения параметра array1, содержащиеся во всех последующих аргументах. Обратите внимание, что в отличие от array_uintersect() в сравнении используются и ключи. Для сравнения и ключей, и значений используется функция обратного вызова.

Пример использования array_uintersect_uassoc()

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");

print_r(array_uintersect_uassoc($array1, $array2, "strcasecmp", "strcasecmp"));
?>

Результат выполнения данного примера:

Array
(
[a] => green
[b] => brown
)

Для сравнения используется функция, определённая пользователем. Она должна возвращать целое число меньшее, равное или большее нуля, если первый параметр, соответственно, должен считаться меньше, равен или больше второго.

array_uintersect()

Вычислить пересечение массивов, используя для сравнения значений функцию обратного вызова (PHP 5)

Описание:

array array_uintersect ( array array1, array array2 [, array ..., callback data_compare_func] )

array_uintersect() возвращает массив, содержащий все значения параметра array1 присутствующие во всех последующих аргументах. Значения сравниваются при помощи функции обратного вызова.

Пример использования array_uintersect()

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");

print_r(array_uintersect($array1, $array2, "strcasecmp"));
?>

Результат выполнения данного примера:

Array
(
[a] => green
[b] => brown
[0] => red
)

Для сравнения используется функция, определённая пользователем. Она должна возвращать целое число меньшее, равное или большее нуля, если первый параметр, соответственно, должен считаться меньше, равен или больше второго.

array_diff_assoc

Определение исключительного пересечения массивов с учетом индексов массивов.
Синтаксис:

array array_diff_assoc(array arr1, array arr2 [, array ...])

Данная функция возвращает массив, который содержит значения, имеющиеся только в массиве arr1 ( и не имеющиеся в любых других).
Обратите внимание, что в отличии от функции array_diff(), при сравнении учитываются ключи.
Пример использования array_diff_assoc():

<?php$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>

Пример выведет следующее:

Array(
[b] => brown
[c] => blue
[0] => red
)

В приведенном примере пара "a" => "green" присутствует в обоих массивах, поэтому она не вошла в результирующий массив. В отличие от этого, значение red присутствует в результирующем массиве, т.к. в первом массиве это значение имело ключ 0,
а во втором массиве оно имело ключ 1.

Две пары ключ => значение считаются равными, если они тождественны друг другу, т.е. (string) $elem1 === (string) $elem2.

Обратите внимание, что данная функция не позволяет напрямую сравнивать многомерные массивы. Хотя конечно можно сравнить вложенные массивы, используя, например, array_diff_assoc ($array1 [0], $array2 [0]);.

Функция поддерживается PHP 4 >=4.3.0, PHP 5

array_diff_uassoc

Определение различия между массивами при помощи пользовательской функции с дополнительной проверкой ключей массива.
Синтаксис:

array array_diff_uassoc(array arr1, array arr2 [, array ..., callback key_compare_func])

Функция array_diff_uassoc() возвращает массив, который содержит значения, имеющиеся только в массиве arr1 ( и не имеющиеся в любых других).

Обратите внимание, что в отличии от функции array_diff(), при сравнении учитываются ключи. Сделано это при помощи пользовательской функции key_compare_func. Эта функция должна возвращать целое число, которое должно быть меньше нуля, если первый переданный ей аргумент меньше чем второй, равное нулю, если первый аргумент равен второму, и больше нуля, если первый аргумент больше второго. Эта функция отличается от array_diff_assoc(), где сравнение значений и индексов происходит автоматически.
Пример использования array_diff_uassoc():

<?phpfunction key_compare_func($a, $b) 
{
if ($a === $b) {
return 0;
}
return ($a > $b)? 1:-1;
}

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_uassoc($array1, $array2, "key_compare_func");
?>

Пример выведет следующее:

Array(
[b] => brown
[c] => blue
[0] => red
)

В приведенном примере пара "a" => "green" присутствует в обоих массивах, поэтому она не вошла в результирующий массив. В отличие от этого, значение red присутствует в результирующем массиве, т.к. в первом массиве это значение имело ключ 0,
а во втором массиве оно имело ключ 1.

Равенство индексов проверяется пользовательской функцией.
Обратите внимание, что данная функция не позволяет напрямую сравнивать многомерные массивы. Хотя конечно можно сравнить вложенные массивы, используя, например, array_diff_uassoc ($array1[0], $array2[0], "key_compare_func");.

Функция поддерживается PHP 5

array_udiff

Сравнивает массивы используя пользовательскую функцию.
Синтаксис:

array array_udiff( array array1, array array2 [, array ..., callback data_compare_func])

Функция array_udiff() возвращает массив, содержащий все значения массива array1, которые не присутствуют в других массивах, переданных в параметрах.
Стоит отметить, что ключи значений сохраняются.
Для сравнения значений массивов используется пользовательская функция data_compare_func. Она возвращает число, большее нуля, равное нулю или меньшее нуля, если первый аргумент, переданные ей в виде параметра, больше, равен или меньше второго параметра соответственно. Это отличается от функции array_diff(),
где используется встроенная функция сравнения. Пример использования функции array_udiff_assoc():

<?phpclass cr {
private $priv_member;
function cr($val)
{
$this->priv_member = $val;
}

function comp_func_cr($a, $b)
{
if ($a->priv_member === $b->priv_member) return 0;
return ($a->priv_member > $b->priv_member)? 1:-1;
}
}
$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1=> new cr(4), 2 => new cr(-15),);
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1=> new cr(4), 2 => new cr(-15),);

$result = array_udiff($a, $b, array("cr", "comp_func_cr"));
print_r($result);
?>

Этот пример выведет следующее:

Array(
[0.5] => cr Object
(
[priv_member:private] => 12
)

[0] => cr Object
(
[priv_member:private] => 23
)

)

Два значения будут сочтены равными, только если (string) $elem1 === (string) $elem2 (т.е. когда строки содержат одно и тоже).

Стоит отметить, что данная функция в случае многомерного массива использует для сравнения одного измерение. Если вы хотите пройтись по всем измерениям, стоит использовать конструкцию array_udiff($array1[0], $array2[0], "data_compare_func");

Функция поддерживается PHP 5

array_udiff_assoc

Сравнивает массивы используя пользовательскую функцию.
Синтаксис:

array array_udiff_assoc( array array1, array array2 [, array ..., callback data_compare_func])

Функция array_udiff_assoc() возвращает массив, содержащий все значения массива array1, которые не присутствуют в других массивах, переданные в параметрах. Стоит отметить, что ключи значений используются при сравнении в отличии от функций array_diff() и array_udiff().

Для сравнения значений массивов используется пользовательская функция. Этим данная функция отличается от array_diff_assoc(), которая использует внутреннюю функции для сравнения.
Пример использования функции array_udiff_assoc():

<?phpclass cr {
private $priv_member;
function cr($val)
{
$this->priv_member = $val;
}

function comp_func_cr($a, $b)
{
if ($a->priv_member === $b->priv_member) return 0;
return ($a->priv_member > $b->priv_member)? 1:-1;
}
}

$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1=> new cr(4), 2 => new cr(-15),);
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1=> new cr(4), 2 => new cr(-15),);

$result = array_udiff_assoc($a, $b, array("cr", "comp_func_cr"));
print_r($result);
?>

Этот пример выведет следующее:

Array(
[0.1] => cr Object
(
[priv_member:private] => 9
)

[0.5] => cr Object
(
[priv_member:private] => 12
)

[0] => cr Object
(
[priv_member:private] => 23
)
)

В нашем примере пара 1=> new cr(4) присутствует в обеих массивах и по этому она не вошла в результирующий массив.
Для сравнения используется пользовательская функция. Она возвращает значение, меньшее нуля, равное нулю или большее нуля, если переданный ей первый параметр меньше второго, равен второму или больше второго соответственно.
Функция поддерживается PHP 5

array_udiff_uassoc

Сравнивает массивы используя пользовательскую функцию.
Синтаксис:

array array_udiff_uassoc(array array1,array array2
[, array...,callback data_compare_func,callback key_compare_func])

Функция array_udiff_uassoc() возвращает массив, содержащий все значения массива array1, которые не присутствуют в других массивах, переданные в параметрах. Стоит отметить, что ключи значений используются при сравнении в отличии от функций array_diff() и array_udiff().

Для сравнения значений массивов используется пользовательская функция data_compare_func. Этим данная функция отличается от array_diff_assoc(), которая использует внутреннюю функции для сравнения.
Сравнение ключей (индексов) происходит при помощи пользовательской функции key_compare_func. Этим данная функция отличается от array_udiff_assoc(), которая использует внутреннюю функции для сравнения.
Пример использования функции array_udiff_uassoc():

<?phpclass cr {
private $priv_member;
function cr($val)
{
$this->priv_member = $val;
}

function comp_func_cr($a, $b)
{
if ($a->priv_member === $b->priv_member) return 0;
return ($a->priv_member > $b->priv_member)? 1:-1;
}

function comp_func_key($a, $b)
{
if ($a === $b) return 0;
return ($a > $b)? 1:-1;
}
}
$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1=> new cr(4), 2 => new cr(-15),);
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1=> new cr(4), 2 => new cr(-15),);

$result = array_udiff_uassoc($a, $b, array("cr", "comp_func_cr"), array("cr", "comp_func_key"));
print_r($result);
?>

Этот пример выведет следующее:

Array(
[0.1] => cr Object
(
[priv_member:private] => 9
)

[0.5] => cr Object
(
[priv_member:private] => 12
)

[0] => cr Object
(
[priv_member:private] => 23
)
)

В нашем примере пара 1=> new cr(4) присутствует в обеих массивах и по этому она не вошла в результирующий массив.
Для сравнения используется пользовательская функция. Она возвращает значение, меньшее нуля, равное нулю или большее нуля, если переданный ей первый параметр меньше второго, равен второму или больше второго соответственно.
Функция поддерживается PHP 5

array_intersect

Определение включительного пересечения массивов.
Синтаксис:

array array_intersect(array arr1, array arr2 [, array ...])

Функция array_intersect() возвращает массив, который содержит значения массива arr1, имеющиеся во всех остальных массивах. При этом индексы сохраняются.
Пример использования функции array_intersect():

<?php$arr1 = array("a" => "green", "red", "blue");
$arr2 = array("b" => "green", "yellow", "red");
$result = array_intersect($arr1, $arr2);
print_r($result);
?>

Пример выведет:

Array(
[a] => green
[0] => red
)

Функция поддерживается PHP 4 >= 4.0.1, PHP 5

array_intersect_assoc

Функция возвращает пересечения значений массивов с сохранением индексов.
Синтаксис:

array array_intersect_assoc(array array1, array array2 [, array ...])

Функция array_intersect_assoc() возвращает массив, который содержит все значения array1, имеющиеся во всех остальных перечисленных массивах. В отличие от функции array_intersect() при сравнении ключи учитываются.
Пример использования функции array_intersect_assoc():

<?php$array1 = array("a" => "яблоко", "b" => "груша", "c" => "дыня", "слива");
$array2 = array("a" => "яблоко", "апельсин", "слива");
$result_array = array_intersect_assoc($array1, $array2);
?>

Пример выведет следующее:

Array(
[a] => яблоко
)

Приведенный пример вывел только значение [a] => яблоко, т.к. это значение присутствовало и в первом и во втором массиве.
Значение дыня не выведено, т.к. в первом массиве у него был индекс 0, а во втором - 1

Функция поддерживается PHP 4 >= 4.3.0, PHP 5

array_merge

Слияние массивов.
Синтаксис:

array array_merge(array arr1, array arr2 [, array ...])

Функция array_merge() призвана устранить все недостатки, присущие оператору + для слияния массивов. А именно, она сливает массивы, перечисленные в ее аргументах, в оди большой массив и возвращает результат. Т.е. значени одного массива присоединяются к значениям предыдущего.
Если в массивах встречаются одинаковые строковые ключи, то тогда значения, принадлежащие этим ключам, сливаются в один массив таким образом, чтобы если одно из значений в свою очередь является массивом, функция array_merge() сливает его с соответствующим значением в другом массиве.
Однако это не затрагивает числовые ключи: элементы с такими ключами помещаются в конец результирующего массива в любом случае.
Пример использования функции array_merge():

<?php$array1 = array ("color" => "red", 2, 4);
$array2 = array ("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge ($array1, $array2);
print_r($result);
?>

Пример выведет следующее:

Array(
[color] => green
[0] => 2
[1] => 4
[2] => a
[3] => b
[shape] => trapezoid
[4] => 4
)

Другой пример использования функции array_merge():

<?php$array1 = array();
$array2 = array(1 => "data");
$result = array_merge($array1, $array2);
print_r($result);
?>

Пример выведет следующее:

Array(
[0] => data
)

Стоит отметить, что числовые ключи были потеряны.
Если есть необходимость просто слить массивы вместе, используйте оператор +

<?php$array1 = array();
$array2 = array(1 => "data");
$result = $array1 + $array2;
print_r($result);
?>

Пример выведет следующее:

Array(
[1] => data
)

Функция поддерживается PHP 4, PHP 5

array_slice

Получение части массива.
Синтаксис:

array array_slice(array arr, int offset [, int lenght])

Функция array_slice() возвращает часть ассоциативного массива arr, начиная с элемента со смещением (номером) offset от начала и длиной lenght (если последний параметр не задан, до конца массива).

Параметры offset и lenght задаются по точно таким же правилам, как и аналогичные параметры в функции substr().
А именно, если offset>0, то последовательность будет начинаться с элемента, имеющего позицию offset от начала массива, а если <0, то отсчет производится от конца массива. Надо отметить, что первый элемент имеет нулевую позицию, а последний (-1).

Если указать length>0, то это число возвращаемых в массиве элементов, а если length<0, то это позиция последнего возвращаемого элемента в массиве arr от его конца.
Пример использования функции array_slice():

<?php$input = array("a", "b", "c", "d", "e");
$output = array_slice($input, 2); // "c", "d", "e"
$output = array_slice($input, 2, -1); // "c", "d"
$output = array_slice($input, -2, 1); // "d"
$output = array_slice($input, 0, 3); // "a", "b", "c"
?>

Функция поддерживается PHP 4, PHP 5

array_splice

Удаляет часть массива или заменяет ее частью другого массива.
Синтаксис:

array array_splice(array arr, int offset [, int lenght [, int replacement]])

Функция array_splice(), также как и array_slice(), возвращает подмасcив arr начиная с индекса offset максимальной длины lenght, но, вместе с тем, она делает и другое полезное действие. А именно, она заменяет только что указанные элементы на то, что находится в массиве replacement (или просто удаляет, если replacement не указан).

Если offset>0, то последовательность будет начинаться с элемента, имеющего позицию offset от начала массива, а если <0,
то отсчет производится от конца массива. Надо отметить, что первый элемент имеет нулевую позицию, а последний (-1).

Если указать length>0, то это число возвращаемых в массиве элементов, а если length<0, то это позиция последнего возвращаемого элемента в массиве arr от его конца.
В качестве примера укажем следующие эквивалентыне замены:

array_push($input, $x, $y)     array_splice($input, count($input), 0, array($x, $y))
array_pop($input) array_splice($input, -1)
array_shift($input) array_splice($input, -1)
array_unshift($input, $x, $y) array_splice($input, 0, 0, array($x, $y))
$a[$x] = $y array_splice($input, $x, 1, $y)

Пример использования функции array_splice():

<?php$input = array("red", "green", "blue", "yellow");
array_splice($input, 2);
// $input is now array("red", "green")

$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, -1);
// $input is now array("red", "yellow")

$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, count($input), "orange");
// $input is now array("red", "orange")

$input = array("red", "green", "blue", "yellow");
array_splice($input, -1, 1, array("black", "maroon"));
// $input is now array("red", "green",
// "blue", "black", "maroon")

$input = array("red", "green", "blue", "yellow");
array_splice($input, 3, 0, "purple");
// $input is now array("red", "green",
// "blue", "purple", "yellow");
?>

Функция поддерживается PHP 4, PHP 5

array_pad

Добавляет в массив несколько элементов.
Синтаксис:

array array_pad(array input, int pad_size, mixed pad_value)

Функция array_pad() возвращает копию массива input, в который были добавлены элементы с значениями pad_value, так, что число элементов в получившемся массиве будет равно pad_size.
Если pad_size>0, то элементы будут добавлены в конец массива, а если <0 - то в начало.
В случае, если значение pad_size меньше элементов в исходном массиве input, то никакого добавления не произойдет, и функция вернет исходный массив input.
Пример использования функции array_pad():

$arr = array(12, 10, 4);
$result = array_pad($arr, 5, 0);
// $result = array(12, 10, 4, 0, 0);
$result = array_pad($arr, -7, -1);
// $result = array(-1, -1, -1, -1, 12, 10, 4)
$result = array_pad($arr, 2, "noop");
// не добавит

Функция поддерживается PHP 4, PHP 5

array_map

Применение пользовательской функции ко всем элементам указанных массивов.
Синтаксис:

array array_map(mixed callback, array arr1 [, array ...])

Функция array_map() возвращает массив, который содержит элементы всех указанных массивов после обработки пользовательской функцией callback.
Количество параметров, передаваемых пользовательской функции, должно совпадать с количеством массивов, переданных функции array_map().

Пример испольльзования функции array_map(): Обработка одного массива

<?phpfunction cube($n) {
return $n*$n*$n;
}
$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);
?>

Приведенный пример выведет следующее:

Array(
[0] => 1
[1] => 8
[2] => 27
[3] => 64
[4] => 125
)

Пример испольльзования функции array_map(): Обработка нескольких массивов

<?phpfunction show_Spanish($n, $m) {
return "Число $n по-испански - $m";
}
function map_Spanish($n, $m) {
return array ($n => $m);
}

$a = array(1, 2, 3, 4, 5);
$b = array("uno", "dos", "tres", "cuatro", "cinco");
$c = array_map("show_Spanish", $a, $b);
print_r($c);

$d = array_map("map_Spanish", $a , $b);
print_r($d);
?>

Приведенный пример выведет следующее:

// printout of $cArray(
[0] => Число 1 по-испански - uno
[1] => Число 2 по-испански - dos
[2] => Число 3 по-испански - tres
[3] => Число 4 по-испански - cuatro
[4] => Число 5 по-испански - cinco
)

// printout of $dArray(
[0] => Array
(
[1] => uno
)

[1] => Array
(
[2] => dos
)

[2] => Array
(
[3] => tres
)

[3] => Array
(
[4] => cuatro
)

[4] => Array
(
[5] => cinco
)

)

Обычно функцию array_map() применяют к массивам, имеющим одинаковую размерность. Если массивы имеют разную длину, то меньшие из них дополняются элементами с пустыми значениями.
Следует отметить, что если вместо имени обрабатывающей функции задать null, то будет создан массив массивов.
Пример испольльзования функции array_map(): Создание массива массивов

<?php$a = array(1, 2, 3, 4, 5);
$b = array("one", "two", "three", "four", "five");
$c = array("uno", "dos", "tres", "cuatro", "cinco");
$d = array_map(null, $a, $b, $c);
print_r($d);
?>

Приведенный пример выведет следующее:

Array(
[0] => Array
(
[0] => 1
[1] => one
[2] => uno
)

[1] => Array
(
[0] => 2
[1] => two
[2] => dos
)

[2] => Array
(
[0] => 3
[1] => three
[2] => tres
)

[3] => Array
(
[0] => 4
[1] => four
[2] => cuatro
)

[4] => Array
(
[0] => 5
[1] => five
[2] => cinco
)

)

Функция поддерживается PHP 4 >= 4.0.6, PHP 5

array_pop

Извлекает и удаляет последние элементы массива.
Синтаксис:

mixed array_pop(array arr); 

Функция array_pop() извлекает последний элемент из массива arr и возвращает его, удалив после этого. С помощью этой функции мы можем строить конструкции, напоминающие стек. Если массив arr был пуст, или это не массив, функция возвращает пустую строку NULL.

После использования функции array_pop() курсор массива устанавливается в начало.
Пример использования функции array_pop():

<?php$stack = array("orange", "apple", "raspberry");
$fruits = array_pop($stack);
print_r($stack);
print_r($fruits);
?>

Пример выведет следующее:

Array(
[0] => orange
[1] => banana
[2] => apple
)

Функция поддерживается PHP 4, PHP 5

array_push

Добавляет один или несколько элементов в конец массива.
Синтаксис:

int array_push(array arr, mixed var1 [, mixed var2, ..])

Функция array_push() добавляет к массиву arr элементы var1, var2 и т.д. Она присваивает им числовые индексы - точно так же, как это происходит для стандартных [].
Если вам нужно добавить всего один элемент, наверное, проще будет воспользоваться этим оператором:

array_push($Arr,1000);     // вызываем функцию$Arr[]=100;                // то же самое, но короче

Пример использования функции array_push():

<?php$stack = array("orange", "banana");
array_push($stack, "apple", "raspberry");
print_r($stack);
?>

Пример выведет следующее:

Array(
[0] => orange
[1] => banana
[2] => apple
[3] => raspberry
)

Обратите внимание, что функция array_push() воспринимает массив, как стек, и добавляет элементы всегда в его конец.
Функция поддерживается PHP 4, PHP 5

array_shift

Извлекает и удаляет первый элемент массива.
Синтаксис:

mixed array_shift(array arr)

Функция array_shift() извлекает первый элемент массива arr и возвращает его. Она сильно напоминает array_pop(),
но только получает начальный, а не конечный элемент, а также производит довольно сильную "встряску" всего массива: ведь при извлечении первого элемента приходится корректировать все числовые индексы у всех оставшихся элементов, т.к. все последующие элементы массива сдвигаются на одну позицию вперед. Строковые ключи массива не изменяются.
Если массив arr пустой или он не является массивом, функция возвращает NULL.

После использования этой функции указатель массива становится в начало.
Пример использования функции array_shift():

<?php$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_shift($stack);
print_r($stack);
?>

Данный пример выведет следующее:

Array(
[0] => banana
[1] => apple
[2] => raspberry
)

а переменная $fruit будет иметь значение "orange"

Функция поддерживается PHP 4, PHP 5

array_unshift

Добавляет одно или несколько значений в начало массива.
Синтаксис:

int array_unshift(list arr, mixed var1 [,mixed var2, ...])

Функция array_unshift() добавляет переданные значения var в начало массива arr. Порядок расположения новых элементов в массиве сохраняется. Все цифровые индексы массива будут изменены таким образом, чтобы она начинались с нуля. Все строковые индексы массива не изменяются.
Функция возвращает новое количество элементов в массиве.
Пример использования функции array_unshift():

<?php$queue = array("orange", "banana");
array_unshift($queue, "apple", "raspberry");
?>

Теперь переменная $queue будет иметь следующие элементы:

Array(
[0] => apple
[1] => raspberry
[2] => orange
[3] => banana
)

Функция поддерживается PHP 4, PHP 5

array_unique

Удаляет дублирующие значения в массиве.
Синтаксис:

array array_unique(array arr)

Функция array_unique() возвращает массив, составленный из всех уникальных значений массива arr вместе с их ключами, путем удаления всех дублирующих значений. В результирующий массив помещаются первые встретившиеся пары ключ=>значение. Индексы сохраняются.
Пример использования функции array_unique():

<?php$input = array("a" => "green", "red", "b" => 
"green", "blue", "red");
$result = array_unique($input);
print_r($result);
?>

Пример выведет следующее:

Array(
[a] => green
[0] => red
[1] => blue
)

Пример использования функции array_unique(): Сравнение типов данных

<?php$input = array(4, "4", "3", 4, 3, "3");
$result = array_unique($input);
var_dump($result);
?>

Пример выведет следующее:

array(2) {
[0] => int(4)
[2] => string(1) "3"
}

Функция поддерживается PHP 4 >= 4.0.1, PHP 5

array_chunk

Функция разбивает массив на части.
Синтаксис:

array array_chunk(array arr, int size [, bool preserve_keys])

Функция array_chunk() разбивает исходный массив arr на несколько массивов, длина которых задается числом size. Если размерность исходного массива не делится ровно на size частей, то последний массив будет иметь меньшую размерность.
Функция array_chunk() возвращает многомерный массив, индексами которого начинаются от 0 и до кол-ва полученных массивов, а значения - полученные в результате разбивки массивы.
Необязательный параметр preserve_keys указывает, стоит ли сохранять ключи исходного массива или нет. Если этот параметр равен false (значение по умолчанию), то индексы полученных массивов будут заданы числами начиная с нуля. Если же параметр равен true, то ключи исходного массива сохраняются.
Пример использования функции array_chunk():

$array = array("1-ый элемент",
"2-ой элемент",
"3-ий элемент",
"4-ый элемент",
"5-ый элемент");
print_r(array_chunk($array, 2));
print_r(array_chunk($array, 2, TRUE));

Пример выведет следующее:

Array(
[0] => Array
(
[0] => 1-ый элемент
[1] => 2-ой элемент
)

[1] => Array
(
[0] => 3-ий элемент
[1] => 4-ый элемент
)

[2] => Array
(
[0] => 5-ый элемент
)

)
Array(
[0] => Array
(
[0] => 1-ый элемент
[1] => 2-ой элемент
)

[1] => Array
(
[2] => 3-ий элемент
[3] => 4-ый элемент
)

[2] => Array
(
[4] => 5-ый элемент
)

)

Функция поддерживается PHP 4 >= 4.2.0, PHP 5

array_fill

Функция заполняет массив определенными значениями.
Синтаксис:

array array_fill(int start_index, int num, mixed value)

Функция array_fill() возвращает массив, который содержит значения, указанные в параметре value размерностью num начиная с элемента, указанного в параметре start_index.
Пример использования array_diff_uassoc():

<?php$a = array_fill(5, 6, 'banana'); 
print_r($a);
?>

Пример выведет следующее:

Array(
[5] => banana
[6] => banana
[7] => banana
[8] => banana
[9] => banana
[10] => banana
)

Функция поддерживается PHP 4 >= 4.2.0, PHP 5

array_filter

Функция применяет фильтр к массиву, используя пользовательскую функцию.
Синтаксис:

array array_filter(array input [, callback callback])

Функция array_filter() возвращает массив, который содержит значения, имеющиеся в массиве input отфильтрованные в соответсвтии с результатами работы пользовательской функции callback.
В случае, если исходный массив input является ассоциативным массивом, в результирующем массиве индексы сохраняются.
Пример использования функции array_filter():

<?phpfunction odd($var) {
return ($var % 2 == 1);
}

function even($var) {
return ($var % 2 == 0);
}

$array1 = array ("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array (6, 7, 8, 9, 10, 11, 12);
echo "Нечетные :n";
print_r(array_filter($array1, "odd"));
echo "Четные :n";
t_r(array_filter($array2, "even"));
?>

Пример выведет следующее:

Нечетные :Array(
[a] => 1
[c] => 3
[e] => 5
)
Четные :Array(
[0] => 6
[2] => 8
[4] => 10
[6] => 12
)

Стоит отметить, что вместо имени фильтрующей функции можно указать массив, который содержит ссылку на объект и имя метода.
Также стоит отметить, что при обработке массива фукцией array_filter() его нельзя изменять: добавлять, удалять элементы или обнулять массив, т.к. это может привести к некоррекстной работе функции.
Функция поддерживается PHP 4 >= 4.0.6, PHP 5

list

Заносит элементы массива в переменные.
Синтаксис:

void list ( mixed ...)

Наподобие array(), функция list() не совсем функция, а языковая конструкция. Она используется для формирования списка переменных.
Замечание: list() работает только с цифровыми индексами массива и принимает ключи элементов начиная с 0.

Пример использования функции list():

$info = array("coffee", "brown", "caffeine");

// Выведем все переменныеlist($drink, $color, $power) = $info;
echo "$drink is $color and $power makes it special.n";

// Выведем первый и последнийlist($drink, , $power) = $info;
echo "$drink has $power.n";

// Выведем только третийlist( , , $power) = $info;
echo "I need $power!n";
?>

Пример использования функции list():

<table>
<tr>
<th>Employee name</th>
<th>Salary</th>
<tr>
<th>
<?php

$result = mysql_query("SELECT id, name, salary FROM employees", $conn);
while (list($id, $name, $salary) = mysql_fetch_row($result)) {
echo " n" .
" $namen" .
" $salaryn" .
" n";
}
?>
</th>
</tr>
</table>

Пример использования функции list(): Индексы

<?php$info = array("coffee", "brown", "caffeine");
list($a[0], $a[1], $a[2]) = $info;
var_dump($a);
?>

array(3) {
[2]=>
string(8) "caffeine"
[1]=>
string(5) "brown"
[0]=>
string(6) "coffee"
}

Функция поддерживается PHP 3, PHP 4, PHP 5

compact

Упаковывает в массив переменные из текущего контекста.
Синтаксис:

array compact(mixed varname1 [, mixed $varname2, ...])

Функция compact() упаковывает в массив переменные из текущего контекста (глобального или контекста функции), заданные своими именами в varname1, $varname2 и т.д. При этом в массиве образуются пары с ключами, равными содержимому varnameN,
и значениями соответствующих переменных.
Число аргументов может быть неопределенное.
Если в аргументе указано имя несуществующей переменной, он пропускается. Действие этой функции противоположно функции extract().

Пример использования функции compact():

<?php$city  = "San Francisco";
$state = "CA";
$event = "SIGGRAPH";

$location_vars = array("city", "state");

$result = compact("event", "nothing_here", $location_vars);
?>

В результате выполнения кода переменная $result имеет значение:

Array(
[event] => SIGGRAPH
[city] => San Francisco
[state] => CA
)

Почему же тогда параметры функции обозначены как mixed? Дело в том, что они могут быть не только строками, но и списками строк. В этом случае функция последнего перебирает все элементы этого списка, и упаковывает те переменные из текущего контекста, имена которых она встретила. Более того - эти списки могут, в свою очередь, также содержать списки строк, и т.д. Правда, последнее используется достаточно редко.
Пример использования функции compact():

<?php$a="Test";
$b="Text";
$c="CCC";
$d="DDD";
$List=array("b",array("c","d"));
$A=compact("a",$List);
?>

Теперь:

// теперь $A===array("a"=>"Test", "b"=>"Text", 
"c"=>"CCC", "d"=>"DDD")

Функция поддерживается PHP 4, PHP 5

extract

Импорт элементов массива в переменные.
Синтаксис:

int extract (array var_array [, int extract_type [, string prefix]])

Функция extract() используется для импортирования значений массива в строку. Эта функция берет ассоциативный массив var_array, использую ключ элемента как имя переменной, а значение элемента как значение полученной переменной. Для создания переменных из пары ключ =>
значение можно также использовать необязательные параметры extract_type и prefix.
Замечание: начиная с PHP версии 4.0.5 эта функция возвращала количество извлеченных переменных.
Функция extract() проверяет, действительно ли каждый ключ массива может быть названием переменной. Она также проверяет на наличие одинаковых названий получаемых переменных. В случае, если обнаруживаются недействительные или числовые ключи, поведение функции предопределяет параметр extract_type, который может принимать следующие значения:
EXTR_OVERWRITE

Если переменная с таким именем уже существует, то ее значение будет заменено (значение по умолчанию).

EXTR_SKIP

Если переменная с таким именем уже существует, то ее значение не будет заменено.
EXTR_PREFIX_SAME

Если переменная с таким именем уже существует, то к ее имени добавится префикс, определенный в параметре prefix.
EXTR_PREFIX_ALL

Ко всем образуемым переменным будет добавлен префикс prefix.
EXTR_PREFIX_INVALID

Только при неправильных или числовых индексах массива к имени переменной будет добавлен префикс prefix.
EXTR_IF_EXISTS

Если переменная с таким именем уже существует, то ее значение будет переписано. Иначе ничего не сделает. Это может быть полезно, если вы задали список всех переменных, а затем хотите извлечь только те переменные, которые были определены, например, из $_REQUEST. Этот флаг был добавлен в PHP 4.2.0

EXTR_PREFIX_IF_EXISTS

Создает переменные с префиксом, если такие переменные без префикса уже существовали. В любом другом случае ничего не создает. Этот флаг был добавлен в PHP 4.2.0

EXTR_REFS

Переменные создаются как ссылки. Это означает, что созданные переменные все еще ссылаются на значения соответствующих элементов массива var_array. Вы можете применять этот флаг как в одиночку, так и совместно с другими флагами. Этот флаг был добавлен в PHP 4.3.0

Пример использования функции extract():

<?php
/* Предположим, что $var_array массив,
полученный при помощи функции wddx_deserialize */

$size = "large";
$var_array = array("color" => "blue",
"size" => "medium",
"shape" => "sphere");
extract($var_array, EXTR_PREFIX_SAME, "wddx");

echo "$color, $size, $shape, $wddx_sizen";
?>

Пример выведет:

blue, large, sphere, medium

Здесь переменная $size не была переписана, т.к. мы указали параметр EXTR_PREFIX_SAME.
Если указать EXTR_SKIP, тогда переменная $wddx_size даже не была бы создана. Если указать EXTR_OVERWRITE, то переменная $size имела бы значение "medium".
Если EXTR_PREFIX_ALL - то в результате были бы созданы переменные $wddx_color, $wddx_size, и $wddx_shape.
Лучше всего использовать ассоциативные массивы. Массивы с цифровыми ключами не могут быть использованы в этой функции, если установлены флаги EXTR_PREFIX_ALL или EXTR_PREFIX_INVALID.

Функция поддерживается PHP 3 >= 3.0.7, PHP 4, PHP 5

array_search()

Осуществляет поиск данного значения в массиве и возвращает соответствующий ключ в случае удачи (PHP 4 >= 4.0.5, PHP 5)

Описание:

mixed array_search ( mixed needle, array haystack [, bool strict] )

Ищет в haystack значение needle и возвращает ключ, если таковое присутствует в массиве, FALSE в противном случае.

Замечание: Если needle является строкой, производится регистро-зависимое сравнение.

Замечание: До PHP 4.2.0, array_search() при неудаче возвращала NULL вместо FALSE.

Если вы передадите значение TRUE в качестве необязательного третьего параметра strict, функция array_search() также проверит тип needle в массиве haystack.

Если needle присутствует в haystack более одного раза, будет возвращён первый найденный ключ. Для того, чтобы возвратить ключи для всех найденных значений, используйте функцию array_keys() с необязательным параметром search_value.

Пример использования array_search()

<?php
$array = array(0 => 'blue', 1 => 'red', 2 => 0x000000, 3 => 'green', 4 => 'red');

$key = array_search('red', $array); // $key = 1;
$key = array_search('green', $array); // $key = 2; (0x000000 == 0 == 'green')
$key = array_search('green', $array, true); // $key = 3;
?>

Внимание

Эта функция может возвращать как логическое значение FALSE, так и не относящееся к логическому типу значение, которое приводится к FALSE, например, 0 или "". За более подробной информации обратитесь к разделу Булев тип. Используйте оператор === для проверки значения, возвращаемого этой функцией.