Php массив key value
The foreach construct provides an easy way to iterate over arrays. foreach works only on arrays and objects, and will issue an error when you try to use it on a variable with a different data type or an uninitialized variable. There are two syntaxes:
foreach (iterable_expression as $value) statement foreach (iterable_expression as $key => $value) statement
The first form traverses the iterable given by iterable_expression . On each iteration, the value of the current element is assigned to $value .
The second form will additionally assign the current element’s key to the $key variable on each iteration.
Note that foreach does not modify the internal array pointer, which is used by functions such as current() and key() .
In order to be able to directly modify array elements within the loop precede $value with &. In that case the value will be assigned by reference.
$arr = array( 1 , 2 , 3 , 4 );
foreach ( $arr as & $value ) $value = $value * 2 ;
>
// $arr is now array(2, 4, 6, 8)
unset( $value ); // break the reference with the last element
?>
Reference of a $value and the last array element remain even after the foreach loop. It is recommended to destroy it by unset() . Otherwise you will experience the following behavior:
// without an unset($value), $value is still a reference to the last item: $arr[3]
foreach ( $arr as $key => $value ) // $arr[3] will be updated with each value from $arr.
echo » < $key >=> < $value >» ;
print_r ( $arr );
>
// . until ultimately the second-to-last value is copied onto the last value
// output:
// 0 => 2 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 2 )
// 1 => 4 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 4 )
// 2 => 6 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 6 )
// 3 => 6 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 6 )
?>
It is possible to iterate a constant array’s value by reference:
Note:
foreach does not support the ability to suppress error messages using @ .
Some more examples to demonstrate usage:
/* foreach example 1: value only */
foreach ( $a as $v ) echo «Current value of \$a: $v .\n» ;
>
/* foreach example 2: value (with its manual access notation printed for illustration) */
$i = 0 ; /* for illustrative purposes only */
foreach ( $a as $v ) echo «\$a[ $i ] => $v .\n» ;
$i ++;
>
/* foreach example 3: key and value */
$a = array(
«one» => 1 ,
«two» => 2 ,
«three» => 3 ,
«seventeen» => 17
);
foreach ( $a as $k => $v ) echo «\$a[ $k ] => $v .\n» ;
>
/* foreach example 4: multi-dimensional arrays */
$a = array();
$a [ 0 ][ 0 ] = «a» ;
$a [ 0 ][ 1 ] = «b» ;
$a [ 1 ][ 0 ] = «y» ;
$a [ 1 ][ 1 ] = «z» ;
foreach ( $a as $v1 ) foreach ( $v1 as $v2 ) echo » $v2 \n» ;
>
>
/* foreach example 5: dynamic arrays */
foreach (array( 1 , 2 , 3 , 4 , 5 ) as $v ) echo » $v \n» ;
>
?>
Unpacking nested arrays with list()
It is possible to iterate over an array of arrays and unpack the nested array into loop variables by providing a list() as the value.
foreach ( $array as list( $a , $b )) // $a contains the first element of the nested array,
// and $b contains the second element.
echo «A: $a ; B: $b \n» ;
>
?>
The above example will output:
You can provide fewer elements in the list() than there are in the nested array, in which case the leftover array values will be ignored:
foreach ( $array as list( $a )) // Note that there is no $b here.
echo » $a \n» ;
>
?>
The above example will output:
A notice will be generated if there aren’t enough array elements to fill the list() :
foreach ( $array as list( $a , $b , $c )) echo «A: $a ; B: $b ; C: $c \n» ;
>
?>
The above example will output:
Notice: Undefined offset: 2 in example.php on line 7 A: 1; B: 2; C: Notice: Undefined offset: 2 in example.php on line 7 A: 3; B: 4; C:
array_keys
Функция array_keys() возвращает числовые и строковые ключи, содержащиеся в массиве array .
Если указан параметр filter_value , функция возвращает ключи у которых значения элементов массива совпадают с этим параметром. В обратном случае, функция возвращает все ключи массива array .
Список параметров
Массив, содержащий возвращаемые ключи.
Если указано, будут возвращены только ключи у которых значения элементов массива совпадают с этим параметром.
Определяет использование строгой проверки на равенство (===) при поиске.
Возвращаемые значения
Возвращает массив со всеми ключами array .
Примеры
Пример #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 )
Смотрите также
- array_values() — Выбирает все значения массива
- array_combine() — Создаёт новый массив, используя один массив в качестве ключей, а другой для его значений
- array_key_exists() — Проверяет, присутствует ли в массиве указанный ключ или индекс
- array_search() — Осуществляет поиск данного значения в массиве и возвращает ключ первого найденного элемента в случае успешного выполнения
User Contributed Notes 28 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.
$importantKeys = array( ‘329462291595’ => null , ‘ZZ291595’ => null );
foreach( array_keys ( $importantKeys ) as $key ) echo gettype ( $key ). «\n» ;
>
?>
will return on a 64 bits system:
integer
string
?>
but on a 32 bits system:
string
string
?>
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 = 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 ));
?>
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()
)
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 = 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
—-
expected to see:
dude dude dude
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.
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:
$emptyArray = 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
# array_keys() also return the key if it’s boolean but the boolean will return as 1 or 0. It will return empty if get NULL value as key. Consider the following array:
$a = array(
«first_index» => «This is the first element» ,
true => 3 ,
false => 2 ,
4.5 => ‘Something’ ,
«08» => 5 ,
«8» => 6 ,
NULL => ‘Null key’
);
Array
(
[ 0 ] => first_index
[ 1 ] => 1
[ 2 ] => 0
[ 3 ] => 4
[ 4 ] => 08
[ 5 ] => 8
[ 6 ] =>
)
Keys from multi dimensional array to simple array
Want to traverse an multi dimensional array and get the keys back in a single dimensional array? This will do the trick:
foreach( $array as $key => $val ) $flattenedKeysArray [] = $key ;
if( is_array ( $val ))
array_walk_keys ( $val , $key , $flattenedKeysArray );
>
might be worth noting in the docs that not all associative (string) keys are a like, output of the follow bit of code demonstrates — might be a handy introduction to automatic typecasting in php for some people (and save a few headaches):
$r = array( «0» => «0» , «1» => «1» , «» => «2» , » » => «3» );
echo ‘how php sees this array: array(«0″=>»0″,»1″=>»1″,»» =>»2″,» «=>»3»)’ , «\n————\n» ;
var_dump ( $r ); print_r ( $r ); var_export ( $r );
echo «\n————\n» , ‘var_dump(«0″,»1″,»»,» «) = ‘ , «\n————\n» ;
var_dump ( «0» , «1» , «» , » » );
?>
OUTPUTS:
I wrote a function to get keys of arrays recursivelly.
function recursive_keys ( $input , $search_value = null )
$output = ( $search_value !== null ? array_keys ( $input , $search_value ) : array_keys ( $input )) ;
foreach( $input as $sub ) <
if( is_array ( $sub )) <
$output = ( $search_value !== null ? array_merge ( $output , recursive_keys ( $sub , $search_value )) : array_merge ( $output , recursive_keys ( $sub ))) ;
>
>
return $output ;
>
?>
I hope it will be usefull
Here’s a function I needed to collapse an array, in my case from a database query. It takes an array that contains key-value pairs and returns an array where they are actually the key and value.
function array_collapse ( $arr , $x , $y ) $carr = array();
while ( $el = current ( $arr )) $carr [ $el [ $x ] ] = $el [ $y ];
next ( $arr );
>
return $carr ;
>
?>
Example usage (pseudo-database code):
$query = db_query ( ‘SELECT name, value FROM properties’ );
$result = db_returnAll ( $query );
/* This will return an array like so:
[[‘name’ -> ‘color’, ‘value’ -> ‘blue’],
[‘name’ -> ‘style’, ‘value’ -> ‘wide-format’],
[‘name’ -> ‘weight’, ‘value’ -> 3.6],
[‘name’ -> ‘name’, ‘value’ -> ‘Waerdthing’]]
$propArr = array_collapse ( $result , ‘name’ , ‘value’ );
/* Now this array looks like:
[[‘color’ -> ‘blue’],
[‘style’ -> ‘wide-format’],
[‘weight’ -> 3.6],
[‘name’ -> ‘Waerdthing’],