Apprendre le PHP : Conditions, boucles et fonctions
Tags: php, french, tutoriel, beginners
Published: 2022-01-23 18:02:22

---
title: Apprendre le PHP : Conditions, boucles et fonctions
published: true
description: 
tags: PHP, French, Tutoriel, Beginner
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fqpxuu0a1kjxkviirpx4.jpg
series: PHP Moderne
---

Aujourd'hui, vous apprendrez les conditions, les boucles et les fonctions

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>

# Exécution conditionnelle

En PHP, il est possible d’exécuter une ligne de code seulement si une condition est vraie.
```php
if ($name === 'Mike') {
    echo 'Hello Mike';
}
```

Le code inclut entre les parenthèses est ce que l’on appel une expression. PHP va exécuter ce code et retourner sa valeur booléenne (vrai ou faux). 

Si le résultat est ‘vrai’ alors le code contenu entre les { } sera exécuté.

Si le résultat est faux, rien ne sera exécuté dans ce bloc 'if'

Voici un autre exemple avec l’opérateur plus grand que '>'

```php

if ($amount > 100) {
    echo 'Livraison gratuite';
}
```

Il est possible d’exécuter du code si la condition est fausse
```php
$amount = 120;

if ($amount > 100) {
    echo 'Livraison gratuite';
} else {
    echo 'Livraison 9.95$';
}
```

Ici le mot-clé 'else' exécute le code si l’expression est ‘false’

Enfin, il est possible d’avoir plusieurs conditions
```php
$amount = 120;

if ($amount > 100) {
    echo 'Livraison gratuite';
} elseif ($amount > 50) {
    echo 'Livraison 9.95$';
} else {
    echo 'Livraison 19.95$';
}
```

Le mot-clé 'elseif' permet de tester une autre condition. À noter que cette condition sera testée seulement si la première condition est fausse.

Si la première et la deuxième condition sont fausses, alors le code dans la section 'else' sera exécuté.

### Opérateur de comparaison

Voici les différents opérateurs qui peuvent être utilisés dans les expressions.

==   equal no type check
===   equal with type check
!=   not equal
||   or
&&   and
\>   greater than
\<   less than

il est possible de tester plusieurs expressions en même temps avec l’opérateur &&

```php
if ($amount > 0 && $amount < 50) {
   echo 'Le prix est entre 1 et 49';
}
```

Le même principe s’applique pour l’opérateur ou ||

```php
if ($amount === 100 || $amount === 200) {
   echo 'Le prix est 100$ ou 200$';
}
```

Les expressions sans opérateur de comparaison

```php
$amount = 0;

if ($amount) {
    echo 'Le montant n est pas de zéro';
}
```

Ici l’expression ($amount) ne contient pas d’opérateur de comparaison, malgré ce fait, ce code est valide. Pourquoi ? En PHP chaque expression est convertie en valeur booléenne. Donc ici 0 est convertie en faux. Toute autre valeur autre que zéro (ou null) serait convertie en vrai.

### Convertion en valeur booléenne

Voici la liste des valeurs qui seront converties en **false**

false

0

0.0

null

‘0’ (string égale à zéro)

‘ ’ (string vide)

[ ] (tableau vide)

Toutes les autres valeurs seront converties en **true**

### Voici quelques exemples de conversion en valeur booléenne

```php
$messsage = 'Hello World';

if ($message) { // true
   echo $messsage;
}
```

```php
if ($value) {
    echo 'Variable is set';
} else {
    echo 'Variable is unset';
}
```

### Utiliser les 'if' dans un fichier HTML

```html
<html lang="en">

<body>
    <?php $isAdmin = true; ?>

    <h1>Home page</h1>

    <?php if ($isAdmin) : ?>
        <p>Welcome Administrator</p>
    <?php else : ?>
        <p>Welcome Guest</p>
    <?php endif ?>

</body>

</html>
```

Chaque bloc de code PHP a une balise d’ouverture et de fermeture. La particularité ici c’est le bloc de code du **if** et du **else** . Il n’y a pas { }. Il est possible d’utiliser les : à la place.

### Switch

Si nous avons plusieurs conditions, les 'if', 'elseif' etc.. peuvent donner un code difficile à lire. Dans ce cas l’instruction 'switch' permet justement d’aider à simplifier votre code.

```php
switch ($color) {
    case 'red':
        echo 'Danger';
         break;
    case 'yellow':
        echo 'Warning';
        break;
    case 'green':
        echo 'Success';
        break;
    default:
        echo 'The color is unknown';
}
```

La première ligne représente l’expression que nous désirons évaluer : switch($color)

Ensuite suffit d’inclure les “case” possible.

La fonction “break” empêche l’exécution de continuer

Le “case” default est utilisé s'il y a aucun case qui correspond.

### Match

Nouveauté PHP 8, cette instruction permet de retourner une expression selon une correspondance clé ⇒valeur

```php
$type = match($color) {
    'red' => 'danger',
    'yellow', 'orange' => 'warning',
    'green' => 'success',
    default => 'Unknown'
};
```

La première ligne représente l’expression que nous désirons vérifier la correspondance: **match**($color)

Sur la deuxième ligne on remarque qu’il est possible de correspondre plus d’une expression à la fois.

Ensuite s’en suit une liste de **clé** ⇒ **valeur**. Si aucune **clé**→**valeur** n’est trouvé, la clé **default** sera exécutée.

À noter que la clé peut être une expression et que la valeur peut être également, une expression et même une fonction.

```php
$type = match($color) {
    userID == 100 => openAdmin(),
    userID < 100 && userID > 0 => openUser(),
    default => openOther()
};
```

### Switch ou Match ?

Chacun possède des plus. **Match** est plus simple visuellement mais **Switch** permet d’exécuter plus d’une ligne de code pour chaque “case”. **Match** permet de retourner une valeur ce que **Switch** ne fait pas. Bref moi j’utilise **Match** si possible car je trouve l’instruction plus épurée visuellement mais sinon je n'ai pas de problème avec l’instruction **switch**

### Ternary operator  ?:

C’est une syntaxe raccourcie pour un if...else. 

Voici un exemple avec if...else

```php
if ($isValid) {
    echo 'user valid';
} else {
    echo 'user not valid';
}
```

Voici le même exemple mais avec l’opérateur Ternary

```php
echo $isValid ? 'user valid' : 'user not valid';
```

Si l’expression qui précède L’opérateur “?” est vraie alors la valeur suivant “?” sera utilisé, sinon c’est la valeur suivant les “:” qui sera utilisé.

### L'opérateur de coalescence Null ??

L'opérateur de coalescence Null renvoie son premier opérande s'il existe et n'est pas NULL ; sinon il renvoie son deuxième opérande

```php
echo $name ?? 'Mike';  //output 'Mike' if $name is null
```

### Assignation avec l'opérateur de coalescence Null ??

```php
$name ??= 'Mike';
```

Assigne la valeur ‘Mike’ si la variable $name est null

### Opérateur Null safe

```php
echo $user?->profile?->activate();
```

Si une des variables qui précède l’opérateur “?” est null alors la valeur de l’expression sera null


# Les boucles

### La boucle “while”
Permet d’exécuter un block de code un certain nombre de fois. Le nombre de fois va dépendre de la condition. Tantque la condition est vrai, le block de code va s’exécuter. 

```php
$number = 1;
while ($number < 10) {
    echo 'value : ' . $number ;
    $number += 1;
}
```

Ici le bloc de code sera exécuté 9 fois.

### La boucle “do while”

Essentiellement le même principe que la boucle “while” mais dans ce cas-ci, le bloc de code va toujours s’exécuter au moins une fois. La condition étant testé seulement à la fin du bloc de code.

```php
$number = 1;
do {
    echo 'value : ' . $number ;
    $number += 1;
} while ($number < 10);
```

### La boucle “for”

Permet d’exécuter un bloc de code un nombre de fois définit par une condition.

```php
for ($i = 0; $i < 20; $i++) {
    echo "i value = " . i;
}
```

Le paramètre se divise en trois sections, le première étant la définition du compteur (i = 0). Ensuite la condition à respecter pour exécuter le bloc de code ($i < 20)  et enfin le code à exécuter à chaque itération ($i++)

### La boucle “foreach”

La fonction foreach permet d’exécuter un bloc de code pour chaque élément d’un tableau.

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

foreach($names as $name) { 
   echo 'Hello ' . $name;
}
```

Le premier paramètre c’est le nom du tableau à parcourir, le second paramètre représente la référence à l’élément en cours.

### Break et Continue

Les instructions break et continue permettent de modifier la boucle

```php
for ($i = 0; $i < 20; $i++) {
    if ($i % 2 === 0) {
        continue;
    }
    echo $i . '<br>';
}
```

Cette boucle va imprimer la valeur de $i, seulement lorsque la valeur sera impaire.

Si la valeur est paire ($i % 2 === 0). Alors on demande à la boucle de faire un **continue** avec la prochaine valeur.

Il est possible de sortir de la boucle à tout moment avec l’instruction **break**

```php
$i = 0;

while ($i < 10000) {
    $i++;
    if ($i == 10) {
        break;
    }
    echo $i . '<br>';
}
```

Ici la boucle va s’arrêter lorsque $i aura 10 comme valeur

# Les fonctions
En PHP il existe plusieurs fonctions déjà pré-définit. Il est également possible de créer nos propres fonctions. 

Les fonctions permettent d’éviter de répéter notre code plusieurs fois. Elles permettent également de diviser notre application en petit morceau plus facile à maintenir.

La syntaxe pour créer une fonction est assez simple

```php
function hello() {
    echo 'Hello World';
}
```

Ici nous utilisons le mot-clé “function” suivit du nom de notre fonction.

Une fois notre fonction créée, il est possible de lancer son exécution

```php
hello();
```

Il est possible d’inclure un ou des paramètres notre fonction

```php
function hello($firstName, $lastName) {
    echo 'Hello' . $firstName . ' ' . $lastName;
}
```

Le lancement de la fonction devra inclure les paramètres dans l’ordre qu’ils ont été déclarés

```php
hello('Mike', 'Taylor');
```

Une valeur par défaut peut-être attribué à un paramètre ce qui du coup rendra se paramètre optionnel lors de l’appel de la fonction.

```php
function hello($firstName, $lastName = 'none') {
    echo 'Hello' . $firstName . ' ' . $lastName;
}

hello('Mike');
// Mike none
```

À noter que les paramètres avec une valeur par défaut doivent absolument être définit en dernier ordre.

Depuis la version 8 de PHP il est possible de lancer une fonction en nommant les paramètres. L’appel est plus clair et l’ordre des paramètres n’a pas à être respecté.

```php
hello(lastName: 'Taylor', firstName: 'Mike');
```

### L’instruction Return

Permet de retourner une valeur lorsque l’on l'appel la fonction.

```php
function fullName($firstName, $lastName) {
    return $firstName . ' ' . $lastName;
}

echo fullName('John', 'Doe');
```

Ici la fonction retourne une string concaténé avec prénom et nom

La fonction echo va afficher sur la page web la valeur retournée par la fonction fullName()

### Fonctions anonymes (closure)

Permet la création de fonctions sans préciser leur nom. Voici un exemple :

```php
$sum = function ($a, $b) (
    return $a + $b;
);

echo $sum(10, 15);
```

Les fonctions anonymes se terminent par un semi colon ;  Et elles ne peuvent pas accéder aux variables du contexte parent.

Il est possible de passer une variable depuis le contexte parent avec l’instruction **use** 

```php
$x = 10;

$sum = function ($a, $b) use $x (
    return $x + $a + $b;
);

echo $sum(10, 15);
// 35
```

### Callback functions

Les fonctions Callback sont des fonctions anonymes passé comme paramètre. Voici un exemple

```php
$products = ['iPhone 12', 'iPhone 13', 'iPad', 'iWatch'];

$filtered_products = array_filter($products, function ($product) {
    return str_contains($product, 'Phone');
});

print_r($filtered_products);
// Array ( [0] => iPhone 12 [1] => iPhone 13 )
```

Ici la fonction array_filter() possède une fonction anonyme comme deuxième paramètre. 

### Arrow functions

Permet l’utilisation d’une syntaxe raccourci:

```php
$products = ['iPhone 12', 'iPhone 13', 'iPad', 'iWatch'];

$filtered_products = array_filter($products, fn ($product) => str_contains($product, 'Phone'));

print_r($filtered_products);
```

À noter que pour le moment, les Arrow fonctions permettent l’exécution de seulement une expression. Les Arrow function sont exécuté dans le contexte en cours donc peuvent utiliser les variables sans à avoir à utiliser l’instruction **use**.

### Fonction Type Hint

À noter que les fonctions peuvent être typé (string, int, etc.). Il est possible de définir un type pour chacun des paramètres et un type pour la valeur de retour de la fonction.

```php
function display(string $first, string $last) : string {
    return "$first $last";
}
```

Ici les paramètres $first et $last devront être de type string ainsi que le valeur de retour.

Il existe plusieurs autres trucs à savoir sur les fonctions typé, nous y reviendrons un peu plus tard.

### Strict Type

Voici un exemple d’une fonction avec type

```php
function add(int $a, int $b): int
{
    return $a + $b;
}

echo add('10', 20);
// 30
```

Dans cette exemple le paramètre $a est de type integer. Malgré tout PHP ne retourne pas d’erreur. La raison c’est que PHP va tenter de convertir la string ‘10’ en integer. Si la conversion est possible alors aucune erreur n’est rapporté.

Il arrive parfois que vous aimeriez que PHP ne permette pas cette conversion et exécute seulement si le paramètre est vraiment du type spécifié. Pour ce faire il faut ajouter un instruction au début de votre fichier.

```php
declare(strict_types=1);

function add(int $a, int $b): int
{
    return $a + $b;
}

echo add('10', 20);
// TypeError
```

Ici une erreur est retournée car le type du paramètre n’est pas un integer

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