Php массив без ключей

array_keys — Выбрать все ключи массива

Описание array array_keys ( array input [, mixed значение_для_поиска] )

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

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

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

$array = array (0 => 100, "color" => "red"); print_r(array_keys ($array));

$array = array ("blue", "red", "green", "blue", "blue");
print_r(array_keys ($array, "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 )

Замечание: Эта функция появилась в PHP 4. Ниже приведен ее эквивалент для PHP 3.

Пример 2. Эквивалент функции array_keys() в PHP 3

(PHP 4, PHP 5, PHP 7)

array_keys — Возвращает все или некоторое подмножество ключей массива

Описание

Функция array_keys() возвращает числовые и строковые ключи, содержащиеся в массиве array .

Если указан параметр search_value , функция возвращает ключи у которых значения элементов массива совпадают с этим параметром. В обратном случае, функция возвращает все ключи массива array .

Список параметров

Массив, содержащий возвращаемые ключи.

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

Определяет использование строгой проверки на равенство (===) при поиске.

Возвращаемые значения

Возвращает массив со всеми ключами array .

Примеры

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

= array( 0 => 100 , "color" => "red" );
print_r ( array_keys ( $array ));

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

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

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

Смотрите также

• array_values() — Выбирает все значения массива
• array_combine() — Создает новый массив, используя один массив в качестве ключей, а другой для его значений
• array_key_exists() — Проверяет, присутствует ли в массиве указанный ключ или индекс
• array_search() — Осуществляет поиск данного значения в массиве и возвращает ключ первого найденного элемента в случае удачи

User Contributed Notes 27 notes

It’s worth noting that if you have keys that are long integer, such as ‘329462291595’, they will be considered as such on a 64bits system, but will be of type string on a 32 bits system.

for example:
= array( ‘329462291595’ => null , ‘ZZ291595’ => null );

foreach( array_keys ( $importantKeys ) as $key ) <
echo gettype ( $key ). "
" ;
>

?>

will return on a 64 bits system:

but on a 32 bits system:

I hope it will save someone the huge headache I had 🙂

Here’s how to get the first key, the last key, the first value or the last value of a (hash) array without explicitly copying nor altering the original array:

= array( ‘first’ => ‘111’ , ‘second’ => ‘222’ , ‘third’ => ‘333’ );

// get the first key: returns ‘first’
print array_shift ( array_keys ( $array ));

// get the last key: returns ‘third’
print array_pop ( array_keys ( $array ));

// get the first value: returns ‘111’
print array_shift ( array_values ( $array ));

// get the last value: returns ‘333’
print array_pop ( array_values ( $array ));
?>

Since 5.4 STRICT standards dictate that you cannot wrap array_keys in a function like array_shift that attempts to reference the array.

Invalid:
echo array_shift( array_keys( array(‘a’ => ‘apple’) ) );

Valid:
$keys = array_keys( array(‘a’ => ‘apple’) );
echo array_shift( $keys );

But Wait! Since PHP (currently) allows you to break a reference by wrapping a variable in parentheses, you can currently use:

echo array_shift( ( array_keys( array(‘a’ => ‘apple’) ) ) );

However I would expect in time the PHP team will modify the rules of parentheses.

It is worth noting that array_keys does not maintain the data-type of the keys when mapping them to a new array. This created an issue with in_array and doing a lookup on characters from a string. NOTE: my lookup $array has a full map of numbers and characters — upper and lower — to do an simple faux encryption with.

= array(
‘e’ => ‘ieio’
, ‘1’ => ‘one’
, ‘2’ => ‘two’
, ‘0’ => ‘zero’
);
var_dump ( $array );
$keys = array_keys ( $array );
var_dump ( $keys );

$string = ‘1e0’ ;
for ( $i = 0 ; $i strlen ( $string ); $i ++) <
if ( in_array ( $string [ $i ], $keys , ‘strict’ )) echo ‘dude ‘ ;
else echo ‘sweet ‘ ;
>
?>

Outputs:
array (size=4)
‘e’ => string ‘ieio’ (length=4)
1 => string ‘one’ (length=3)
2 => string ‘two’ (length=3)
0 => string ‘zero’ (length=4)

array (size=4)
0 => string ‘e’ (length=1)
1 => int 1
2 => int 2
3 => int 0

sweet dude sweet

—-
expected to see:
dude dude dude

There’s a lot of multidimensional array_keys function out there, but each of them only merges all the keys in one flat array.

Here’s a way to find all the keys from a multidimensional array while keeping the array structure. An optional MAXIMUM DEPTH parameter can be set for testing purpose in case of very large arrays.

NOTE: If the sub element isn’t an array, it will be ignore.

function array_keys_recursive ( $myArray , $MAXDEPTH = INF , $depth = 0 , $arrayKeys = array()) <
if( $depth $MAXDEPTH ) <
$depth ++;
$keys = array_keys ( $myArray );
foreach( $keys as $key ) <
if( is_array ( $myArray [ $key ])) <
$arrayKeys [ $key ] = array_keys_recursive ( $myArray [ $key ], $MAXDEPTH , $depth );
>
>
>

return $arrayKeys ;
>
?>

EXAMPLE:
input:
array(
‘Player’ => array(
‘id’ => ‘4’,
‘state’ => ‘active’,
),
‘LevelSimulation’ => array(
‘id’ => ‘1’,
‘simulation_id’ => ‘1’,
‘level_id’ => ‘1’,
‘Level’ => array(
‘id’ => ‘1’,
‘city_id’ => ‘8’,
‘City’ => array(
‘id’ => ‘8’,
‘class’ => ‘home’,
)
)
),
‘User’ => array(
‘id’ => ’48’,
‘gender’ => ‘M’,
‘group’ => ‘user’,
‘username’ => ‘Hello’
)
)

output:
array(
‘Player’ => array(),
‘LevelSimulation’ => array(
‘Level’ => array(
‘City’ => array()
)
),
‘User’ => array()
)

If an array is empty (but defined), or the $search_value is not found in the array, an empty array is returned (not false, null, or -1). This may seem intuitive, especially given the documentation says an array is returned, but I needed to sanity test to be sure:

= array();
var_dump ( array_keys ( $emptyArray , 99 )); // array (size=0) empty

$filledArray = array( 11 , 22 , 33 , 42 );
var_dump ( array_keys ( $filledArray , 99 )); // array (size=0) empty

На самом деле массив в PHP — это упорядоченное отображение, которое устанавливает соответствие между значением и ключом. Этот тип оптимизирован в нескольких направлениях, поэтому вы можете использовать его как собственно массив, список (вектор), хэш-таблицу (являющуюся реализацией карты), словарь, коллекцию, стэк, очередь и, возможно, что-то еще. Так как значением массива может быть другой массив PHP, можно также создавать деревья и многомерные массивы.

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

Синтаксис

Определение при помощи array()

Массив (тип array ) может быть создан языковой конструкцией array() . В качестве параметров она принимает любое количество разделенных запятыми пар key => value (ключ => значение).

Запятая после последнего элемента массива необязательна и может быть опущена. Обычно это делается для однострочных массивов, то есть array(1, 2) предпочтительней array(1, 2, ). Для многострочных массивов с другой стороны обычно используется завершающая запятая, так как позволяет легче добавлять новые элементы в конец массива.

Начиная с PHP 5.4 возможно использовать короткий синтаксис определения массивов, который заменяет языковую конструкцию array() на [].

Пример #1 Простой массив

// Начиная с PHP 5.4
$array = [
"foo" => "bar" ,
"bar" => "foo" ,
];
?>

key может быть либо типа integer , либо типа string . value может быть любого типа.

Дополнительно с ключом key будут сделаны следующие преобразования:

• Строки, содержащие целое число (исключая случаи, когда число предваряется знаком +) будут преобразованы к типу integer . Например, ключ со значением "8" будет в действительности сохранен со значением 8. С другой стороны, значение "08" не будет преобразовано, так как оно не является корректным десятичным целым.
• Числа с плавающей точкой (тип float ) также будут преобразованы к типу integer , то есть дробная часть будет отброшена. Например, ключ со значением 8.7 будет в действительности сохранен со значением 8.
• Тип bool также преобразовываются к типу integer . Например, ключ со значением true будет сохранен со значением 1 и ключ со значением false будет сохранен со значением .
• Тип null будет преобразован к пустой строке. Например, ключ со значением null будет в действительности сохранен со значением "".
• Массивы (тип array ) и объекты (тип object ) не могут использоваться в качестве ключей. При подобном использовании будет генерироваться предупреждение: Недопустимый тип смещения (Illegal offset type).

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

Пример #2 Пример преобразования типов и перезаписи элементов

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

Так как все ключи в вышеприведенном примере преобразуются к 1, значение будет перезаписано на каждый новый элемент и останется только последнее присвоенное значение "d".

Массивы в PHP могут содержать ключи типов integer и string одновременно, так как PHP не делает различия между индексированными и ассоциативными массивами.

Пример #3 Смешанные ключи типов integer и string

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

Параметр key является необязательным. Если он не указан, PHP будет использовать предыдущее наибольшее значение ключа типа integer , увеличенное на 1.

Пример #4 Индексированные массивы без ключа

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

Возможно указать ключ только для некоторых элементов и пропустить для других:

Пример #5 Ключи для некоторых элементов

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

Как вы видите последнее значение "d" было присвоено ключу 7. Это произошло потому, что самое большое значение ключа целого типа перед этим было 6.

Доступ к элементам массива с помощью квадратных скобок

Доступ к элементам массива может быть осуществлен с помощью синтаксиса array[key].

Пример #6 Доступ к элементам массива

= array(
"foo" => "bar" ,
42 => 24 ,
"multi" => array(
"dimensional" => array(
"array" => "foo"
)
)
);

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

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

И квадратные и фигурные скобки можно взаимозаменяемо использовать для доступа к элементам массива (то есть и $array[42] и $array равнозначны).

С PHP 5.4 стало возможным прямое разыменование массива, возвращаемого в качестве результата вызова функции или метода. Раньше приходилось использовать временные переменные.

С PHP 5.5 возможно разыменовывать массив буквально.

Пример #7 Разыменование массива

function getArray () <
return array( 1 , 2 , 3 );
>

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

// ранее делали так
$tmp = getArray ();
$secondElement = $tmp [ 1 ];

// или так
list(, $secondElement ) = getArray ();
?>

Попытка доступа к неопределенному ключу в массиве — это то же самое, что и попытка доступа к любой другой неопределенной переменной: будет сгенерирована ошибка уровня E_NOTICE , и результат будет NULL .

Массив, разыменовывающий скалярное значение, которое не является типом ( string ), отдаст NULL без какого-либо оповещения об ошибке.

Создание/модификация с помощью синтаксиса квадратных скобок

Существующий массив может быть изменен путем явной установкой значений в нем.

Это выполняется присвоением значений массиву ( array ) с указанием в скобках ключа. Кроме того, ключ можно опустить, в результате получится пустая пара скобок ([]).

Если массив $arr еще не существует, он будет создан. Таким образом, это еще один способ определить массив array . Однако такой способ применять не рекомендуется, так как если переменная $arr уже содержит некоторое значение (например, значение типа string из переменной запроса), то это значение останется на месте и [] может на самом деле означать доступ к символу в строке. Лучше инициализировать переменную путем явного присваивания значения.

Замечание: Начиная с PHP 7.1.0, используя в оператор "пустой индекс" на строке, приведет к фатальной ошибке. Ранее, в этом случае, строка молча преобразовывалась в массив.

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

= array( 5 => 1 , 12 => 2 );

$arr [] = 56 ; // В этом месте скрипта это
// то же самое, что и $arr[13] = 56;

$arr [ "x" ] = 42 ; // Это добавляет к массиву новый
// элемент с ключом "x"

unset( $arr [ 5 ]); // Это удаляет элемент из массива

unset( $arr ); // Это удаляет массив полностью
?>

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

Учтите, что максимальное целое значение ключа не обязательно существует в массиве в данный момент. Оно могло просто существовать в массиве какое-то время, с тех пор как он был переиндексирован в последний раз. Следующий пример это иллюстрирует:

// Создаем простой массив.
$array = array( 1 , 2 , 3 , 4 , 5 );
print_r ( $array );

// Теперь удаляем каждый элемент, но сам массив оставляем нетронутым:
foreach ( $array as $i => $value ) <
unset( $array [ $i ]);
>
print_r ( $array );

// Добавляем элемент (обратите внимание, что новым ключом будет 5, вместо 0).
$array [] = 6 ;
print_r ( $array );

// Переиндексация:
$array = array_values ( $array );
$array [] = 7 ;
print_r ( $array );
?>

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

Полезные функции

Для работы с массивами существует достаточное количество полезных функций. Смотрите раздел функции для работы с массивами.

Функция unset() позволяет удалять ключи массива. Обратите внимание, что массив НЕ будет переиндексирован. Если вы действительно хотите поведения в стиле "удалить и сдвинуть", можно переиндексировать массив используя array_values() .

= array( 1 => ‘один’ , 2 => ‘два’ , 3 => ‘три’ );
unset( $a [ 2 ]);
/* даст массив, представленный так:
$a = array(1 => ‘один’, 3 => ‘три’);
а НЕ так:
$a = array(1 => ‘один’, 2 => ‘три’);
*/

$b = array_values ( $a );
// Теперь $b это array(0 => ‘один’, 1 => ‘три’)
?>

Управляющая конструкция foreach существует специально для массивов. Она предоставляет возможность легко пройтись по массиву.

Что можно и нельзя делать с массивами

Почему $foo[bar] неверно?

Всегда заключайте в кавычки строковый литерал в индексе ассоциативного массива. К примеру, пишите $foo[‘bar’], а не $foo[bar]. Но почему? Часто в старых скриптах можно встретить следующий синтаксис:

Это неверно, хотя и работает. Причина в том, что этот код содержит неопределенную константу (bar), а не строку (‘bar’ — обратите внимание на кавычки). Это работает, потому что PHP автоматически преобразует "голую строку" (не заключенную в кавычки строку, которая не соответствует ни одному из известных символов языка) в строку со значением этой "голой строки". Например, если константа с именем bar не определена, то PHP заменит bar на строку ‘bar’ и использует ее.

Замечание: Это не означает, что нужно всегда заключать ключ в кавычки. Нет необходимости заключать в кавычки константы или переменные, поскольку это помешает PHP обрабатывать их.

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

Дополнительные примеры, демонстрирующие этот факт:

// Показываем все ошибки
error_reporting ( E_ALL );

$arr = array( ‘fruit’ => ‘apple’ , ‘veggie’ => ‘carrot’ );

// Верно
print $arr [ ‘fruit’ ]; // apple
print $arr [ ‘veggie’ ]; // carrot

// Неверно. Это работает, но из-за неопределенной константы с
// именем fruit также вызывает ошибку PHP уровня E_NOTICE
//
// Notice: Use of undefined constant fruit — assumed ‘fruit’ in.
print $arr [ fruit ]; // apple

// Давайте определим константу, чтобы продемонстрировать, что
// происходит. Мы присвоим константе с именем fruit значение ‘veggie’.
define ( ‘fruit’ , ‘veggie’ );

// Теперь обратите внимание на разницу
print $arr [ ‘fruit’ ]; // apple
print $arr [ fruit ]; // carrot

// Внутри строки это нормально. Внутри строк константы не
// рассматриваются, так что ошибки E_NOTICE здесь не произойдет
print "Hello $arr [ fruit ] " ; // Hello apple

// С одним исключением: фигурные скобки вокруг массивов внутри
// строк позволяют константам там находиться
print "Hello < $arr [ fruit ]>" ; // Hello carrot
print "Hello < $arr [ ‘fruit’ ]>" ; // Hello apple

// Это не будет работать и вызовет ошибку обработки, такую как:
// Parse error: parse error, expecting T_STRING’ or T_VARIABLE’ or T_NUM_STRING’
// Это, конечно, также действует и с суперглобальными переменными в строках
print "Hello $arr [ ‘fruit’]" ;
print "Hello $_GET [ ‘foo’]" ;

// Еще одна возможность — конкатенация
print "Hello " . $arr [ ‘fruit’ ]; // Hello apple
?>

Если вы переведете error_reporting в режим отображения ошибок уровня E_NOTICE (например, такой как E_ALL ), вы сразу увидите эти ошибки. По умолчанию error_reporting установлена их не отображать.

Как указано в разделе синтаксис, внутри квадратных скобок (‘[‘ и ‘]‘) должно быть выражение. Это означает, что можно писать вот так:

Это пример использования возвращаемого функцией значения в качестве индекса массива. PHP известны также и константы:

Обратите внимание, что E_ERROR — это такой же верный идентификатор, как и bar в первом примере. Но последний пример по сути эквивалентен такой записи:

поскольку E_ERROR соответствует 1 и т.д.

Так что же в этом плохого?

Когда-нибудь в будущем команда разработчиков PHP возможно пожелает добавить еще одну константу или ключевое слово, либо константа из другого кода может вмешаться и тогда у вас могут возникнуть проблемы. Например, вы уже не можете использовать таким образом слова empty и default, поскольку они являются зарезервированными ключевыми словами.

Замечание: Повторим, внутри строки ( string ), заключенной в двойные кавычки, корректно не окружать индексы массива кавычками, поэтому "$foo[bar]" является верной записью. Более подробно почему — смотрите вышеприведенные примеры, а также раздел по обработке переменных в строках.

Преобразование в массив

Для любого из типов integer , float , string , boolean и resource , преобразование значения в массив дает результатом массив с одним элементом (с индексом 0), являющимся скалярным значением, с которого вы начали. Другими словами, (array)$scalarValue — это точно то же самое, что и array($scalarValue).

Если вы преобразуете в массив объект ( object ), вы получите в качестве элементов массива свойства (переменные-члены) этого объекта. Ключами будут имена переменных-членов, с некоторыми примечательными исключениями: целочисленные свойства станут недоступны; к закрытым полям класса (private) спереди будет дописано имя класса; к защищенным полям класса (protected) спереди будет добавлен символ ‘*’. Эти добавленные значения с обоих сторон также имеют нулевые байты. Это может вызвать несколько неожиданное поведение:

class A <
private $A ; // Это станет ‘AA’
>

class B extends A <
private $A ; // Это станет ‘BA’
public $AA ; // Это станет ‘AA’
>

var_dump ((array) new B ());
?>

Вышеприведенный код покажет 2 ключа с именем ‘AA’, хотя один из них на самом деле имеет имя ‘AA’.

Если вы преобразуете в массив значение NULL , вы получите пустой массив.

Сравнение

Массивы можно сравнивать при помощи функции array_diff() и операторов массивов.

Примеры

Тип массив в PHP является очень гибким, вот несколько примеров:

// это
$a = array( ‘color’ => ‘red’ ,
‘taste’ => ‘sweet’ ,
‘shape’ => ’round’ ,
‘name’ => ‘apple’ ,
4 // ключом будет 0
);

$b = array( ‘a’ , ‘b’ , ‘c’ );

// . . .полностью соответствует
$a = array();
$a [ ‘color’ ] = ‘red’ ;
$a [ ‘taste’ ] = ‘sweet’ ;
$a [ ‘shape’ ] = ’round’ ;
$a [ ‘name’ ] = ‘apple’ ;
$a [] = 4 ; // ключом будет 0

// после выполнения этого кода, $a будет массивом
// array(‘color’ => ‘red’, ‘taste’ => ‘sweet’, ‘shape’ => ’round’,
// ‘name’ => ‘apple’, 0 => 4), а $b будет
// array(0 => ‘a’, 1 => ‘b’, 2 => ‘c’), или просто array(‘a’, ‘b’, ‘c’).
?>

Пример #8 Использование array()

// Массив как карта (свойств)
$map = array( ‘version’ => 4 ,
‘OS’ => ‘Linux’ ,
‘lang’ => ‘english’ ,
‘short_tags’ => true
);

// исключительно числовые ключи
$array = array( 7 ,
8 ,
0 ,
156 ,
— 10
);
// это то же самое, что и array(0 => 7, 1 => 8, . )

$switching = array( 10 , // ключ = 0
5 => 6 ,
3 => 7 ,
‘a’ => 4 ,
11 , // ключ = 6 (максимальным числовым индексом было 5)
‘8’ => 2 , // ключ = 8 (число!)
’02’ => 77 , // ключ = ’02’
0 => 12 // значение 10 будет перезаписано на 12
);

// пустой массив
$empty = array();
?>

Пример #9 Коллекция

= array( ‘red’ , ‘blue’ , ‘green’ , ‘yellow’ );

foreach ( $colors as $color ) <
echo "Вам нравится $color ?
" ;
>

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

Изменение значений массива напрямую возможно путем передачи их по ссылке.

Пример #10 Изменение элемента в цикле

foreach ( $colors as & $color ) <
$color = strtoupper ( $color );
>
unset( $color ); /* это нужно для того, чтобы последующие записи в
$color не меняли последний элемент массива */

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

Следующий пример создает массив, начинающийся с единицы.

Пример #11 Индекс, начинающийся с единицы

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

Пример #12 Заполнение массива

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

Пример #13 Сортировка массива

Поскольку значение массива может быть чем угодно, им также может быть другой массив. Таким образом вы можете создавать рекурсивные и многомерные массивы.

Пример #14 Рекурсивные и многомерные массивы

= array ( "fruits" => array ( "a" => "апельсин" ,
"b" => "банан" ,
"c" => "яблоко"
),
"numbers" => array ( 1 ,
2 ,
3 ,
4 ,
5 ,
6
),
"holes" => array ( "первая" ,
5 => "вторая" ,
"третья"
)
);

// Несколько примеров доступа к значениям предыдущего массива
echo $fruits [ "holes" ][ 5 ]; // напечатает "вторая"
echo $fruits [ "fruits" ][ "a" ]; // напечатает "апельсин"
unset( $fruits [ "holes" ][ 0 ]); // удалит "первая"

// Создаст новый многомерный массив
$juices [ "apple" ][ "green" ] = "good" ;
?>

Обратите внимание, что при присваивании массива всегда происходит копирование значения. Чтобы скопировать массив по ссылке, вам нужно использовать оператор ссылки.

= array( 2 , 3 );
$arr2 = $arr1 ;
$arr2 [] = 4 ; // $arr2 изменился,
// $arr1 все еще array(2, 3)

$arr3 = & $arr1 ;
$arr3 [] = 4 ; // теперь $arr1 и $arr3 одинаковы
?>