Apprendre le PHP : Manipulation des tableaux
Tags: php, french, tutoriel, beginners
Published: 2022-01-17 13:45:33

---
title: Apprendre le PHP : Manipulation des tableaux
published: true
description: 
tags: PHP, French, Tutoriel, Beginner
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0705jhlkzbx35ur1e1cd.jpg
series: PHP Moderne
---

Aujourd'hui, vous apprendrez la manipulation des tableaux en PHP.

Ce cours accéléré PHP est gratuit et sera publié ici sur dev.to. Je publierai un nouvel article tous les deux jours environ. Pour ne rien manquer, vous pouvez me suivre sur twitter : <a href="https://twitter.com/EricLeCodeur" class="twitter-follow-button" data-show-count="false">Follow @EricLeCodeur</a><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

Tout d'abord, voici un scénario très courant dans le développement Web qui vous aidera à comprendre pourquoi nous avons besoin d'Array.
Dans l'exemple suivant, nous devons afficher une liste de produits et leurs prix.
```php
$product1 = "iPad";
$product2 = "iPhone";
$product3 = "iWatch";

$price1 = 599;
$price2 = 899;
$price3 = 699;

echo $product1 . ' : ' . $price1 . '<br>';
echo $product2 . ' : ' . $price2 . '<br>';
echo $product3 . ' : ' . $price3 . '<br>';
```

Comme vous pouvez l'imaginer, ce code est loin d'être optimal. Imaginez si nous avions 100 produits ou même 10 000 produits.

Il existe un moyen de faire l'exemple précédent de manière beaucoup plus efficace... Les tableaux.

Les tableaux en PHP sont des listes de valeurs. Les valeurs d'un tableau peuvent être de types différents.
Pour définir un tableau, nous utilisons des crochets [ ]

```php
$products = [];
```
La variable $products est un tableau vide

Il est possible de créer un tableau avec du contenu
```php
$products = ['iPad', 'iPhone', 'iWatch'];
```
Ce tableau contient trois chaînes : iPad, iPhone, iWatch

Chaque élément du tableau est séparé par une virgule.

Il est possible d'avoir des tableaux avec différents types de variables
```php
$array = ['First entry', 100, true];
```

Il est même possible de créer un tableau dans un tableau
```php
$array = ['First entry', 100, ['iPad', 'iPhone'], false];
```

### Pour accéder à un élément
```php
echo $array[0];
// First entry
```
Les éléments d&#39;un tableau sont indexés à partir de 0. Ainsi, le premier élément est à la position 0, le second à la position 1, et ainsi de suite.```php
$array = ['First entry', 100, ['iPad', 'iPhone'], false];
                 0         1           2            3
```
Pour accéder à un tableau dans un tableau, vous utilisez la syntaxe suivante
```php
echo $array[2][1];
// iPhone
```
Ici, nous affichons l'élément 2, c'est-à-dire ['iPad', 'iPhone'] alors que le sous élément 1 est l'iPhone

Si vous tentez d'accéder à un élément inexistant. PHP renverra un avertissement et la valeur null.
```php
$array = ['First entry', 100, true];

echo $array[3];
// null 
// Warning: Undefined array key 3
```

### Nombres d'items dans un tableau 
Pour déterminer le nombre d'éléments dans un tableau, vous pouvez utiliser la fonction count()
```php
$array = ['First entry', 100, true];

echo count($array);
// 3
```

### Manipulation de tableaux

Ajouter un élément à la fin du tableau
```php
$array[] = 'Last';

// ['First entry', 100, ['iPad', 'iPhone'], false, 'Last']
```

Supprimer un élément du tableau
```php
unset($array[0]);

// [100, ['iPad', 'iPhone'], false, 'Last']
```

Convertir un tableau en chaîne avec la fonction implode

```php
$array = ['One', 'Two', 'Three'];
echo implode(', ', $array);
// "One, Two, Three"
```
Le premier paramètre est le séparateur.
Transformer une chaîne en tableau avec la fonction éclater

```php
$text = 'Mike, Shawn, John';
echo explode(',', $text); // ['Mike', 'Shawn', 'John'];
```
Le premier paramètre est le séparateur.

### Itérer à travers tous les éléments d'un tableau

La fonction foreach exécute le code pour chaque élément du tableau.

```php
$names = ['Mike', 'Shawn', 'John'];

foreach($names as $name) { 
   echo 'Hello ' . $name;
}
```
Le premier paramètre est le nom du tableau à parcourir, le deuxième paramètre représente la référence à l'élément courant.

### Tableaux associatifs
Jusqu'à présent, nous avons appris comment fonctionnent les tableaux. Ils ont une clé numérique commençant à 0.
Il est possible de créer des tableaux avec une clé personnalisée. C'est ce que PHP appelle des tableaux associatifs.

```php
$person = ['age' => 45, 'genre' => 'men'];
```
Ici, « l'âge » et le « genre » sont les clés. 45 et 'men' sont les valeurs associées à ces clés. Notez que certains langages de programmation appellent ce type de tableau un dictionnaire.

Les tableaux associatifs sont très pratiques et vous devez bien les comprendre car vous les utiliserez très souvent. Ils sont parfaits pour stocker des informations.

```php
$product = ['id' => 100, 'name' => 'iPad', 'price' => 699];
```

L'accès à une valeur de tableau se fait avec la clé

```php
echo "Product :" . $product['name'];
```

L'ajout d'une clé/valeur au tableau est possible en spécifiant une nouvelle clé

```php
$product['qty'] = 5;
```

Il est possible de vérifier si une clé existe

```php
$product = ['id' => 100, 'name' => 'iPad', 'price' => 699];

echo array_key_exists('id', $product);
// true
```

### Boucle dans un tableau associatif avec des valeurs et des clés

```php
foreach($names as $key => $value) {
   echo $key . ' : ' . $value;
}
```

### Concaténation : Joindre deux tableaux

```php
$names1 = ['Mike', 'Paul', 'Tom'];
$names2 = ['John', 'Sam'];

$allNames = array_merge($names1, $names2);
// ['Mike', 'Paul', 'Tom', 'John', 'Sam'];
```

Concaténation avec l'opérateur de propagation (...)

```php
$names1 = ['Mike', 'Paul', 'Tom'];
$names2 = ['John', 'Sam'];

$allNames = [...$names1, ...$names2];
// ['Mike', 'Paul', 'Tom', 'John', 'Sam'];
```

Ici, l'opérateur de propagation avant le nom du tableau (...$names) déconstruit le tableau.

### Un tableau de tableaux associatifs

Un modèle que vous utiliserez souvent est un tableau contenant des tableaux associatifs.

```php
$items = [
    ['id' => '100', 'name' => 'product 1'],
    ['id' => '200', 'name' => 'product 2'],
    ['id' => '300', 'name' => 'product 3'],
    ['id' => '400', 'name' => 'product 4'],
];
```

Ce type de tableau est excellent pour représenter les données.Il est possible de boucler et d'afficher chaque élément

```php
foreach($items as $item) {
    echo $item['name'] . <br>;
}
```
L'instruction 'as' crée une référence à l'élément de tableau.

### Récupère une partie d'un tableau

Il existe plusieurs fonctions qui permettent de récupérer une partie d'un tableau.

Récupérer uniquement les clés ou les valeurs

```php
$person = ['age' => 45, 'genre' => 'men'];

// Return an array with only keys
echo array_keys($person); // ['age', 'genre']

// Return an array with only values
echo array_values($person); // [45, 'men']
```
## Fonctions avec fonction comme paramètre

Dans cette partie du tutoriel nous allons voir trois fonctions qui permettent la manipulation des tableaux. Ces fonctions sont :
- array_filter()
- array_map()
- array_reduce()

Ces fonctions sont particulières car elle ont chacune une fonction callback comme paramètre. Une fonction callback est une fonction anonyme qui s'exécute de la même façon qu'une fonction classique. 

Le concept des fonctions callback peut être plus difficile à comprendre. Donc si vous ne saisissez pas tout du premier coup c'est normale.

# array_filter()
Permet la récupération des éléments qui correspondent à un critère spécifique
```php
$items = [
    ['id' => 100, 'name' => 'product 1'],
    ['id' => 200, 'name' => 'product 2'],
    ['id' => 300, 'name' => 'product 3'],
    ['id' => 400, 'name' => 'product 4'],
];

$filteredItem = array_filter($items, function ($product) {
    return $product['id'] > 200;
});

print_r($filteredItem);
// $items = [
//    ['id' => '300', 'name' => 'product 3'],
//    ['id' => '400', 'name' => 'product 4'],
// ];
```

La fonction array_filter() est une fonction avec une fonction de rappel en paramètre. Pour chaque élément du tableau, une expression sera évaluée. Si l'expression est vraie, l'élément courant sera inclus dans le tableau résultant.

### Recherche dans un tableau

```php
$items = [
  ['id' => '100', 'name' => 'product 1'],
  ['id' => '200', 'name' => 'product 2'],
  ['id' => '300', 'name' => 'product 3'],
  ['id' => '400', 'name' => 'product 4'],
];

$found_key = array_search('product 3', array_column($items, 'name'));
// 2
```
La fonction array_search() permet de rechercher une clé spécifique selon un critère de recherche. Dans le dernier exemple nous recherchons la clé du 'produit' dans la colonne 'nom'

### Créez un nouveau tableau avec la fonction array_map()

```php
$items = [
    ['id' => 100, 'name' => 'product 1'],
    ['id' => 200, 'name' => 'product 2'],
    ['id' => 300, 'name' => 'product 3'],
    ['id' => 400, 'name' => 'product 4'],
];

$mapItems = array_map(function ($product) {
    return [
        'id' => $product['id'] * 2, 
        'name' => $product['name']
    ];
}, $items);

print_r($mapItems);
//[
    ['id' => 200, 'name' => 'product 1'],
    ['id' => 400, 'name' => 'product 2'],
    ['id' => 600, 'name' => 'product 3'],
    ['id' => 800, 'name' => 'product 4'],
];
```
La fonction array_map() renvoie un tableau qui contient ce que chaque élément de rappel renverra.
La fonction array_map() doit avoir deux paramètres : une fonction callback et un tableau. ex. array_map (fonction de rappel, tableaux)

La fonction array_map() boucle sur chaque élément du tableau et construit en même temps un nouveau tableau. Chaque élément du nouveau tableau est le résultat (retour) de la fonction callback. Dans le dernier exemple, chaque boucle a renvoyé un élément avec l'identifiant * 2 et le nom du produit.
La table d'origine n'est pas modifiée, une nouvelle table est créée.

### La fonction array_reduce()

Cette fonction prend un tableau et le réduit à une seule valeur. Par exemple, a renvoyé le résultat de l'addition de tous les nombres contenus dans un tableau.```php
$numbers = [2, 4, 6, 100];

$sum = array_reduce($numbers, function ($num, $total) {
    return $total + $num;
}, 0);

print_r($sum);
// 112
```
La fonction array_reduce() prend deux paramètres : une référence à l'élément réel et une variable totale. A chaque itération, la fonction callback retourne le résultat dans la variable total.

## Conclusion
C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : <a href="https://twitter.com/EricLeCodeur" class="twitter-follow-button" data-show-count="false">Suivre @EricLeCodeur</a><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>