Aller au contenu principal

Module PHP.4 – Types & données

Objectif​

Maîtriser tous les types de données PHP : types scalaires, null, conversions de types, et comprendre le typage faible vs strict.

Théorie​

Types scalaires​

int (entier)​

$nombre = 42;
$negatif = -15;
$zero = 0;
$grand = 1000000;

Caractéristiques :

  • Pas de limite de taille pratique (64 bits)
  • Peut être décimal, hexadécimal, octal, binaire
$decimal = 42;
$hexa = 0x2A;      // 42 en hexadécimal
$octal = 052;      // 42 en octal
$binaire = 0b101010; // 42 en binaire

Fonctions utiles :

is_int($nombre);      // Vérifier si c'est un entier
intval($valeur);       // Convertir en entier
(int) $valeur;         // Cast vers entier

float (décimal)​

$prix = 19.99;
$temperature = -5.5;
$scientifique = 1.5e3;  // 1500

Précision :

  • Précision limitée (problèmes d'arrondi connus)
  • Pour l'argent, utiliser des entiers (centimes) ou des bibliothèques spécialisées

Fonctions utiles :

is_float($valeur);
floatval($valeur);
(float) $valeur;
round($nombre, 2);     // Arrondir à 2 décimales
number_format($prix, 2); // Formater : 19.99

string (chaîne de caractères)​

$simple = 'Simple guillemets';
$double = "Double guillemets";
$heredoc = <<<EOT
Texte sur
plusieurs lignes
EOT;

Différences guillemets :

$nom = "Jean";

// Double guillemets : interpolation
echo "Bonjour $nom";        // Bonjour Jean
echo "Bonjour {$nom}";      // Bonjour Jean (recommandé)

// Simple guillemets : littéral
echo 'Bonjour $nom';        // Bonjour $nom

// Échappement
echo "Il a dit \"Bonjour\"";  // Il a dit "Bonjour"
echo 'Il a dit \'Bonjour\'';  // Il a dit 'Bonjour'

Fonctions string courantes :

$texte = "Bonjour le monde";

strlen($texte);              // Longueur : 17
strtoupper($texte);          // "BONJOUR LE MONDE"
strtolower($texte);          // "bonjour le monde"
ucfirst($texte);             // "Bonjour le monde"
substr($texte, 0, 7);        // "Bonjour"
str_replace("monde", "PHP", $texte); // "Bonjour le PHP"
trim($texte);                // Enlève espaces début/fin
explode(" ", $texte);        // ["Bonjour", "le", "monde"]

bool (booléen)​

$vrai = true;
$faux = false;

Valeurs considérées comme false :

  • false
  • 0 (entier)
  • 0.0 (float)
  • "" (chaîne vide)
  • "0" (chaîne "0")
  • [] (tableau vide)
  • null

Tout le reste est considéré comme true.

Fonctions :

is_bool($valeur);
(bool) $valeur;

null​

null représente l'absence de valeur.

$variable = null;
$variable = NULL;  // Même chose (insensible à la casse)

Utilisations :

  • Variable non initialisée
  • Variable explicitement vidée
  • Valeur par défaut

Vérification :

is_null($variable);
$variable === null;  // Comparaison stricte recommandée
isset($variable);     // Vérifie si existe et n'est pas null

Différence isset() vs is_null() :

$var1 = null;
$var2;  // Non définie

isset($var1);   // false
isset($var2);   // false

is_null($var1); // true
is_null($var2); // true (mais génère un warning)

Conversion de types​

Conversion explicite (cast) :

$nombre = (int) "42";        // 42
$texte = (string) 42;        // "42"
$bool = (bool) 1;            // true
$float = (float) "3.14";     // 3.14

Fonctions de conversion :

intval($valeur);     // Vers entier
floatval($valeur);   // Vers float
strval($valeur);     // Vers string
boolval($valeur);    // Vers booléen

Conversion automatique (coercion) :

$resultat = "5" + 3;     // 8 (conversion automatique)
$resultat = "5" . 3;     // "53" (concaténation)
$resultat = "5" * "3";   // 15 (multiplication)

Typage faible vs strict​

Typage faible (par défaut) : PHP convertit automatiquement les types selon le contexte.

$nombre = "5";
$resultat = $nombre + 3;  // 8 (conversion automatique)

$age = "25";
if ($age > 18) {  // "25" converti en 25
    echo "Majeur";
}

Typage strict (déclaré) : Depuis PHP 7.0, on peut déclarer un typage strict.

Activer le typage strict :

<?php
declare(strict_types=1);

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

additionner(5, 3);      // OK : 8
additionner("5", 3);    // Erreur : type string non accepté

Types de déclaration :

// Paramètres typés
function calculer(int $a, float $b): float {
    return $a + $b;
}

// Retour typé
function obtenirNom(): string {
    return "Jean";
}

// Propriétés typées (PHP 7.4+)
class Personne {
    public string $nom;
    public int $age;
}

Types disponibles pour déclaration :

  • int, float, string, bool
  • array
  • object
  • ?type (nullable) : ?string = string ou null
  • Classes/interfaces
  • void (pas de retour)
  • mixed (PHP 8.0+)

Vérification de types​

Fonctions is_ :*

is_int($valeur);
is_float($valeur);
is_string($valeur);
is_bool($valeur);
is_array($valeur);
is_object($valeur);
is_null($valeur);
is_numeric($valeur);    // Vérifie si numérique (int, float, ou string numérique)

gettype() :

gettype(42);        // "integer"
gettype(3.14);      // "double"
gettype("texte");   // "string"
gettype(true);      // "boolean"
gettype(null);      // "NULL"

var_dump() : Affiche le type et la valeur (utile pour déboguer) :

var_dump(42);
// int(42)

var_dump("Jean");
// string(4) "Jean"

Exercice​

  1. Types scalaires

    • Créez des variables de chaque type (int, float, string, bool)
    • Testez les fonctions is_* pour vérifier les types
    • Utilisez var_dump() pour voir les détails

  2. Conversions

    • Testez les conversions explicites (cast)
    • Testez les conversions automatiques
    • Observez les résultats

  3. Typage strict

    • Créez une fonction avec typage strict
    • Testez avec les bons types
    • Testez avec les mauvais types (observez les erreurs)

  4. Manipulation de strings

    • Créez une chaîne de caractères
    • Testez au moins 5 fonctions string différentes
    • Concaténez plusieurs chaînes

  5. Null et vérifications

    • Créez des variables null
    • Testez isset(), is_null(), empty()
    • Comprenez les différences

Quiz​

  1. Quelle fonction vérifie si une variable est un entier ?

    • is_integer()
    • is_int()
    • check_int()

  2. Que retourne (int) "3.14" ?

    • 3.14
    • 3
    • "3"

  3. Que signifie le typage strict en PHP ?

    • Plus rapide
    • Les types doivent correspondre exactement
    • Moins d'erreurs

  4. Quelle est la différence entre isset() et is_null() ?

    • Aucune différence
    • isset() vérifie existence et non-null, is_null() seulement null
    • is_null() est plus rapide

  5. Que fait gettype() ?

    • Convertit le type
    • Retourne le nom du type
    • Vérifie le type

Mini défi​

Mission : Créer un système de validation de types

Créez un script PHP qui valide et convertit différents types de données :

Fonctionnalités :

  1. Fonction de validation

    • validerEntier($valeur) : Vérifie et convertit en entier
    • validerFloat($valeur) : Vérifie et convertit en float
    • validerString($valeur) : Vérifie et nettoie la chaîne
    • validerBool($valeur) : Vérifie et convertit en booléen

  2. Fonction de conversion sécurisée

    • convertirType($valeur, $type) : Convertit vers un type spécifique
    • Gère les erreurs gracieusement
    • Retourne null si conversion impossible

  3. Tests

    • Testez avec différentes valeurs
    • Testez les cas limites (null, chaînes vides, etc.)
    • Affichez les résultats de manière claire

Exemple d'utilisation :

$entier = validerEntier("42");      // 42
$entier = validerEntier("abc");     // null ou valeur par défaut
$float = validerFloat("19.99");     // 19.99
$string = validerString("  Test  "); // "Test" (trim)

Critères :

  • ✅ Toutes les fonctions de validation créées
  • ✅ Gestion des erreurs appropriée
  • ✅ Code bien documenté
  • ✅ Tests complets avec différents cas
  • ✅ Utilisation de typage strict si possible

Objectif : Maîtriser les types PHP et savoir les valider et convertir correctement.

Validation : Vous pouvez passer au module suivant quand vous maîtrisez tous les types PHP et leurs conversions.