🔧 Partie 1

Qu'est-ce qu'une fonction ?

Le concept fondamental

Une fonction : c'est quoi ? 🤔

Analogie : Machine à café ☕

• 🔵 Entrée : Eau + café moulu
• ⚙️ Traitement : Chauffer, filtrer, extraire
• ☕ Sortie : Tasse de café

Pourquoi utiliser des fonctions ? 🎯

• ♻️ Réutilisabilité : Écrire une fois, utiliser partout
• 📖 Lisibilité : Code plus clair et organisé
• 🔧 Maintenance : Modifier à un seul endroit
• 🐛 Débogage : Tester chaque fonction isolément
• 👥 Travail en équipe : Diviser le travail

Exemple sans fonction ❌

<?php
// Calculer la TVA pour plusieurs produits

// Produit 1
$prixHT1 = 100;
// Calcul : prix HT + 20% de TVA
$prixTTC1 = $prixHT1 + ($prixHT1 * 0.20);
echo "Prix TTC : $prixTTC1€\n";  // 120€

// Produit 2 - On répète EXACTEMENT le même calcul
$prixHT2 = 50;
$prixTTC2 = $prixHT2 + ($prixHT2 * 0.20);
echo "Prix TTC : $prixTTC2€\n";  // 60€

// Produit 3 - Encore la même répétition !
$prixHT3 = 75;
$prixTTC3 = $prixHT3 + ($prixHT3 * 0.20);
echo "Prix TTC : $prixTTC3€\n";  // 90€

// 😓 Problème : Si on change le taux de TVA à 5.5%,
//    il faut modifier 3 lignes !
?>

Exemple avec fonction ✅

<?php
// 1. DÉFINIR la fonction UNE SEULE FOIS
function calculerTVA($prixHT) {
    // Le calcul est écrit UNE FOIS ici
    return $prixHT + ($prixHT * 0.20);
}

// 2. UTILISER la fonction AUTANT DE FOIS que nécessaire
echo "Prix TTC : " . calculerTVA(100) . "€\n";  // 120€
echo "Prix TTC : " . calculerTVA(50) . "€\n";   // 60€
echo "Prix TTC : " . calculerTVA(75) . "€\n";   // 90€

// ✨ Avantage : Pour changer le taux de TVA,
//    on modifie UNE SEULE ligne dans la fonction !

// Encore plus simple :
$prix = 200;
$total = calculerTVA($prix);  // On stocke le résultat
echo "Total : $total€\n";      // 240€
?>

📝 Partie 2

Déclaration et appel

Créer et utiliser des fonctions

Syntaxe de déclaration 📝

function nomDeLaFonction() {
    // Code à exécuter
}

Exemple simple :

<?php
function direBonjour() {
    echo "Bonjour tout le monde !\n";
}
?>

Appeler une fonction 📞

<?php
// 1. DÉCLARATION (définir la fonction)
//    On écrit la "recette" mais on ne l'exécute pas encore
function direBonjour() {
    echo "Bonjour tout le monde !\n";
}

// 2. APPEL (utiliser la fonction)
//    Maintenant on EXÉCUTE la fonction
direBonjour();  // Affiche : Bonjour tout le monde !

// On peut l'appeler plusieurs fois
direBonjour();  // Affiche : Bonjour tout le monde !
direBonjour();  // Affiche : Bonjour tout le monde !

// Note : Sans les (), PHP ne comprend pas que c'est un appel
// direBonjour;   ❌ Ne fonctionne pas
?>

Ordre de déclaration ⚠️

<?php
// Déclarer AVANT d'appeler
function saluer() {
    echo "Salut !\n";
}

saluer();  // ✅ Fonctionne
?>

Conventions de nommage 📏

function calculerMoyenne() { }
function afficherMenu() { }
function envoyerEmail() { }
function validerFormulaire() { }

function f() { }           // Trop court
function Calculer() { }    // Majuscule (convention)
function calculer-prix() { } // Tiret interdit
function 2fonction() { }   // Chiffre au début

Bonnes pratiques de nommage 🎯

• ✅ camelCase : calculerPrixTTC()
• ✅ Verbes d'action : calculer, afficher, envoyer, valider
• ✅ Noms descriptifs : doit expliquer ce que fait la fonction
• ✅ En français ou anglais : mais cohérent dans tout le projet

↩️ Partie 3

Return : Valeur de retour

Récupérer un résultat

Qu'est-ce que return ? ↩️

Sans return :

<?php
function afficherMessage() {
    echo "Hello !\n";
    // Pas de return = ne renvoie rien
}

afficherMessage();  // Affiche "Hello !"
?>

Fonction avec return

<?php
// Fonction qui RETOURNE un résultat
function addition($a, $b) {
    $resultat = $a + $b;  // On calcule
    return $resultat;      // On RENVOIE le résultat
    // La fonction s'arrête ici
}

// Récupérer le résultat dans une variable
$total = addition(5, 3);  // $total reçoit 8
echo $total;              // Affiche : 8

// On peut aussi utiliser directement sans stocker
echo addition(10, 20);    // Affiche : 30

// On peut réutiliser le résultat dans des calculs
$somme1 = addition(5, 5);   // 10
$somme2 = addition(3, 7);   // 10
$final = $somme1 + $somme2; // 20
echo $final;                // Affiche : 20
?>

Return arrête la fonction ⛔

<?php
function tester() {
    echo "Ligne 1\n";    // ✅ S'exécute
    echo "Ligne 2\n";    // ✅ S'exécute
    
    return "Fin";        // ⛔ STOP ! La fonction s'arrête ici
    
    echo "Ligne 3\n";    // ❌ Ne s'exécutera JAMAIS
    echo "Ligne 4\n";    // ❌ Ne s'exécutera JAMAIS
}

$resultat = tester();
// Affichera dans le terminal :
// Ligne 1
// Ligne 2
// (Ligne 3 n'apparaît jamais)

echo $resultat;  // Affiche : Fin

// Utilité : sortir rapidement d'une fonction
function diviser($a, $b) {
    if ($b == 0) {
        return "Erreur : division par zéro";  // Sort immédiatement
    }
    return $a / $b;  // Ne s'exécute que si $b != 0
}
?>

Return vs echo 🤔

<?php
// AVEC ECHO : affiche directement, ne retourne rien
function avecEcho() {
    echo "Résultat : 10";  // Affiche immédiatement à l'écran
    // Pas de return = la fonction ne renvoie rien (null)
}

avecEcho();  // Affiche : Résultat : 10
$x = avecEcho();  // Affiche "Résultat : 10" mais $x = null
// echo $x;  // Afficherait : (rien, null)

echo "---\n";

// AVEC RETURN : renvoie une valeur, n'affiche rien
function avecReturn() {
    return 10;  // Renvoie la valeur 10, n'affiche rien
}

$y = avecReturn();  // $y reçoit 10, rien n'est affiché
echo "Résultat : $y\n";  // Affiche : Résultat : 10

// On peut réutiliser $y dans des calculs
$double = $y * 2;  // 20
echo $double;      // Affiche : 20
?>

Quand utiliser return ? 🎯

Types de retour

<?php
// Retourner un nombre
function getAge() {
    return 25;
}

// Retourner une chaîne
function getNom() {
    return "Marie";
}

// Retourner un booléen
function estMajeur($age) {
    return $age >= 18;
}

// Retourner un tableau
function getCoordonnees() {
    return [48.8566, 2.3522];
}
?>

📦 Partie 4

Paramètres et arguments

Passer des données aux fonctions

Paramètre vs Argument 🤔

<?php
// DÉCLARATION de la fonction
function saluer($prenom) {  // $prenom = PARAMÈTRE
    // $prenom est une variable qui RECEVRA une valeur
    echo "Bonjour $prenom !\n";
}

// APPELS de la fonction
saluer("Marie");  // "Marie" = ARGUMENT (valeur concrète)
// "Marie" est copié dans $prenom, puis la fonction s'exécute

saluer("Jean");   // "Jean" = ARGUMENT
// "Jean" est copié dans $prenom, puis la fonction s'exécute

// On peut passer une variable comme argument
$nom = "Sophie";
saluer($nom);     // La VALEUR de $nom ("Sophie") est copiée
                  // dans $prenom de la fonction
?>

Fonction sans paramètre

<?php
function afficherDate() {
    echo date("Y-m-d") . "\n";
}

afficherDate();  // Pas d'argument
?>

Fonction avec 1 paramètre

<?php
function carre($nombre) {
    return $nombre * $nombre;
}

echo carre(5);   // Affiche : 25
echo carre(10);  // Affiche : 100

$x = 7;
echo carre($x);  // Affiche : 49
?>

Fonction avec plusieurs paramètres

<?php
// Fonction avec 2 paramètres
function addition($a, $b) {
    // $a reçoit le 1er argument
    // $b reçoit le 2ème argument
    return $a + $b;
}

echo addition(5, 3);   // $a=5, $b=3 → 8
echo addition(10, 20); // $a=10, $b=20 → 30

// Fonction avec 3 paramètres
function presenteProduit($nom, $prix, $stock) {
    // $nom reçoit le 1er argument (string)
    // $prix reçoit le 2ème argument (nombre)
    // $stock reçoit le 3ème argument (nombre)
    echo "Produit : $nom\n";
    echo "Prix : $prix€\n";
    echo "Stock : $stock\n";
}

// Appel avec les 3 arguments dans l'ordre
presenteProduit("Ordinateur", 899, 15);
// $nom = "Ordinateur"
// $prix = 899
// $stock = 15
?>

Ordre des arguments ⚠️

<?php
function division($a, $b) {
    // $a = numérateur (nombre du haut)
    // $b = dénominateur (nombre du bas)
    return $a / $b;
}

// Bon ordre : 10 divisé par 2
echo division(10, 2);  // $a=10, $b=2 → 10/2 = 5 ✅

// Mauvais ordre : 2 divisé par 10
echo division(2, 10);  // $a=2, $b=10 → 2/10 = 0.2 ⚠️
// Le résultat est différent !

// Autre exemple plus critique
function inscrire($nom, $prenom, $email) {
    echo "$prenom $nom - $email\n";
}

// Bon ordre : tout est correct
inscrire("Dupont", "Marie", "marie@email.com");
// $nom="Dupont", $prenom="Marie", $email="marie@email.com"
// Affiche : Marie Dupont - marie@email.com ✅

// Mauvais ordre : catastrophe !
inscrire("marie@email.com", "Dupont", "Marie");
// $nom="marie@email.com", $prenom="Dupont", $email="Marie"
// Affiche : Dupont marie@email.com - Marie ❌
// Complètement mélangé !
?>

Nombre d'arguments variable

<?php
function addition($a, $b) {
    return $a + $b;
}

addition(5);       // ❌ Erreur : manque un argument
addition(5, 3, 7); // ❌ Erreur : trop d'arguments
?>

⚙️ Partie 5

Valeurs par défaut

Paramètres facultatifs

Qu'est-ce qu'une valeur par défaut ? 🎯

<?php
// $nom a une valeur par défaut : "Visiteur"
function saluer($nom = "Visiteur") {
    echo "Bonjour $nom !\n";
}

// Appel AVEC argument : on utilise l'argument fourni
saluer("Marie");  
// $nom reçoit "Marie"
// Affiche : Bonjour Marie !

// Appel SANS argument : on utilise la valeur par défaut
saluer();
// Aucun argument fourni → $nom prend la valeur "Visiteur"
// Affiche : Bonjour Visiteur !

// Le paramètre devient facultatif :
// - Si on donne un argument → il est utilisé
// - Si on ne donne rien → la valeur par défaut est utilisée
?>

Syntaxe des valeurs par défaut

<?php
// $prixHT est obligatoire (pas de défaut)
// $tauxTVA est facultatif (défaut = 20)
function calculerTVA($prixHT, $tauxTVA = 20) {
    // Calcul : prix HT + (prix HT * taux / 100)
    return $prixHT + ($prixHT * $tauxTVA / 100);
}

// CAS 1 : Taux personnalisé (TVA réduite)
echo calculerTVA(100, 5.5);
// $prixHT = 100
// $tauxTVA = 5.5 (on a fourni un argument)
// Résultat : 105.5

// CAS 2 : Taux par défaut (TVA normale)
echo calculerTVA(100);
// $prixHT = 100
// $tauxTVA = 20 (valeur par défaut car pas d'argument)
// Résultat : 120

// Utilité : la plupart du temps on utilise 20%,
// donc on peut l'omettre et le préciser seulement
// quand c'est différent (5.5%, 10%, etc.)
?>

Plusieurs valeurs par défaut

<?php
// $nom est obligatoire
// $role et $actif sont facultatifs
function creerUtilisateur($nom, $role = "user", $actif = true) {
    echo "Nom : $nom\n";
    echo "Rôle : $role\n";
    echo "Actif : " . ($actif ? "Oui" : "Non") . "\n";
}

// CAS 1 : Tous les arguments fournis
creerUtilisateur("Marie", "admin", false);
// $nom = "Marie"
// $role = "admin" (on remplace le défaut)
// $actif = false (on remplace le défaut)

// CAS 2 : Seulement l'argument obligatoire
creerUtilisateur("Jean");
// $nom = "Jean"
// $role = "user" (valeur par défaut)
// $actif = true (valeur par défaut)
// Affiche : Nom: Jean, Rôle: user, Actif: Oui

// CAS 3 : Argument obligatoire + premier facultatif
creerUtilisateur("Paul", "moderator");
// $nom = "Paul"
// $role = "moderator" (on le précise)
// $actif = true (valeur par défaut)
?>

Ordre des paramètres ⚠️

<?php
// ❌ MAUVAIS (défaut avant obligatoire)
function mauvais($nom = "Test", $age) {
    // Erreur !
}

// ✅ BON (défaut après obligatoire)
function bon($age, $nom = "Test") {
    echo "$nom a $age ans\n";
}

bon(25);         // Test a 25 ans
bon(30, "Marie"); // Marie a 30 ans
?>

Valeurs par défaut de différents types

<?php
// String
function message($texte = "Aucun message") {
    echo $texte . "\n";
}

// Nombre
function multiplier($nombre, $facteur = 2) {
    return $nombre * $facteur;
}

// Booléen
function afficherListe($tableau, $triee = false) {
    if ($triee) {
        sort($tableau);
    }
    print_r($tableau);
}

// Null
function rechercher($id, $cache = null) {
    if ($cache === null) {
        echo "Pas de cache\n";
    }
}
?>

Paramètres nommés (PHP 8+) 🆕

<?php
function inscription($nom, $email, $role = "user", $actif = true) {
    // Code...
}

// Ancienne méthode (ordre important)
inscription("Marie", "marie@email.com", "user", true);

// Nouvelle méthode PHP 8+ (ordre libre)
inscription(
    nom: "Marie",
    email: "marie@email.com",
    actif: false,
    role: "admin"
);
?>

📚 Partie 6

Lire la documentation PHP

Comprendre les signatures de fonctions

Pourquoi lire la documentation ? 📖

• 🔍 Découvrir les fonctions disponibles
• 📝 Comprendre les paramètres requis
• 💡 Voir des exemples d'utilisation
• ⚠️ Connaître les valeurs de retour
• 📊 Identifier les versions PHP compatibles

Qu'est-ce qu'une signature ? ✍️

Exemple de signature dans la doc :

On y trouve :

• Le nom de la fonction
• Les paramètres attendus
• Les types acceptés
• Le type de retour

Décomposer une signature 🔍

Analyse :

• substr = Nom de la fonction
• string $string = 1er paramètre (obligatoire, type string)
• int $offset = 2ème paramètre (obligatoire, type int)
• ?int $length = null = 3ème paramètre (facultatif, nullable)
• : string = Retourne un string

Les symboles importants 📌

Exemple 1 : strlen() 📏

Lecture de la signature :

• Fonction : strlen
• Paramètre : $string (type string, obligatoire)
• Retour : int (nombre entier)
• Pas de valeur par défaut = paramètre obligatoire

Utilisation :

<?php
// strlen() compte le nombre de caractères
$longueur = strlen("Bonjour");
// "Bonjour" a 7 caractères → retourne 7
echo $longueur;  // 7

// Exemples supplémentaires
echo strlen("Hello");     // 5
echo strlen("A");         // 1
echo strlen("");          // 0 (chaîne vide)
echo strlen("Bob Smith"); // 10 (l'espace compte)

// strlen() attend obligatoirement 1 string
// strlen();  ❌ Erreur : argument manquant
?>

Exemple 2 : round() 🔢

Lecture de la signature :

• $num : int OU float (obligatoire) - le nombre à arrondir
• $precision : int, défaut = 0 (facultatif) - nombre de décimales
• $mode : int, défaut = PHP_ROUND_HALF_UP (facultatif) - méthode d'arrondi
• Retourne : float - le nombre arrondi

<?php
// Sans précision : arrondit à l'entier le plus proche
echo round(3.14159);  
// $num = 3.14159, $precision = 0 (défaut)
// Résultat : 3 (0 décimale)

// Avec 2 décimales
echo round(3.14159, 2);
// $num = 3.14159, $precision = 2
// Résultat : 3.14

// Avec 3 décimales
echo round(3.14159, 3);
// $num = 3.14159, $precision = 3
// Résultat : 3.142

// Le 3ème paramètre est rarement utilisé
// On peut l'ignorer dans 99% des cas
?>

Exemple 3 : array_filter() 🔍

Lecture :

• $array : tableau (obligatoire)
• $callback : fonction (nullable, facultatif)
• $mode : int, défaut = 0 (facultatif)
• Retourne : array

<?php
$nombres = [1, 2, 3, 4, 5];
$pairs = array_filter($nombres, function($n) {
    return $n % 2 == 0;
});
print_r($pairs);  // [2, 4]
?>

Comment chercher dans la doc ? 🔍

1. Allez sur php.net/manual/fr/
2. Utilisez la barre de recherche
3. Tapez le nom de la fonction
4. Lisez la signature en haut
5. Regardez les exemples
6. Vérifiez les notes et warnings

Exercice de lecture 📖

Exercice de lecture : Réponse ✅

<?php
$texte = "rouge,vert,bleu";
$couleurs = explode(",", $texte);
print_r($couleurs);
// Array ( [0] => rouge [1] => vert [2] => bleu )
?>

📄 Partie 7

Fichiers CSV

Lire et écrire des données tabulaires

Qu'est-ce qu'un fichier CSV ? 📄

Exemple de contenu CSV :

nom,prenom,age,ville
Dupont,Marie,25,Paris
Martin,Jean,30,Lyon
Durand,Sophie,28,Marseille

Caractéristiques :

• Valeurs séparées par des virgules (ou point-virgule)
• Une ligne = Un enregistrement
• Première ligne = En-têtes (souvent)

Pourquoi utiliser les CSV ? 🎯

• 📊 Import/Export de données (Excel, Google Sheets)
• 💾 Stockage simple de données structurées
• 🔄 Échange entre applications
• 📈 Analyse de données
• 🗂️ Backup de bases de données

Lire un fichier CSV : fgetcsv() 📖

Paramètres importants :

• $stream : fichier ouvert avec fopen()
• $separator : délimiteur (virgule par défaut)

Exemple : Lire un CSV

Fichier : utilisateurs.csv

nom,prenom,age
Dupont,Marie,25
Martin,Jean,30

Code PHP :

<?php
// 1. Ouvrir le fichier en mode lecture ("r" = read)
$fichier = fopen("utilisateurs.csv", "r");

// 2. Lire ligne par ligne avec une boucle
while (($ligne = fgetcsv($fichier)) !== false) {
    // fgetcsv() lit UNE ligne et la transforme en tableau
    // $ligne est un tableau indexé avec les valeurs de la ligne
    print_r($ligne);
    // Boucle continue tant qu'il y a des lignes à lire
    // Quand on arrive à la fin, fgetcsv() retourne false
}

// 3. TOUJOURS fermer le fichier
fclose($fichier);

// Résultat affiché :
// Array ( [0] => nom [1] => prenom [2] => age )
// Array ( [0] => Dupont [1] => Marie [2] => 25 )
// Array ( [0] => Martin [1] => Jean [2] => 30 )
?>

Résultat de la lecture

Array ( [0] => nom [1] => prenom [2] => age )
Array ( [0] => Dupont [1] => Marie [2] => 25 )
Array ( [0] => Martin [1] => Jean [2] => 30 )

Ignorer la première ligne (en-têtes)

<?php
$fichier = fopen("utilisateurs.csv", "r");

// ASTUCE : Sauter la première ligne (en-têtes)
// On appelle fgetcsv() UNE fois sans stocker le résultat
fgetcsv($fichier);
// Cette ligne lit "nom,prenom,age" et la jette (on n'en fait rien)

// Maintenant on lit les vraies données
while (($ligne = fgetcsv($fichier)) !== false) {
    // Accès aux valeurs par index
    echo "Nom : {$ligne[0]}\n";      // Colonne 0 = nom
    echo "Prénom : {$ligne[1]}\n";   // Colonne 1 = prenom
    echo "Âge : {$ligne[2]}\n";      // Colonne 2 = age
    echo "---\n";
}

fclose($fichier);

// Résultat affiché :
// Nom : Dupont
// Prénom : Marie
// Âge : 25
// ---
// Nom : Martin
// Prénom : Jean
// Âge : 30
// ---
?>

CSV avec point-virgule ;

En France, souvent ; au lieu de ,

nom;prenom;age
Dupont;Marie;25
Martin;Jean;30

Spécifier le séparateur :

<?php
$fichier = fopen("utilisateurs.csv", "r");

while (($ligne = fgetcsv($fichier, 0, ";")) !== false) {
    print_r($ligne);
}

fclose($fichier);
?>

Écrire dans un fichier CSV : fputcsv() ✍️

Paramètres :

• $stream : fichier ouvert en écriture
• $fields : tableau de valeurs à écrire
• $separator : délimiteur

Exemple : Écrire un CSV

<?php
// 1. Ouvrir en mode écriture ("w" = write)
// ⚠️ "w" ÉCRASE le fichier s'il existe déjà !
$fichier = fopen("export.csv", "w");

// 2. Écrire l'en-tête (première ligne)
// fputcsv() prend un TABLEAU et le transforme en ligne CSV
fputcsv($fichier, ["nom", "prenom", "age"]);
// Écrit : nom,prenom,age

// 3. Écrire les données ligne par ligne
fputcsv($fichier, ["Dupont", "Marie", 25]);
// Écrit : Dupont,Marie,25

fputcsv($fichier, ["Martin", "Jean", 30]);
// Écrit : Martin,Jean,30

fputcsv($fichier, ["Durand", "Sophie", 28]);
// Écrit : Durand,Sophie,28

// 4. TOUJOURS fermer le fichier
fclose($fichier);

echo "Fichier créé !\n";

// Le fichier export.csv contient maintenant :
// nom,prenom,age
// Dupont,Marie,25
// Martin,Jean,30
// Durand,Sophie,28
?>

Résultat : export.csv

nom,prenom,age
Dupont,Marie,25
Martin,Jean,30
Durand,Sophie,28

Ajouter des lignes (mode append)

<?php
// Mode "a" = append (ajouter à la fin)
// ✅ "a" N'ÉCRASE PAS le contenu existant
$fichier = fopen("export.csv", "a");

// Ajouter une nouvelle ligne à la fin du fichier
fputcsv($fichier, ["Leroy", "Paul", 35]);
// Cette ligne s'ajoute APRÈS les lignes existantes

fclose($fichier);

echo "Ligne ajoutée !\n";

// Si export.csv contenait :
// nom,prenom,age
// Dupont,Marie,25
// Martin,Jean,30
//
// Il contient maintenant :
// nom,prenom,age
// Dupont,Marie,25
// Martin,Jean,30
// Leroy,Paul,35  ← AJOUTÉ
?>

Exporter un tableau en CSV

<?php
// Tableau de données (tableau multidimensionnel)
$utilisateurs = [
    ["Dupont", "Marie", 25, "Paris"],
    ["Martin", "Jean", 30, "Lyon"],
    ["Durand", "Sophie", 28, "Marseille"]
];

// Ouvrir le fichier
$fichier = fopen("utilisateurs.csv", "w");

// Écrire l'en-tête
fputcsv($fichier, ["nom", "prenom", "age", "ville"]);

// Parcourir le tableau avec foreach
foreach ($utilisateurs as $utilisateur) {
    // $utilisateur est un tableau : ["Dupont", "Marie", 25, "Paris"]
    // fputcsv() transforme ce tableau en ligne CSV
    fputcsv($fichier, $utilisateur);
}

fclose($fichier);

// Fichier créé : utilisateurs.csv
// nom,prenom,age,ville
// Dupont,Marie,25,Paris
// Martin,Jean,30,Lyon
// Durand,Sophie,28,Marseille
?>

Lire et traiter un CSV

<?php
$fichier = fopen("utilisateurs.csv", "r");

// Lire l'en-tête
$entetes = fgetcsv($fichier);

// Stocker dans un tableau associatif
$utilisateurs = [];

while (($ligne = fgetcsv($fichier)) !== false) {
    $utilisateurs[] = [
        "nom" => $ligne[0],
        "prenom" => $ligne[1],
        "age" => (int)$ligne[2],
        "ville" => $ligne[3]
    ];
}

fclose($fichier);
print_r($utilisateurs);
?>

Gestion des erreurs 🛡️

<?php
$fichier = fopen("donnees.csv", "r");

if ($fichier === false) {
    die("Erreur : Impossible d'ouvrir le fichier\n");
}

while (($ligne = fgetcsv($fichier)) !== false) {
    // Vérifier que la ligne a le bon nombre de colonnes
    if (count($ligne) < 3) {
        echo "Ligne invalide ignorée\n";
        continue;
    }
    
    // Traiter la ligne
    print_r($ligne);
}

fclose($fichier);
?>

Bonnes pratiques CSV 🎯

• ✅ Toujours fermer les fichiers avec fclose()
• ✅ Vérifier que fopen() a réussi
• ✅ Gérer l'encodage (UTF-8 recommandé)
• ✅ Échapper les valeurs avec guillemets si nécessaire
• ✅ Valider le nombre de colonnes
• ⚠️ Attention aux virgules dans les données
• ⚠️ Attention aux sauts de ligne dans les valeurs

💪 Partie 8

Exercices pratiques

À vous de jouer !

Exercice 1 : Fonction simple

Exercice 1 : Corrigé ✅

<?php
function doubler($nombre) {
    return $nombre * 2;
}

// Tests
echo doubler(5);   // 10
echo doubler(10);  // 20
echo doubler(7.5); // 15

$x = 12;
echo doubler($x);  // 24
?>

Exercice 2 : Plusieurs paramètres

Exercice 2 : Corrigé ✅

<?php
function calculerMoyenne($note1, $note2, $note3) {
    $total = $note1 + $note2 + $note3;
    $moyenne = $total / 3;
    return $moyenne;
}

// Test
$resultat = calculerMoyenne(15, 12, 18);
echo "Moyenne : $resultat\n";  // Moyenne : 15

// Autre test
echo calculerMoyenne(10, 14, 16);  // 13.333...
?>

Exercice 3 : Valeur par défaut

Exercice 3 : Corrigé ✅

<?php
function direBonjour($nom, $heure = "journée") {
    echo "Bonjour $nom, bonne $heure !\n";
}

// Tests
direBonjour("Marie");
// Affiche : Bonjour Marie, bonne journée !

direBonjour("Jean", "soirée");
// Affiche : Bonjour Jean, bonne soirée !

direBonjour("Sophie", "matinée");
// Affiche : Bonjour Sophie, bonne matinée !
?>

Exercice 4 : Fonction avec validation

Exercice 4 : Corrigé ✅

<?php
function estMajeur($age) {
    return $age >= 18;
}

// Tests
var_dump(estMajeur(15));  // bool(false)
var_dump(estMajeur(18));  // bool(true)
var_dump(estMajeur(25));  // bool(true)

// Utilisation dans une condition
if (estMajeur(20)) {
    echo "Accès autorisé\n";
} else {
    echo "Accès refusé\n";
}
?>

Exercice 5 : Lire un CSV

nom,prix,stock
Ordinateur,899,15
Souris,25,50
Clavier,45,30

Exercice 5 : Corrigé ✅

<?php
$fichier = fopen("produits.csv", "r");

if ($fichier === false) {
    die("Erreur d'ouverture\n");
}

// Sauter l'en-tête
fgetcsv($fichier);

// Lire et afficher
while (($ligne = fgetcsv($fichier)) !== false) {
    echo "Produit : {$ligne[0]}\n";
    echo "Prix : {$ligne[1]}€\n";
    echo "Stock : {$ligne[2]} unités\n";
    echo "---\n";
}

fclose($fichier);
?>

Exercice 6 : Écrire un CSV

Exercice 6 : Corrigé ✅

<?php
function exporterEtudiants($tableau, $nomFichier) {
    $fichier = fopen($nomFichier, "w");
    
    if ($fichier === false) {
        return false;
    }
    
    // En-tête
    fputcsv($fichier, ["nom", "prenom", "moyenne"]);
    
    // Données
    foreach ($tableau as $etudiant) {
        fputcsv($fichier, $etudiant);
    }
    
    fclose($fichier);
    return true;
}

// Test
$etudiants = [
    ["Dupont", "Marie", 15],
    ["Martin", "Jean", 14],
    ["Durand", "Sophie", 16]
];

exporterEtudiants($etudiants, "etudiants.csv");
echo "Export réussi !\n";
?>

Exercice bonus 🌟

Exercice bonus : Corrigé ✅

<?php
function calculerPrixTTC($prixHT, $tauxTVA = 20) {
    $prixTTC = $prixHT * (1 + $tauxTVA / 100);
    return round($prixTTC, 2);
}

function exporterProduits($produits, $fichier) {
    $f = fopen($fichier, "w");
    fputcsv($f, ["nom", "prixHT", "prixTTC"]);
    
    foreach ($produits as $produit) {
        $nom = $produit[0];
        $prixHT = $produit[1];
        $prixTTC = calculerPrixTTC($prixHT);
        fputcsv($f, [$nom, $prixHT, $prixTTC]);
    }
    
    fclose($f);
}

// Test
$produits = [["Ordinateur", 899], ["Souris", 25]];
exporterProduits($produits, "catalogue.csv");
?>

Récapitulatif 🎯

Ce que vous avez appris :

• ✅ Fonctions : déclaration avec function
• ✅ Appel : nomFonction(arguments)
• ✅ Return : renvoyer un résultat
• ✅ Paramètres : passer des données
• ✅ Valeurs par défaut : paramètres facultatifs
• ✅ Documentation : lire les signatures
• ✅ CSV : fgetcsv() et fputcsv()

Syntaxe à retenir 📝

<?php
// Déclaration
function nomFonction($param1, $param2 = "défaut") {
    // Code
    return $resultat;
}

// Appel
$valeur = nomFonction("arg1", "arg2");

// CSV - Lecture
$f = fopen("fichier.csv", "r");
$ligne = fgetcsv($f);
fclose($f);

// CSV - Écriture
$f = fopen("fichier.csv", "w");
fputcsv($f, ["col1", "col2"]);
fclose($f);
?>

Bonnes pratiques 💡

• ✅ Noms de fonctions descriptifs
• ✅ Une fonction = Une tâche
• ✅ Paramètres avec défauts à la fin
• ✅ Toujours fermer les fichiers (fclose)
• ✅ Vérifier que fopen() a réussi
• ✅ Documenter vos fonctions complexes
• ✅ Utiliser return plutôt que echo

Prochaines étapes 🚀

1. 📦 Scope des variables : globales vs locales
2. 🔄 Fonctions variables et anonymes
3. 📚 Include/Require : organiser le code
4. 🗄️ Bases de données : PDO et MySQL
5. 🎨 POO : Classes et méthodes

Ressources utiles 📚

• 📖 php.net/manual/fr/ : Documentation officielle
• 🔍 php.net/nomfonction : Doc d'une fonction
• 💡 PHP The Right Way : Bonnes pratiques
• 🎓 W3Schools PHP : Tutoriels
• 📄 RFC 4180 : Spécification CSV