PHP
Tableaux

Introduction

Syntaxe

• $ array = array ('Value1', 'Value2', 'Value3'); // Les clés sont par défaut à 0, 1, 2, ...,
• $ array = array ('Value1', 'Value2',); // Virgule de fin optionnelle
• $ array = array ('key1' => 'Value1', 'key2' => 'Value2',); // Clés explicites
• $ array = array ('key1' => 'Value1', 'Value2',); // Array (['key1'] => Value1 [1] => 'Value2')
• $ array = ['key1' => 'Value1', 'key2' => 'Value2',]; // raccourci PHP 5.4+
• $ array [] = 'ValueX'; // Ajoute 'ValueX' à la fin du tableau
• $ array ['keyX'] = 'ValueX'; // Assigne 'valueX' à la clé 'keyX'
• $ array + = ['keyX' => 'valueX', 'keyY' => 'valueY']; // Ajout / remplacement d'éléments sur un tableau existant

Paramètres

Remarques

Initialisation d'un tableau

Un tableau peut être initialisé vide:

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

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

Un tableau peut être initialisé et prédéfini avec des valeurs:

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

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

Un tableau peut également être initialisé avec des index personnalisés (également appelés tableau associatif) :

// 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 n'a pas été utilisée auparavant, PHP la créera automatiquement. Bien que pratique, cela pourrait rendre le code plus difficile à lire:

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

L'index continuera généralement là où vous l'avez laissé. PHP essaiera d'utiliser des chaînes numériques en tant qu'entiers:

$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!

Pour initialiser un tableau de taille fixe, vous pouvez utiliser 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);

Remarque: Un tableau créé à l'aide de SplFixedArray a une empreinte mémoire réduite pour les grands ensembles de données, mais les clés doivent être des entiers.

Pour initialiser un tableau avec une taille dynamique mais avec n éléments non vides (par exemple un espace réservé), vous pouvez utiliser une boucle comme suit:

$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 tous vos espaces réservés sont identiques, vous pouvez également le créer en utilisant la fonction array_fill() :

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

Cela crée et renvoie un tableau avec des entrées num de value , les clés commençant à start_index .

Remarque: Si le start_index est négatif, il commencera par l’index négatif et continuera à partir de 0 pour les éléments suivants.

$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)

Conclusion: Avec array_fill() vous êtes plus limité pour ce que vous pouvez réellement faire. La boucle est plus flexible et vous ouvre de nombreuses opportunités.

Chaque fois que vous voulez un tableau rempli d'une plage de nombres (par exemple 1 à 4), vous pouvez soit ajouter chaque élément à un tableau, soit utiliser la fonction range() :

plage de tableau (mixte $ start, mixed $ end [, nombre $ step = 1])

Cette fonction crée un tableau contenant une série d'éléments. Les deux premiers paramètres sont requis, où ils définissent les points de début et de fin de la plage (incluse). Le troisième paramètre est facultatif et définit la taille des étapes en cours. En créant une range de 0 à 4 avec un stepsize de 1 , le tableau résultant serait composé des éléments suivants: 0 , 1 , 2 , 3 et 4 . Si la taille du pas est augmentée à 2 (c.-à-d. range(0, 4, 2) ), le tableau résultant serait alors: 0 , 2 et 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 peut fonctionner avec des entiers, des flottants, des booléens (convertis en nombres entiers) et des chaînes. Il convient toutefois de faire preuve de prudence lors de l’utilisation de floats comme arguments en raison du problème de précision en virgule flottante.

Vérifier si la clé existe

Utilisez array_key_exists() ou isset() ou !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

Notez que isset() traite un élément null comme inexistant. Alors que !empty() fait la même chose pour tout élément égal à false (en utilisant une comparaison faible, par exemple, null , '' et 0 sont tous traités comme faux par !empty() ). While isset($map['foobar']); est true !empty($map['foobar']) est false . Cela peut conduire à des erreurs (par exemple, il est facile d'oublier que la chaîne '0' est considérée comme fausse), donc l'utilisation de !empty() est souvent mal vue.

Notez également que isset() et !empty() isset() fonctionneront (et retourneront false) si $map n'est pas défini du tout. Cela les rend quelque peu sujettes aux erreurs d'utilisation:

// 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

Vous pouvez également vérifier les tableaux ordinaux:

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

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

Notez que isset() a de meilleures performances que array_key_exists() car ce dernier est une fonction et la première une construction de langage.

Vous pouvez également utiliser key_exists() , alias de array_key_exists() .

Vérifier si une valeur existe dans le tableau

La fonction in_array() renvoie true si un élément existe dans un tableau.

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

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

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

Vous pouvez également utiliser la fonction array_search() pour obtenir la clé d'un élément spécifique dans un tableau.

$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'));

Validation du type de tableau

La fonction is_array() renvoie true si une variable est un tableau.

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

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

Vous pouvez taper le type de tableau dans une fonction pour appliquer un type de paramètre; le fait de transmettre autre chose entraînera une erreur fatale.

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

Vous pouvez également utiliser la fonction gettype() .

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

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

Interfaces ArrayAccess et Iterator

Une autre fonctionnalité utile consiste à accéder à vos collections d'objets personnalisées en tant que tableaux en PHP. Il existe deux interfaces disponibles dans le noyau PHP (> = 5.0.0) pour supporter ceci: ArrayAccess et Iterator . Le premier vous permet d'accéder à vos objets personnalisés en tant que tableau.

ArrayAccess

Supposons que nous ayons une classe d'utilisateurs et une table de base de données stockant tous les utilisateurs. Nous aimerions créer une classe UserCollection qui:

1. nous permettre d’adresser certains utilisateurs par leur identifiant unique
2. effectuer des opérations de base (pas toutes les CRUD, mais au moins créer, récupérer et supprimer) sur notre collection d'utilisateurs

Considérons la source suivante (ci-après, nous utilisons la syntaxe de création de tableau court [] disponible depuis la version 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
}

alors nous pouvons :

$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']));

qui affichera ce qui suit, en supposant qu'il n'y avait pas de testuser avant de lancer le code:

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)

IMPORTANT: offsetExists n'est pas appelé lorsque vous vérifiez l'existence d'une clé avec la fonction array_key_exists . Ainsi, le code suivant affichera false deux fois:

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

Itérateur

Étendons notre classe de haut en Iterator avec quelques fonctions de l'interface Iterator pour permettre une itération avec foreach et while .

Tout d'abord, nous devons ajouter une propriété contenant notre index actuel de l'itérateur, ajoutons-le aux propriétés de la classe sous la forme $_position :

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

Deuxièmement, ajoutons l'interface Iterator à la liste des interfaces implémentées par notre classe:

class UserCollection implements ArrayAccess, Iterator {

puis ajoutez les fonctions requises par l'interface elles-mêmes:

// 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

Donc, dans l'ensemble, voici la source complète de la classe implémentant les deux interfaces. Notez que cet exemple n'est pas parfait, car les identifiants de la base de données peuvent ne pas être séquentiels, mais cela a été écrit pour vous donner l'idée principale: vous pouvez adresser vos collections d'objets de toute façon en implémentant les interfaces ArrayAccess et Iterator :

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
}

et un foreach en boucle à travers tous les objets utilisateur:

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

qui produira quelque chose comme

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

Créer un tableau de variables

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

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

Cette méthode est souvent utilisée dans les frameworks pour transmettre un tableau de variables entre deux composants.