PHP
Arrays

Introducción

Sintaxis

• $ array = array ('Value1', 'Value2', 'Value3'); // Las teclas predeterminadas son 0, 1, 2, ...,
• $ array = array ('Value1', 'Value2',); // coma final opcional
• $ array = array ('key1' => 'Value1', 'key2' => 'Value2',); // Claves explícitas
• $ array = array ('key1' => 'Value1', 'Value2',); // Array (['key1'] => Value1 [1] => 'Value2')
• $ array = ['key1' => 'Value1', 'key2' => 'Value2',]; // PHP 5.4+ taquigrafía
• $ array [] = 'ValueX'; // Añadir 'ValueX' al final de la matriz
• $ array ['keyX'] = 'ValueX'; // Asignar 'valueX' a la tecla 'keyX'
• $ array + = ['keyX' => 'valueX', 'keyY' => 'valueY']; // Agregar / sobrescribir elementos en una matriz existente

Parámetros

Observaciones

Inicializando una matriz

Una matriz se puede inicializar vacía:

// An empty array
$foo = array();

// Shorthand notation available since PHP 5.4
$foo = [];

Una matriz se puede inicializar y preestablecer con valores:

// Creates a simple array with three strings
$fruit = array('apples', 'pears', 'oranges');

// Shorthand notation available since PHP 5.4
$fruit = ['apples', 'pears', 'oranges'];

Una matriz también se puede inicializar con índices personalizados (también llamada matriz asociativa) :

// A simple associative array
$fruit = array(
   'first'  => 'apples',
   'second' => 'pears', 
   'third'  => 'oranges'
);

// Key and value can also be set as follows
$fruit['first'] = 'apples';

// Shorthand notation available since PHP 5.4
$fruit = [
    'first'  => 'apples', 
    'second' => 'pears', 
    'third'  => 'oranges'
];

Si la variable no se ha utilizado antes, PHP la creará automáticamente. Si bien es conveniente, esto podría hacer que el código sea más difícil de leer:

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

El índice usualmente continuará donde lo dejaste. PHP intentará usar cadenas numéricas como enteros:

$foo = [2 => 'apple', 'melon'];  // Array( [2] => apple, [3] => melon )
$foo = ['2' => 'apple', 'melon']; // same as above
$foo = [2 => 'apple', 'this is index 3 temporarily', '3' => 'melon']; // same as above! The last entry will overwrite the second!

Para inicializar una matriz con un tamaño fijo, puede usar SplFixedArray :

$array = new SplFixedArray(3);

$array[0] = 1;
$array[1] = 2;
$array[2] = 3;
$array[3] = 4; // RuntimeException

// Increase the size of the array to 10
$array->setSize(10);

Nota: una matriz creada con SplFixedArray tiene una huella de memoria reducida para grandes conjuntos de datos, pero las claves deben ser enteros.

Para inicializar una matriz con un tamaño dinámico pero con n elementos no vacíos (por ejemplo, un marcador de posición), puede usar un bucle de la siguiente manera:

$myArray = array();
$sizeOfMyArray = 5;
$fill = 'placeholder';

for ($i = 0; $i < $sizeOfMyArray; $i++) {
    $myArray[] = $fill;
}

// print_r($myArray); results in the following:
// Array ( [0] => placeholder [1] => placeholder [2] => placeholder [3] => placeholder [4] => placeholder ) 

Si todos sus marcadores de posición son iguales, también puede crearlo utilizando la función array_fill() :

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

Esto crea y devuelve una matriz con num entradas de value , llaves a partir de start_index .

Nota: Si el start_index es negativo, comenzará con el índice negativo y continuará desde 0 para los siguientes elementos.

$a = array_fill(5, 6, 'banana'); // Array ( [5] => banana, [6] => banana, ..., [10] => banana)
$b = array_fill(-2, 4, 'pear'); // Array ( [-2] => pear, [0] => pear, ..., [2] => pear)

Conclusión: con array_fill() estás más limitado por lo que realmente puedes hacer. El bucle es más flexible y le abre una gama más amplia de oportunidades.

Cuando quiera que una matriz se llene con un rango de números (por ejemplo, 1-4), puede agregar cada elemento a una matriz o usar la función range() :

rango de matriz (mezcla $ inicio, mezcla $ final [, número $ paso = 1])

Esta función crea una matriz que contiene un rango de elementos. Los primeros dos parámetros son necesarios, donde establecen los puntos de inicio y final del rango (inclusive). El tercer parámetro es opcional y define el tamaño de los pasos que se están tomando. Al crear un range de 0 a 4 con un stepsize de stepsize de 1 , la matriz resultante consistirá de los siguientes elementos: 0 , 1 , 2 , 3 y 4 . Si el tamaño del paso se incrementa a 2 (es decir, range(0, 4, 2) ), la matriz resultante sería: 0 , 2 y 4 .

$array = [];
$array_with_range = range(1, 4);

for ($i = 1; $i <= 4; $i++) {
    $array[] = $i;
}
    
print_r($array); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )
print_r($array_with_range); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )

range puede trabajar con enteros, flotadores, valores booleanos (que se convierten en enteros) y cadenas. Sin embargo, se debe tener precaución al usar flotantes como argumentos debido al problema de precisión de punto flotante.

Comprobar si existe la clave

Utilice array_key_exists() o isset() o !empty() isset() !empty() :

$map = [
    'foo' => 1,
    'bar' => null,
    'foobar' => '',
];

array_key_exists('foo', $map); // true
isset($map['foo']); // true
!empty($map['foo']); // true

array_key_exists('bar', $map); // true
isset($map['bar']); // false
!empty($map['bar']); // false

Tenga en cuenta que isset() trata un elemento de valor null como no existente. Mientras que !empty() hace lo mismo para cualquier elemento que sea false (usando una comparación débil; por ejemplo, null , '' y 0 se tratan como falso por !empty() ). While isset($map['foobar']); es true !empty($map['foobar']) es false . Esto puede llevar a errores (por ejemplo, es fácil olvidar que la cadena '0' se trata como falsa), por lo que el uso de !empty() menudo está mal visto.

Tenga en cuenta también que isset() y !empty() isset() funcionarán (y devolverán false) si $map no está definido en absoluto. Esto los hace un tanto propensos a usar errores:

// Note "long" vs "lang", a tiny typo in the variable name.
$my_array_with_a_long_name = ['foo' => true];
array_key_exists('foo', $my_array_with_a_lang_name); // shows a warning
isset($my_array_with_a_lang_name['foo']); // returns false

También puede consultar matrices ordinales:

$ord = ['a', 'b']; // equivalent to [0 => 'a', 1 => 'b']

array_key_exists(0, $ord); // true
array_key_exists(2, $ord); // false

Tenga en cuenta que isset() tiene mejor rendimiento que array_key_exists() ya que esta última es una función y la primera es una construcción de lenguaje.

También puedes usar key_exists() , que es un alias para array_key_exists() .

Comprobando si existe un valor en la matriz

La función in_array() devuelve true si existe un elemento en una matriz.

$fruits = ['banana', 'apple'];

$foo = in_array('banana', $fruits);
// $foo value is true

$bar = in_array('orange', $fruits);
// $bar value is false

También puede usar la función array_search() para obtener la clave de un elemento específico en una matriz.

$userdb = ['Sandra Shush', 'Stefanie Mcmohn', 'Michael'];
$pos = array_search('Stefanie Mcmohn', $userdb);
if ($pos !== false) {
    echo "Stefanie Mcmohn found at $pos";
}

$userdb = [
    [
        "uid" => '100',
        "name" => 'Sandra Shush',
        "url" => 'urlof100',
    ],
    [
        "uid" => '5465',
        "name" => 'Stefanie Mcmohn',
        "pic_square" => 'urlof100',
    ],
    [
        "uid" => '40489',
        "name" => 'Michael',
        "pic_square" => 'urlof40489',
    ]
];

$key = array_search(40489, array_column($userdb, 'uid'));

Validando el tipo de matriz

La función is_array() devuelve true si una variable es una matriz.

$integer = 1337;
$array = [1337, 42];

is_array($integer); // false
is_array($array); // true

Puede escribir sugerir el tipo de matriz en una función para imponer un tipo de parámetro; Pasar cualquier otra cosa resultará en un error fatal.

function foo (array $array) { /* $array is an array */ }

También puede utilizar la función gettype() .

$integer = 1337;
$array = [1337, 42];

gettype($integer) === 'array'; // false
gettype($array) === 'array'; // true

Interfaces ArrayAccess e Iterador

Otra característica útil es acceder a sus colecciones de objetos personalizados como matrices en PHP. Hay dos interfaces disponibles en PHP (> = 5.0.0) núcleo para apoyar esta: ArrayAccess y Iterator . El primero le permite acceder a sus objetos personalizados como matriz.

ArrayAccess

Supongamos que tenemos una clase de usuario y una tabla de base de datos que almacena a todos los usuarios. Nos gustaría crear una clase UserCollection que:

1. Permítanos dirigirnos a ciertos usuarios por su nombre de usuario identificador único
2. realizar operaciones básicas (no todas las CRUD, pero al menos Crear, Recuperar y Eliminar) en nuestra colección de usuarios

Considere la siguiente fuente (en lo sucesivo, usaremos la sintaxis de creación de matriz corta [] disponible desde la versión 5.4):

class UserCollection implements ArrayAccess {
    protected $_conn;
    
    protected $_requiredParams = ['username','password','email'];
    
    public function __construct() {
        $config = new Configuration();

        $connectionParams = [
            //your connection to the database
        ];
        
        $this->_conn = DriverManager::getConnection($connectionParams, $config);
    }
    
    protected function _getByUsername($username) {
        $ret = $this->_conn->executeQuery('SELECT * FROM `User` WHERE `username` IN (?)',
            [$username]
        )->fetch();
        
        return $ret;
    }
    
    // START of methods required by ArrayAccess interface
    public function offsetExists($offset) {
        return (bool) $this->_getByUsername($offset);
    }

    public function offsetGet($offset) {
        return $this->_getByUsername($offset);
    }

    public function offsetSet($offset, $value) {
        if (!is_array($value)) {
            throw new \Exception('value must be an Array');
        }

        $passed = array_intersect(array_values($this->_requiredParams), array_keys($value));
        if (count($passed) < count($this->_requiredParams)) {
            throw new \Exception('value must contain at least the following params: ' . implode(',', $this->_requiredParams));
        }
        $this->_conn->insert('User', $value);
    }

    public function offsetUnset($offset) {
        if (!is_string($offset)) {
            throw new \Exception('value must be the username to delete');
        }
        if (!$this->offsetGet($offset)) {
            throw new \Exception('user not found');
        }
        $this->_conn->delete('User', ['username' => $offset]);
    }
    // END of methods required by ArrayAccess interface
}

Entonces podemos :

$users = new UserCollection();

var_dump(empty($users['testuser']),isset($users['testuser']));
$users['testuser'] = ['username' => 'testuser', 
                      'password' => 'testpassword',
                      'email'    => '[email protected]'];
var_dump(empty($users['testuser']), isset($users['testuser']), $users['testuser']);
unset($users['testuser']);
var_dump(empty($users['testuser']), isset($users['testuser']));

que generará lo siguiente, asumiendo que no hubo un testuser antes de lanzar el código:

bool(true)
bool(false)
bool(false)
bool(true)
array(17) {
  ["username"]=>
  string(8) "testuser"
  ["password"]=>
  string(12) "testpassword"
  ["email"]=>
  string(13) "[email protected]"
}
bool(true)
bool(false)

IMPORTANTE: no se llama a offsetExists cuando verifica la existencia de una clave con la función array_key_exists . Entonces el siguiente código dará como resultado false dos veces:

var_dump(array_key_exists('testuser', $users));
$users['testuser'] = ['username' => 'testuser', 
                      'password' => 'testpassword',
                      'email'    => '[email protected]'];
var_dump(array_key_exists('testuser', $users));

Iterador

Extendamos nuestra clase desde arriba con algunas funciones de la interfaz del Iterator para permitir la iteración sobre ella con foreach y while .

Primero, debemos agregar una propiedad que contenga nuestro índice actual de iterador, vamos a agregarla a las propiedades de la clase como $_position :

// iterator current position, required by Iterator interface methods
protected $_position = 1;

Segundo, agreguemos la interfaz Iterator a la lista de interfaces implementadas por nuestra clase:

class UserCollection implements ArrayAccess, Iterator {

A continuación, agregue lo requerido por las funciones de la interfaz en sí:

// START of methods required by Iterator interface
public function current () {
    return $this->_getById($this->_position);
}
public function key () {
    return $this->_position;
}
public function next () {
    $this->_position++;
}
public function rewind () {
    $this->_position = 1;
}
public function valid () {
    return null !== $this->_getById($this->_position);
}
// END of methods required by Iterator interface

Entonces, en general, aquí está la fuente completa de la clase que implementa ambas interfaces. Tenga en cuenta que este ejemplo no es perfecta, ya que los identificadores en la base de datos pueden no ser secuencial, pero esto fue escrito sólo para darle la idea principal: se puede hacer frente a sus colecciones de objetos de cualquier manera posible mediante la implementación de ArrayAccess y Iterator interfaces:

class UserCollection implements ArrayAccess, Iterator {
    // iterator current position, required by Iterator interface methods
    protected $_position = 1;
    
    // <add the old methods from the last code snippet here>
    
    // START of methods required by Iterator interface
    public function current () {
        return $this->_getById($this->_position);
    }
    public function key () {
        return $this->_position;
    }
    public function next () {
        $this->_position++;
    }
    public function rewind () {
        $this->_position = 1;
    }
    public function valid () {
        return null !== $this->_getById($this->_position);
    }
    // END of methods required by Iterator interface
}

y un bucle foreach a través de todos los objetos de usuario:

foreach ($users as $user) {
    var_dump($user['id']);
}

lo que producirá algo así como

string(2) "1"
string(2) "2"
string(2) "3"
string(2) "4"
...

Creando una matriz de variables

$username = 'Hadibut';
$email = '[email protected]';

$variables = compact('username', 'email');
// $variables is now ['username' => 'Hadibut', 'email' => '[email protected]']

Este método se usa a menudo en marcos para pasar una matriz de variables entre dos componentes.