Arrays

Introducción
Constantes predefinidas
Ordenamiento de arrays
Funciones de Arrays
- array — Crea un array
- array_all — Verifica si todos los elementos del array validan la función de retrollamada
- array_any — Verifica que al menos un elemento del array valide la función de retrollamada
- array_change_key_case — Cambia la casse de todas las claves de un array
- array_chunk — Divide un array en arrays de menor tamaño
- array_column — Devuelve los valores de una columna de un array de entrada
- array_combine — Crea un array a partir de otros dos arrays
- array_count_values — Cuenta las ocurrencias de cada valor distinto en un array
- array_diff — Calcula la diferencia entre arrays
- array_diff_assoc — Calcula la diferencia de dos arrays, teniendo en cuenta las claves
- array_diff_key — Calcula la diferencia de dos arrays utilizando las claves para la comparación
- array_diff_uassoc — Calcula la diferencia entre dos arrays asociativos, utilizando una función de retrollamada
- array_diff_ukey — Calcula la diferencia entre dos arrays utilizando una función de retrollamada sobre las claves para comparación
- array_fill — Rellena un array con un mismo valor
- array_fill_keys — Rellena un array con valores, especificando las claves
- array_filter — Filtra los elementos de un array mediante una función de retrollamada
- array_find — Devuelve el primer elemento que valida la función de retrollamada
- array_find_key — Devuelve la clave del primer elemento que valida la función de retrollamada
- array_flip — Reemplaza las claves por los valores, y los valores por las claves
- array_intersect — Calcula la intersección de arrays
- array_intersect_assoc — Calcula la intersección de dos arrays con pruebas sobre los índices
- array_intersect_key — Calcula la intersección de dos arrays utilizando las claves para la comparación
- array_intersect_uassoc — Calcula la intersección de dos arrays con pruebas en los índices, compara los índices utilizando una función de retrollamada
- array_intersect_ukey — Calcula la intersección de dos arrays utilizando una función de retrollamada sobre las claves para la comparación
- array_is_list — Verifica si un array dado es una lista
- array_key_exists — Verifica si una clave existe en un array
- array_key_first — Recupera la primera clave de un array
- array_key_last — Recupera la última clave de un array
- array_keys — Devuelve todas las claves o un conjunto de las claves de un array
- array_map — Aplica una función a los elementos de un array
- array_merge — Fusiona varios arrays en uno solo
- array_merge_recursive — Combina uno o varios arrays juntos, de manera recursiva
- array_multisort — Ordena los arrays multidimensionales
- array_pad — Completa un array con un valor hasta la longitud especificada
- array_pop — Desapila un elemento del final de un array
- array_product — Calcula el producto de los valores del array
- array_push — Apila uno o más elementos al final de un array
- array_rand — Toma una o varias claves, al azar en un array
- array_reduce — Reduce itérativemente un array
- array_replace — Sustituye los elementos de un array por los de otros arrays
- array_replace_recursive — Sustituye recursivamente en el primer array los elementos de los otros arrays proporcionados
- array_reverse — Invierte el orden de los elementos de un array
- array_search — Busca en un array la primera clave asociada al valor
- array_shift — Despila un elemento al principio de un array
- array_slice — Extrae una porción de array
- array_splice — Elimina y reemplaza una porción de array
- array_sum — Calcula la suma de los valores del array
- array_udiff — Calcula la diferencia entre dos arrays utilizando una función de retrollamada
- array_udiff_assoc — Calcula la diferencia entre arrays con verificación de índices, compara los datos con una función de retrollamada
- array_udiff_uassoc — Calcula la diferencia de dos arrays asociativos, compara los datos y los índices con una función de retrollamada
- array_uintersect — Calcula la intersección de dos arrays, compara los datos utilizando una función de retrollamada
- array_uintersect_assoc — Calcula la intersección de dos arrays con pruebas sobre el índice, compara los datos utilizando una función de retrollamada
- array_uintersect_uassoc — Calcula la intersección de dos arrays con pruebas en el índice, compara los datos y los índices de los dos arrays utilizando una función de retrollamada separada
- array_unique — Elimina los valores duplicados de un array
- array_unshift — Empila uno o más elementos al inicio de un array
- array_values — Devuelve todos los valores de un array
- array_walk — Ejecuta una función proporcionada por el usuario en cada uno de los elementos de un array
- array_walk_recursive — Aplica una función de retrollamada de manera recursiva a cada miembro de un array
- arsort — Ordena un array en orden descendente y conserva la asociación de los índices
- asort — Ordena un array en orden ascendente y conserva la asociación de los índices
- compact — Crea un array a partir de variables y su valor
- count — Cuenta todos los elementos de un array o en un objeto Countable
- current — Devuelve el elemento actual del array
- each — Devuelve cada par clave/valor de un array
- end — Posiciona el puntero del array al final del array
- extract — Importa las variables en la tabla de símbolos
- in_array — Indica si un valor pertenece a un array
- key — Devuelve una clave de un array asociativo
- key_exists — Alias de array_key_exists
- krsort — Ordena un array según las claves en orden descendente
- ksort — Ordena un array según las claves en orden ascendente
- list — Asigna variables como si fueran un array
- natcasesort — Ordena un array con el algoritmo de "orden natural" insensible a mayúsculas y minúsculas
- natsort — Ordena un array con el algoritmo de "orden natural"
- next — Avance el puntero interno de un array
- pos — Alias de current
- prev — Retrocede el puntero actual del array
- range — Crea un array que contiene un intervalo de elementos
- reset — Reinicia el puntero interno del array al principio
- rsort — Ordena un array en orden decreciente
- shuffle — Mezcla los elementos de un array
- sizeof — Alias de count
- sort — Ordena un array en orden creciente
- uasort — Ordena un array utilizando una función de retrollamada
- uksort — Ordena un array por sus claves utilizando una función de retrollamada
- usort — Ordena un array utilizando una función de comparación

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 9 notes

down

107

applegrew at rediffmail dot com ¶

16 years ago

For newbies like me.

Creating new arrays:-
//Creates a blank array.
$theVariable = array();

//Creates an array with elements.
$theVariable = array("A", "B", "C");

//Creating Associaive array.
$theVariable = array(1 => "http//google.com", 2=> "http://yahoo.com");

//Creating Associaive array with named keys
$theVariable = array("google" => "http//google.com", "yahoo"=> "http://yahoo.com");

Note:
New value can be added to the array as shown below.
$theVariable[] = "D";
$theVariable[] = "E";

down

Tyler Bannister ¶

15 years ago

To delete an individual array element use the unset function

For example:

<?PHP
    $arr = array( "A", "B", "C" );
    unset( $arr[1] );
    // now $arr = array( "A", "C" );
?>

Unlink is for deleting files.

down

macnimble at gmail dot com ¶

16 years ago

Converting a linear array (like a mysql record set) into a tree, or multi-dimensional array can be a real bugbear. Capitalizing on references in PHP, we can 'stack' an array in one pass, using one loop, like this:

<?php
# array_stack()
# Original idea from:
# http://www.ideashower.com/our_solutions/
#   create-a-parent-child-array-structure-in-one-pass/
function array_stack (&$a, $p = '@parent', $c = '@children')
{
  $l = $t = array();
  foreach ($a AS $key => $val):
    if (!$val[$p]) $t[$key] =& $l[$key];
    else $l[$val[$p]][$c][$key] =& $l[$key];
    $l[$key] = (array)$l[$key] + $val;
  endforeach;
  return $a = array('tree' => $t, 'leaf' => $l);
}

# Example:
$node = array();
$node[1] = array('@parent' => 0, 'title' => 'I am node 1.');
#     ^-----------------------v Link @parent value to key.
$node[2] = array('@parent' => 1, 'title' => 'I am node 2.');
$node[3] = array('@parent' => 2, 'title' => 'I am node 3.');
$node[4] = array('@parent' => 1, 'title' => 'I am node 4.');
$node[5] = array('@parent' => 4, 'title' => 'I am node 5.');

array_stack($node);

$node['leaf'][1]['title'] = 'I am node one.';
$node['leaf'][2]['title'] = 'I am node two.';
$node['leaf'][3]['title'] = 'I am node three.';
$node['leaf'][4]['title'] = 'I am node four.';
$node['leaf'][5]['title'] = 'I am node five.';

echo '<pre>',print_r($node['tree'],TRUE),'</pre>';
?>

Note that there's no parameter checking on the array value, but this is only to keep the function size small. One could easily a quick check in there to make sure the $a parameter was in fact an array.

Hope you find it useful. Huge thanks to Nate Weiner of IdeaShower.com for providing the original function I built on.

down

webmaster at infoproducts dot x10hosting dot com ¶

16 years ago

New value can also be added to the array as shown below.
$theVariable["google"] = "http//google.com";
or
$theVariable["1"] = "http//google.com";

down

dragos dot rusu at NOSPAM dot bytex dot ro ¶

15 years ago

If an array item is declared with key as NULL, array key will automatically be converted to empty string '', as follows:

<?php
$a = array(
    NULL => 'zero',
    1    => 'one',
    2    => 'two');

// This will show empty string for key associated with "zero" value
var_dump(array_keys($a));

// Array elements are shown
reset($a);
while( key($a) !== NULL )
{
  echo key($a) . ": ".current($a) . "<br>";// PHP_EOL
  next($a);
}

// Array elements are not shown
reset($a);
while( key($a) != NULL ) // '' == null   => no iteration will be executed
{
  echo key($a) . ": ".current($a) . "<br>";// PHP_EOL
  next($a);
}

down

sunear at gmail dot com ¶

15 years ago

Made this function to delete elements in an array;



<?php



function array_del_elm($input_array, $del_indexes) {

    if (is_array($del_indexes)) {

        $indexes = $del_indexes;

    } elseif(is_string($del_indexes)) {

        $indexes = explode($del_indexes, " ");

    } elseif(is_numeric($del_indexes)) {

        $indexes[0] = (integer)$del_indexes;

    } else return;

    $del_indexes = null;

    

    $cur_index = 0;

    if (sort($indexes)) for($i=0; $i<count($input_array); $i++) {

        if ($i == $indexes[$cur_index]) {

            $cur_index++;

            if ($cur_index == count($indexes)) return $output_array;

            continue;

        }

        $output_array[] = $input_array[$i];

    }

    return $output_array;

}



?>



but then i saw the methods of doing the same by Tyler Bannister & Paul, could see that theirs were faster, but had floors regarding deleting multiple elements thus support of several ways of giving parameters. I combined the two methods to this to this:



<?php



function array_del_elm($target_array, $del_indexes) {

    if (is_array($del_indexes)) {

        $indexes = $del_indexes;

    } elseif(is_string($del_indexes)) {

        $indexes = explode($del_indexes, " ");

    } elseif(is_numeric($del_indexes)) {

        $indexes[0] = (integer)$del_indexes;

    } else return;

    unset($del_indexes);

    

    for($i=0; $i<count($indexes); $i++) {

        unset($target_array[$indexes[$i]]);

    }

    return $target_array;

}



?>



Fast, compliant and functional ;)

down

-2

andyd273 at gmail dot com ¶

16 years ago

A small correction to Endel Dreyer's PHP array to javascript array function. I just changed it to show keys correctly:

            function array2js($array,$show_keys)
            {
                $dimensoes = array();
                $valores = array();
               
                $total = count ($array)-1;
                $i=0;
                foreach($array as $key=>$value){
                    if (is_array($value)) {
                        $dimensoes[$i] = array2js($value,$show_keys);
                        if ($show_keys) $dimensoes[$i] = '"'.$key.'":'.$dimensoes[$i];
                    } else {
                        $dimensoes[$i] = '"'.addslashes($value).'"';
                        if ($show_keys) $dimensoes[$i] = '"'.$key.'":'.$dimensoes[$i];
                    }
                    if ($i==0) $dimensoes[$i] = '{'.$dimensoes[$i];
                    if ($i==$total) $dimensoes[$i].= '}';
                    $i++;
                }
                return implode(',',$dimensoes);
            }

down

-4

justin at jmfrazier dot com ¶

5 years ago

Using null as the key when setting an array value is NOT the same as using empty [].
<?php
  $null = null;
  $testArray = [];
  $testArray[$null] = 1;
  $testArray[$null] = 2;
  $testArray[$null] = 3;
  $testArray[$null] = 4;
  var_dump($testArray);
?>
Output:
array(1) {
  '' =>
  int(4)
}

<?php
  $testArray = [];
  $testArray[null] = 1;
  $testArray[null] = 2;
  $testArray[null] = 3;
  $testArray[null] = 4;
  var_dump($testArray);
?>
Output:
array(1) {
  '' =>
  int(4)
}

<?php
  $testArray = [];
  $testArray[] = 1;
  $testArray[] = 2;
  $testArray[] = 3;
  $testArray[] = 4;
  var_dump($testArray);
?>
Output:
array(4) {
  [0] =>
  int(1)
  [1] =>
  int(2)
  [2] =>
  int(3)
  [3] =>
  int(4)
}

down

-4

info at curtinsNOSPAMcreations dot com ¶

14 years ago

Another way to create a multidimensional array that looks a lot cleaner is to use json_decode.  (Note that this probably adds a touch of overhead, but it sure does look nicer.)  You can of course add as many levels and as much formatting as you'd like to the string you then decode.  Don't forget that json requires " around values, not '!!  (So, you can't enclose the json string with " and use ' inside the string.)

As an example:

<?php
    $myarray['blah'] = json_decode('[
        {"label":"foo","name":"baz"},
        {"label":"boop","name":"beep"}
    ]',true);

print_r($myarray)
?>
returns:

Array
(
    [blah] => Array
        (
            [0] => Array
                (
                    [label] => foo
                    [name] => baz
                )
 
            [1] => Array
                (
                    [label] => boop
                    [name] => beep
                )
        )
)

＋add a note