PHP 5.6.18 is available

array_column

(PHP 5 >= 5.5.0, PHP 7)

array_columnDevuelve los valores de una sola columna del array de entrada

Descripción

array array_column ( array $input , mixed $column_key [, mixed $index_key = null ] )

array_column() devuelve los valores de una sola columna de input, identificado por la clave de columna column_key. Opcionalmente, se podría proporcionar una clave de índice, index_key, para indexar los valores del array devuelto por los valores de la columna index_key del array de entrada.

Parámetros

input

Un array multidimensional o un array de objetos desde el que extraer una columna de valores. Si se proporciona un array de objetos, entonces se podrá extraer directamente las propiedades públicas. Para poder extraer las proiedades protegidas o privadas, la clase debe implementar los métodos mágicos __get() y __isset().

column_key

La columna de valores a devolver. Este valor podría ser una clave de tipo integer de la columna de la cual obtener los datos, o podría ser una clave de tipo string para un array asociativo o nombre de propiedad. También prodría ser NULL para devolver array completos u objetos (útil junto con index_key para reindexar el array).

index_key

La columna a usar como los índices/claves para el array devuelto. Este valor podría ser la clave de tipo integer de la columna, o podría ser el nombre de la clave de tipo string.

Valores devueltos

Devuelve un array de valores que representa una sola columna del array de entrada.

Historial de cambios

Versión Descripción
7.0.0 Se añdió la capacidad de que el parámetro input sea un array de objetos.

Ejemplos

Ejemplo #1 Obtener la columna de nombres del conjunto de resultados

<?php
// Array representando un conjunto de registros posibles devueltos desde una base de datos
$registros = array(
    array(
        
'id' => 2135,
        
'nombre' => 'John',
        
'apellido' => 'Doe',
    ),
    array(
        
'id' => 3245,
        
'nombre' => 'Sally',
        
'apellido' => 'Smith',
    ),
    array(
        
'id' => 5342,
        
'nombre' => 'Jane',
        
'apellido' => 'Jones',
    ),
    array(
        
'id' => 5623,
        
'nombre' => 'Peter',
        
'apellido' => 'Doe',
    )
);
 
$nombres array_column($registros'nombre');
print_r($nombres);
?>

El resultado del ejemplo sería:

Array
(
    [0] => John
    [1] => Sally
    [2] => Jane
    [3] => Peter
)

Ejemplo #2 Obtener la columna de apellidos del conjunto de resultados, indexada por la columna "id"

<?php
// Se emplea el array $registros del Ejemplo #1
$apellidos array_column($registros'apellido''id');
print_r($apellidos);
?>

El resultado del ejemplo sería:

Array
(
    [2135] => Doe
    [3245] => Smith
    [5342] => Jones
    [5623] => Doe
)

Ejemplo #3 Obtener la columna de nombres de usuarios de la propiedad pública "nombre_usuario" de un objeto

<?php

class Usuario
{
    public 
$nombre_usuario;

    public function 
__construct(string $nombre_usuario)
    {
        
$this->nombre_usuario $nombre_usuario;
    }
}

$usuarios = [
    new 
Usuario('usuario 1'),
    new 
Usuario('usuario 2'),
    new 
Usuario('usuario 3'),
];

print_r(array_column($usuarios'nombre_usuario'));
?>

El resultado del ejemplo sería:

Array
(
    [0] => usuario 1
    [1] => usuario 2
    [2] => usuario 3
)

Ejemplo #4 Obtener la columna de nombres de la propiedad privada "nombre" de un objeto empleando el método mágico __get().

<?php

class Persona
{
    private 
$name;

    public function 
__construct(string $nombre)
    {
        
$this->nombre $nombre;
    }

    public function 
__get($prop)
    {
        return 
$this->$prop;
    }

    public function 
__isset($prop) : bool
    
{
        return isset(
$this->$prop);
    }
}

$gente = [
    new 
Persona('Fred'),
    new 
Persona('Jane'),
    new 
Persona('John'),
];

print_r(array_column($gente'nombre'));
?>

El resultado del ejemplo sería:

Array
(
    [0] => Fred
    [1] => Jane
    [2] => John
)
Si no se proporciona __isset(), será devuelto un array vacío.

add a note add a note

User Contributed Notes 11 notes

up
41
mohanrajnr at gmail dot com
9 months ago
if array_column does not exist the below solution will work.

if(!function_exists("array_column"))
{

    function array_column($array,$column_name)
    {

        return array_map(function($element) use($column_name){return $element[$column_name];}, $array);

    }

}
up
48
WARrior
2 years ago
You can also use array_map fucntion if you haven't array_column().

example:

$a = array(
    array(
        'id' => 2135,
        'first_name' => 'John',
        'last_name' => 'Doe',
    ),
    array(
        'id' => 3245,
        'first_name' => 'Sally',
        'last_name' => 'Smith',
    )
);

array_column($a, 'last_name');

becomes

array_map(function($element){return $element['last_name'];}, $a);
up
4
till at etill dot net
8 months ago
Some remarks not included in the official documentation.

1) array_column does not support 1D arrays, in which case an empty array is returned.

2) The $column_key is zero-based.

3) If $column_key extends the valid index range an empty array is returned.
up
0
kaspar dot wilbuer at web dot de
5 days ago
If you need to extract more than one column from an array, you can use array_intersect_key on each element, like so:

function array_column_multi(array $input, array $column_keys) {
    $result = array();
    $column_keys = array_flip($column_keys);
    foreach($input as $key => $el) {
        $result[$key] = array_intersect_key($el, $column_keys);
    }
    return $result;
}
up
-1
antonfedonjuk at gmail dot com
6 months ago
My version is closer to the original than http://github.com/ramsey/array_column
<?php
/**
* Provides functionality for array_column() to projects using PHP earlier than
* version 5.5.
* @copyright (c) 2015 WinterSilence (http://github.com/WinterSilence)
* @license MIT
*/
if (!function_exists('array_column')) {
   
/**
     * Returns an array of values representing a single column from the input
     * array.
     * @param array $array A multi-dimensional array from which to pull a
     *     column of values.
     * @param mixed $columnKey The column of values to return. This value may
     *     be the integer key of the column you wish to retrieve, or it may be
     *     the string key name for an associative array. It may also be NULL to
     *     return complete arrays (useful together with index_key to reindex
     *     the array).
     * @param mixed $indexKey The column to use as the index/keys for the
     *     returned array. This value may be the integer key of the column, or
     *     it may be the string key name.
     * @return array
     */
   
function array_column(array $array, $columnKey, $indexKey = null)
    {
       
$result = array();
        foreach (
$array as $subArray) {
            if (!
is_array($subArray)) {
                continue;
            } elseif (
is_null($indexKey) && array_key_exists($columnKey, $subArray)) {
               
$result[] = $subArray[$columnKey];
            } elseif (
array_key_exists($indexKey, $subArray)) {
                if (
is_null($columnKey)) {
                   
$result[$subArray[$indexKey]] = $subArray;
                } elseif (
array_key_exists($columnKey, $subArray)) {
                   
$result[$subArray[$indexKey]] = $subArray[$columnKey];
                }
            }
        }
        return
$result;
    }
}
?>
up
-2
hypxm at qq dot com
1 year ago
a simple solution:

function arrayColumn(array $array, $column_key, $index_key=null){
        if(function_exists('array_column ')){
            return array_column($array, $column_key, $index_key);
        }
        $result = [];
        foreach($array as $arr){
            if(!is_array($arr)) continue;

            if(is_null($column_key)){
                $value = $arr;
            }else{
                $value = $arr[$column_key];
            }

            if(!is_null($index_key)){
                $key = $arr[$index_key];
                $result[$key] = $value;
            }else{
                $result[] = $value;
            }

        }

        return $result;
    }
up
-4
kiler129 @ nowhere
1 year ago
Please note this function accepts 2D-arrays ONLY, and silently returns empty array when non-array argument is provided.

Code:
class testObject {
    public $a = 123;
}
$testArray = [new testObject(), new testObject(), new testObject()];
$result = array_column($testArray, 'a')); //array(0) { }
up
-4
coviex
1 year ago
Value for existing key in the resulting array is rewritten with new value if it exists in another source sub-array.
up
-3
marianbucur17 at yahoo dot com
8 months ago
If array_column is not available you can use the following function, which also has the $index_key parameter:

if (!function_exists('array_column')) {
    function array_column($array, $column_key, $index_key = null)
    {
        return array_reduce($array, function ($result, $item) use ($column_key, $index_key)
        {
            if (null === $index_key) {
                $result[] = $item[$column_key];
            } else {
                $result[$item[$index_key]] = $item[$column_key];
            }

            return $result;
        }, []);
    }
}
up
-8
robbieaverill[at]gmail.com
10 months ago
Another option for older PHP versions (pre 5.5.0) is to use array_walk():

<?php
$array
= array(
  array(
'some' => 'var', 'foo' => 'bar'),
  array(
'some' => 'var', 'foo' => 'bar'),
  array(
'some' => 'var', 'foo' => 'bar')
);

array_walk($array, function(&$value, $key, $return) {
 
$value = $value[$return];
},
'foo');

print_r($array);

// Array
// (
//     [0] => bar
//     [1] => bar
//     [2] => bar
// )

?>
up
-13
myles at smyl dot es
1 year ago
This didn't work for me recursively and needed to come up with a solution.

Here's my solution to the function:

if ( ! function_exists( 'array_column_recursive' ) ) {
    /**
     * Returns the values recursively from columns of the input array, identified by
     * the $columnKey.
     *
     * Optionally, you may provide an $indexKey to index the values in the returned
     * array by the values from the $indexKey column in the input array.
     *
     * @param array $input     A multi-dimensional array (record set) from which to pull
     *                         a column of values.
     * @param mixed $columnKey The column of values to return. This value may be the
     *                         integer key of the column you wish to retrieve, or it
     *                         may be the string key name for an associative array.
     * @param mixed $indexKey  (Optional.) The column to use as the index/keys for
     *                         the returned array. This value may be the integer key
     *                         of the column, or it may be the string key name.
     *
     * @return array
     */
    function array_column_recursive( $input = NULL, $columnKey = NULL, $indexKey = NULL ) {

        // Using func_get_args() in order to check for proper number of
        // parameters and trigger errors exactly as the built-in array_column()
        // does in PHP 5.5.
        $argc   = func_num_args();
        $params = func_get_args();
        if ( $argc < 2 ) {
            trigger_error( "array_column_recursive() expects at least 2 parameters, {$argc} given", E_USER_WARNING );

            return NULL;
        }
        if ( ! is_array( $params[ 0 ] ) ) {
            // Because we call back to this function, check if call was made by self to
            // prevent debug/error output for recursiveness :)
            $callers = debug_backtrace();
            if ( $callers[ 1 ][ 'function' ] != 'array_column_recursive' ){
                trigger_error( 'array_column_recursive() expects parameter 1 to be array, ' . gettype( $params[ 0 ] ) . ' given', E_USER_WARNING );
            }

            return NULL;
        }
        if ( ! is_int( $params[ 1 ] )
             && ! is_float( $params[ 1 ] )
             && ! is_string( $params[ 1 ] )
             && $params[ 1 ] !== NULL
             && ! ( is_object( $params[ 1 ] ) && method_exists( $params[ 1 ], '__toString' ) )
        ) {
            trigger_error( 'array_column_recursive(): The column key should be either a string or an integer', E_USER_WARNING );

            return FALSE;
        }
        if ( isset( $params[ 2 ] )
             && ! is_int( $params[ 2 ] )
             && ! is_float( $params[ 2 ] )
             && ! is_string( $params[ 2 ] )
             && ! ( is_object( $params[ 2 ] ) && method_exists( $params[ 2 ], '__toString' ) )
        ) {
            trigger_error( 'array_column_recursive(): The index key should be either a string or an integer', E_USER_WARNING );

            return FALSE;
        }
        $paramsInput     = $params[ 0 ];
        $paramsColumnKey = ( $params[ 1 ] !== NULL ) ? (string) $params[ 1 ] : NULL;
        $paramsIndexKey  = NULL;
        if ( isset( $params[ 2 ] ) ) {
            if ( is_float( $params[ 2 ] ) || is_int( $params[ 2 ] ) ) {
                $paramsIndexKey = (int) $params[ 2 ];
            } else {
                $paramsIndexKey = (string) $params[ 2 ];
            }
        }
        $resultArray = array();
        foreach ( $paramsInput as $row ) {
            $key    = $value = NULL;
            $keySet = $valueSet = FALSE;
            if ( $paramsIndexKey !== NULL && array_key_exists( $paramsIndexKey, $row ) ) {
                $keySet = TRUE;
                $key    = (string) $row[ $paramsIndexKey ];
            }
            if ( $paramsColumnKey === NULL ) {
                $valueSet = TRUE;
                $value    = $row;
            } elseif ( is_array( $row ) && array_key_exists( $paramsColumnKey, $row ) ) {
                $valueSet = TRUE;
                $value    = $row[ $paramsColumnKey ];
            }

            $possibleValue = array_column_recursive( $row, $paramsColumnKey, $paramsIndexKey );
            if ( $possibleValue ) {
                $resultArray = array_merge( $possibleValue, $resultArray );
            }

            if ( $valueSet ) {
                if ( $keySet ) {
                    $resultArray[ $key ] = $value;
                } else {
                    $resultArray[ ] = $value;
                }
            }
        }

        return $resultArray;
    }
}
To Top