Apprendre le PHP : require, include, manipulation fichiers et enumerations
Tags: php, french, tutoriel, beginners
Published: 2022-01-28 14:28:55

---
title: Apprendre le PHP : require, include, manipulation fichiers et enumerations
published: true
description: 
tags: PHP, French, Tutoriel, Beginner
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wukm3jucn3jjczb2rith.jpg
series: PHP Moderne
---

Aujourd'hui, vous apprendrez les instructions "require" et "include", la manipulation de fichiers et les énumérations.

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>

# require et include
Jusqu’a présent nous avons créer seulement un fichier PHP pour tous nos tests. 

Lors de la création d’une application il en sera presque toujours autrement. Très rapidement nous aurons besoin de diviser/organiser notre code en plusieurs fichiers.

Ici nous verrons deux instructions qui permettent d’exécuter du code qui à été définit dans un autre fichier.

Pour ce faire nous allons créer deux fichiers. Le premier nommé **message.php** et écrire le code suivant
```php
<?php

function sendMessage(string $message)
{
    echo $message . '<br>';
}
```
Ici c’est du code simple de chez simple. Une petite fonction qui affiche un message et un saut de ligne.

Ensuite, créer le second fichier nommé **index.php** et écrire le code suivant

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

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <?php
        require 'message.php';
        sendMessage('Hello World');
    ?>
</body>

</html>
```
Dans cet exemple, on découvre l’instruction **require**. Elle permet d’inclure le code du fichier message.php. Donc, par conséquent, permet l’utilisation de la fonction **sendMessage**()

Que se passe t’il si le fichier spécifié comme paramètre n’existe pas ? Dans ce cas, PHP retournera une erreure.

### L’instruction include

Permet de faire exactement la même chose que **require** sauf que PHP ne retournera pas une erreure (seulement un Warning) si le fichier à inclure n’est pas présent.

### require_once et include_once

Ces instructions sont identiques à leur instructions sœur (require et include). La différence c’est que PHP va inclure le fichier seulement s'il ne l’a pas déjà fait.

# Manipulation de fichiers et dossiers
PHP inclut plusieurs fonctions pour manipuler les dossiers et fichier sur le serveur

Voici quelques fonctions très utiles

### Créer un fichier

```php
file_put_contents("test.txt", "Hello World!");
```

Cette fonction va créer le fichier test.txt (dans le dossier en cours) avec le contenu ‘Hello World’. 

Il est possible de spécifier le dossier.

```php
file_put_contents("data/test.txt", "Hello World!");
```

Si le dossier n’existe pas, PHP retournera un warning

Vous pouvez créer le dossier avec la fonction mkdir

```php
mkdir('data');

file_put_contents("data/test.txt", "Hello World!");
```

À noter que pour effacer un dossier vous pouvez utiliser la fonction rmdir(). Le dossier doit être vide afin que sa suppression soit possible.

Si vous désirez créer le fichier dans un dossier qui est parent au dossier en cours utilisez les deux points **. .**

```php
file_put_contents("../test.txt", "Hello World!");
```

Le fichier sera créé dans le dossier parent

Si le fichier existe déjà, la fonction file_put_contents va remplacer le fichier existant. Si votre objectif est d’ajouter au fichier existant, utiliser l’option FILE_APPEND

```php
file_put_contents("test.txt", "Hello World!", FILE_APPEND);
```

### Lire un fichier

```php
$content = file_get_contents("test.txt");
```

Si le fichier n’existe pas, PHP va retourner un warning

Pour vérifier si le fichier existe vous pouvez utiliser la fonction file_exists()

```php
if (file_exists('/posts/first.txt')) {
  // do some stuff
}
```

### Lire un fichier ligne par ligne

La fonction précédente permettait de lire un fichier d’un coup. Il existe une fonction pour lire ligne par ligne.

```php
$file = fopen("test.txt", "r");

while(! feof($file)) {
  $line = fgets($file);
  echo $line. "<br>";
}
fclose($file);
```

ici le fichier est ouvert avec l’option ‘r’ pour read. 

Le bloc de code va s’exécuter tant que la fin du fichier n’est pas détectée feof()

### Écrire dans un fichier ligne par ligne

```php
$file = fopen('export.csv', 'w');
```

Ici le fichier est ouvert avec l’option ‘w’ pour créer ou overwrite. Si on aurait voulu faire un ajout on aurait pu utiliser l’option ‘a’ pour append

Une fois le fichier ouvert on peut insérer des lignes

```php
$array = [
    ['name' => 'Mike', 'age' => 45],
    ['name' => 'John', 'age' => 38],
];

//Write key name as csv header
fputcsv($file, array_keys($array[0]));

//Write lines (format as csv)
foreach ($array as $row) {
    fputcsv($file, $row); 
}
fclose($file);
```

La fonction fputfile() permet d’écrire des lignes. Ici nous avons plustot utiliser sa fonction soeur fputcsv() qui fait sensiblement la même chose mais au format csv.

À noter que nous avons utilisé un fputcsv avant la boucle. Cette ligne sera la première ligne du fichier et devra inclure le nom des colonnes. La fonction array_keys() permet justement de récupérer le nom des clé du tableau (name et age)

# Énumérations
Les énumérations, ou "Enums" permettent de définir un “type” personnalisé qui se limitera à l'une des valeurs possibles parmi celle spécifiée. Les Enums sont un type d’objet et peuvent donc être utilisés partout ou un objet peut être utilisé.

Voici un exemple de déclaration

```php
// Définir le nom et les valeurs posssible
enum InvoiceStatus
{
    case Sent;
    case Paid;
    case Cancelled;
}
```

Cette déclaration crée un type **InvoiceStatus** qui peut avoir seulement trois valeurs

InvoiceStatus::Sent

InvoiceStatus::Paid

InvoiceStatus::Cancel

Il est possible d’utiliser ce type dans une fonction avec type hint

```php
function printInvoiceStatus(InvoiceStatus $status)
{
    print($status->name);
}

printInvoiceStatus(InvoiceStatus::Sent);
// Sent
```

La propriété **name** permet de récupérer le nom du **case**

Il est possible d’associé une valeur pour chacun des “**case”**. Pour ce faire il faut absolument spécifier le type du enum lors de sa déclaration : ex. enum InvoiceStatus : int

Il est également possible d’ajouter une méthode à notre **enum**

```php
enum InvoiceStatus : int
{
    case Sent = 0;
    case Paid = 1;
    case Cancelled = 2;
}

print(InvoiceStatus::Paid->value);
```

La propriété **value** permet de récupérer la valeur associée au “case”

Tout comme un objet, il est possible d’ajouter une méthode au Enum

```php
enum InvoiceStatus : int
{
    case Sent = 0;
    case Paid = 1;
    case Cancelled = 2;

    public function text() : string
    {
        return match ($this) {
            self::Sent => 'Sent',
            self::Paid => 'Paid',
            self::Cancelled => 'Cancelled'
        };
    }
}

function getInvoiceStatus(InvoiceStatus $status)
{
    print($status->text());
    print($status->value);
}

getInvoiceStatus(InvoiceStatus::Paid);
// Paid1
```

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