Cheatsheet : PHP
CheatSheet PHP : Guide complet, résumé, aide-mémoire, tutoriel et conseils clés pour apprendre et maîtriser PHP efficacement et rapidement.
12 chapitres
Commentaire
copié !
// Je suis un commentaire
/* Je suis un commentaire
sur plusieurs lignes */
Debug
copié !
Infos détaillées (type, valeur, structure…) sur une variable.
var_dump($maVariable);
Variable
copié !
Case mémoire stockant une donnée.
$firstname = "Toto";
$firstname = "Tutu"; // Ecrase la valeur précédente
// Non modifiable
const RATIO = 6.55;
define("RATIO", 6.55); // équivalent
- Types principaux : texte, nombre et booléen
define()ne peut pas être utilisée dans une classe
Affichage
copié !
Afficher du texte/variables.
// Texte
echo "Hello World";
// Variable
$firstname = "Toto";
echo $firstname;
Concaténation
copié !
Joindre plusieurs chaînes de caractères et/ou variables.
$firstname = "Toto";
echo "Hello " . $firstname; // "Hello Toto"
Opération
copié !
$a = 4;
$b = 7;
$addition = $a + $b; // Addition (11)
$soustraction = $b - $a; // Soustraction (3)
$multiplication = $a * $b; // Multiplication (28)
$division = $b / $a; // Division (1.75)
$modulo = $b % $a; // Reste de la division (3)
- Si
nombre % 2 = 0=> pair et sinombre % 2 = 1=> impair - Opérations complexes => fonctions
sqrt(),exp()…
Tableau
copié !
Structure de données regroupant un ensemble de valeurs.
// Tableau unidimensionnel (indéxé par 0, 1... n)
$fruits = ["Salade", "Tomate", "Oignon"];
echo $fruits[0]; // "Salade"
// Tableau unidimensionnel (associatif)
$user = [
"firstname" => "John",
"lastname" => "Doe",
"premium" => true,
];
echo $user['lastname']; // "Doe"
// Tableau multidimensionnel
$fruits = [
["Salade", 1.90],
["Tomate", 2.75],
["Oignon", 1]
];
echo $fruits[1][1]; // 2.75
Premier élément d’un tableau à l’indice 0
If, Else
copié !
Conditionne l’exécution d’un script.
$dice = 5;
if ($dice == 1) {
// Il vaut mieux relancer le dé...
} else if ($dice > 1 && $dice <= 3) {
// C'est mieux ...
} elseif ($dice > 3 && $dice <= 5) {
// Pas mal !
} else {
// Super !
}
- Opérateurs de comparaison :
==,===,!=,!==,>,>=,<et<= - Opérateurs logiques :
!,&&et|| - Il est possible d’imbriquer des conditions entre elles
Switch
copié !
Conditionne l’exécution d’un script.
$fruit = "Banane";
switch ($fruit) {
case 'Banane':
echo $fruit . " (1.93 € / kg)";
break;
case 'Pomme':
echo $fruit . " (2.62 € / kg)";
break;
case 'Mangue':
case 'Papaye':
echo $fruit . " (6.17 € / kg)";
break;
default:
echo "Désolé, nous ne vendons pas de " . $fruit;
}
casedéclenché si valeur strictement égale (===) à l’expression duswitch- Plusieurs
caseà la suite signifient « ou » breaktermine l’instructiondefaultexécuté si aucune correspondance avec lescase
For
copié !
Répète une instruction plusieurs fois.
// 0, 1, 2, 3 ... 10
for ($i=0; $i<=10; $i++) {
echo $i
}
$i=0: point de départ$i<=10: point d’arrivée$i++: pas (ou « step ») - raccourci pour$i=$i+1- Alternative
foreach()utile pour boucler sur des tableaux - Il est possible d’imbriquer des boucles entre elles
While
copié !
Répète une instruction tant qu’une condition est vraie.
$n = 0;
while ($n < 10) {
$n++;
}
echo $n; // 10
Il est possible d’imbriquer des boucles entre elles
Fonction
copié !
Une portion de code isolée exécutable sur demande.
// Déclaration
function isEven(int $number): bool {
return $number % 2 === 0;
}
// Appels
echo isEven(7); // false
echo isEven(8); // true
$number: paramètre de la fonction (typé enint):boolindique que la fonction retourne un booléenreturn ...: valeur retournée par la fonction (facultatif)7et8: arguments (valeurs transmises à un paramètre)
Inclusions
copié !
Insère le contenu d’un fichier dans un autre.
// Si fichier à inclure non trouvé => warning (script continu son exécution)
include('path/to/my/file.php');
// Comme `include` + ne réinclut pas un fichier déja inclus auparavant
include_once('path/to/my/file.php');
// Si fichier à inclure non trouvé => erreur (script arrêté)
require('path/to/my/file.php');
// Comme `require` + ne réinclut pas un fichier déja inclus auparavant
require_once('path/to/my/file.php');
include('path/to/my/file.php') peut être écrit include 'path/to/my/file.php'
Paramètres GET
copié !
Transmet des informations au serveur afin de récupérer des ressources.
// Considérons l'URL https://domaine.com/page?param1=toto¶m2=tutu
// Récupère un paramètre GET
$_GET['param1']; // "toto"
$_GET['param2']; // "tutu"
- Paramètres
GETtransitent via l’URL - Signe
?devant le 1er paramètre et signe&devant chaque suivant - Formulaire HTML envoyé en
GET=>$_GET['attribut-name-du-champ'] $_GET= variable superglobale (accessible de partout)
Paramètres POST
copié !
Transmet des informations au serveur pour traitement.
// Récupère un paramètre POST
echo $_POST['demo'];
- Paramètres
POSTtransitent via le corps de la requête HTTP - Formulaire envoyé en
POST=>$_POST['attribut-name-du-champ'] $_POST= variable superglobale (accessible de partout)
Session
copié !
Stockage temporaire côté serveur pour persister des données entre plusieurs pages.
// Démarrer une session / charger une session existante
session_start();
// Déclaration d'une variable de session
$_SESSION['username'] = "Toto";
// Affichage d'une variable de session
echo $_SESSION['username'];
// Détruire une variable de session spécifique
unset($_SESSION['username']);
// Détruire l'ensemble des variables de session
$_SESSION = array();
// Détruire la session en elle-même
session_destroy();
session_start()(début du script PHP) avant d’utiliser les sessions$_SESSION= variable superglobale (accessible de partout)- Session automatiquement détruite à la fermeture du navigateur
Connexion
copié !
Connexion à une base de données.
try {
/*
Paramètre 1 : chaîne de connexion
Paramètre 2 : nom de l'utilisateur
Paramètre 3 : mot de passe utilisateur
*/
$db = new PDO(
'mysql:host=localhost;dbname=nom_bdd;charset=utf8;port=3307',
'root',
''
);
} catch (PDOException $e) {
die('Erreur : ' . $e->getMessage());
}
Si non précisée, la valeur du port par défaut est 3306
Récupération
copié !
Récupérer des données.
$db = new PDO(...);
$query = $db->query("SELECT ...");
// Récupère plusieurs résultats
$articles = $query->fetchAll();
// Récupère un seul résultat
$article = $query->fetch();
query()exécute une requêteSQLde lecturefetch()récupère un seul résultat etfetchAll()récupère plusieurs résultats
Insertion
copié !
Insérer des données.
$db = new PDO(...);
$query = $db->exec("INSERT INTO ...");
exec() exécute une requête SQL d’écriture
Modification
copié !
Modifier des données.
$db = new PDO(...);
$query = $db->exec("UPDATE ...");
exec() : exécute une requête SQL d’écriture
Suppression
copié !
Supprimer des données.
$db = new PDO(...);
$query = $db->exec("DELETE FROM ...");
exec() exécute une requête SQL d’écriture
Requête préparée
copié !
Sécuriser ses requêtes dynamiques (injections SQL).
$db = new PDO(
'mysql:host=localhost;dbname=nom_bdd;charset=utf8',
'root',
''
);
// ⚠️ Injection SQL
$query = $db->exec("DELETE FROM articles WHERE id = " . $id);
// ✅ Requête préparée
$query = $pdo->prepare("DELETE FROM articles WHERE id = :id");
$query->bindParam(':id', $id, PDO::PARAM_INT);
$query->execute();
:id=> marqueur indiquant l’emplacement d’un paramètre dynamique dans la requêteprepare()+execute()viennent remplacer les méthodesquery()ouexec()bindParam()permet d’attacher des paramètres aux marqueurs:x
Sécurisation XSS
copié !
Se protéger des failles XSS.
$maVariable = "<script src='https://pirate.com/attaque.js'></script>";
// ⚠️ Le script sera exécuté dans la page
echo $maVariable;
// Affiche <script src='https://pirate.com/attaque.js'></script>
// ✅ Le script sera converti en entité HTML et donc non exécuté
echo htmlspecialchars($maVariable);
// Affiche : <script src='https://pirate.com/attaque.js'></script>
Autoload
copié !
Chargement automatique des classes.
spl_autoload_register(function (string $class): void {
require($class . '.php');
});
Déclarer une classe
copié !
Représentation abstraite d’un élément partageant des caractéristiques communes.
class Character {
// Attributs (caractéristiques)
private int $id;
private string $pseudo;
private int $xp;
const XP_MAX = 1000;
// Méthodes (actions/comportement)
// Constructeur
public function __construct(
int $id,
string $pseudo,
int $xp
) {
$this->id = $id;
$this->pseudo = $pseudo;
$this->xp = $xp;
}
// Getters (accesseurs)
public function getId(): int {
return $this->id;
}
public function getPseudo(): string {
return $this->pseudo;
}
public function getXp(): int {
return $this->xp;
}
// Setters (mutateurs)
public function setPseudo(string $pseudo): void {
$this->pseudo = $pseudo;
}
public function setXp(int $xp): void {
$this->xp = $xp;
}
// Méthode perso
public function infos(): string {
return "Je suis " . $this->pseudo . " et j'ai " . $this->xp . "/" . self::XP_MAX . " points d'expérience.";
}
}
- Constructeur : initialise les attributs d’un objet lors de sa création
- Getter : retourne la valeur d’un attribut
- Setter : modifie la valeur d’un attribut
$thisfait référence à l’objet courantselffait référence à la classe courante- Encapsulation : accès aux attributs
privatecontrôlé par des méthodespublic - Classe dans un fichier
.phpdu même nom (enPascalCase) - Jamais de
setId()car unidest immuable - Nom de constante en
UPPERCASE(ex:XP_MAX)
Créer un objet
copié !
Créer un objet à partir d’une classe.
$perso1 = new Character(1, "Toto", 450);
// Accès à un attribut public (⚠️ encapsulation)
echo "Je suis " . $perso1->pseudo;
// Appel d'une méthode public
echo "Je suis " . $perso1->getPseudo();
echo "J'ai " . $perso1->getXp() . "/" . Character::XP_MAX . " XP";
newpermet de créer un objet à partir d’une classe (= instanciation)- Instancier une classe revient implicitement à appeler
__construct() - L’opérateur
->permet d’accéder à un attribut/une méthode - Accéder à une constante :
NomClasse::NOM_CONSTANTE
Visibilité
copié !
Détermine l’accès aux attributs et méthodes.
class Character {
private string $attribut1;
public string $attribut2;
protected string $attribut3;
}
private: accessible depuis la classepublic: accessible de partout (classe + objets instanciés)protected: commeprivate+ accessible depuis classes filles
Classe enfant
copié !
Classe qui hérite des attributs d’une classe parente.
class Wizard extends Character {
private int $magicPower;
public function __construct(
int $id,
string $pseudo,
int $xp,
int $magicPower
) {
parent::__construct($id, $pseudo, $xp);
$this->magicPower = $magicPower;
}
public function castSpell(): int {
$minPower = $this->magicPower;
$maxPower = $this->magicPower * 2;
return random_int($minPower, $maxPower);
}
}
parentfait référence à la classe parenteextendsindique qu’une classe enfant hérite d’une classe parente
Classe parente
copié !
Modèle commun partagé par d’autres classes.
abstract class Character {
// Attributs
protected int $id;
protected string $pseudo;
protected int $xp;
const XP_MAX = 1000;
// Constructeur
public function __construct(
int $id,
string $pseudo,
int $xp
) {
$this->id = $id;
$this->pseudo = $pseudo;
$this->xp = $xp;
}
// ...
}
- Classes enfants pourront accéder aux attributs
protected - classe
abstract=> ne peut pas être instanciée
Static
copié !
Accéder à un attribut/méthode sans instancier la classe.
class Car {
// ...
public static int $counter = 0;
public function __construct(
int $id,
string $brand,
string $model
) {
$this->id = $id;
$this->brand = $brand;
$this->model = $model;
self::$counter++;
}
// ...
public static function getCounter() {
return self::$counter;
}
}
echo Car::$counter;
echo Car::getCounter();
self::pour accéder à un élémentstaticdepuis la classeNOM_CLASSE::pour accéder à un élémentstaticdepuis un objet