FlorenceBuchelet/PHP_FR.md

## PHP_FR.md

      
    Raw
  

              PHP_FR.md
            
          
    PHP

PHP est un langage impératif (instructions, affectations, boucles, conditions, branchements (break, return, try/catch)) orienté objet, conçu pour la création d'applications webs dynamiques. Il est généralement associé à un serveur Apache.
PHP est libre, gratuit, accessible et multiplateforme.
📨 Le projet sur lequel je travaille étant en Magento 1 avec un conteneur Docker en PHP 7.3, cette doc évitera d'aller au delà de ce que cette version de PHP propose.
Bases

define('MY_CONST', 'value') permet de définir une constante globale, disponible partout dans le code et qui ne peut pas être redéfinie.
const MY_CONST = 'value'; définit également une constante (syntaxe moderne) mais pas nécessairement globale (scopée à un fichier ou à une class).
Une variable est définie lors de sa première affectation : $var = 1, et peut être réaffectée.
Tableaux et Objets

Les tableaux PHP ont une dimension en plus de celle en JS qui les rapprochent davantage du concept d'object literal que d'array.
// Deux concepts distincts en JS :
$array = ["item_1", "item_2", "item_3"]; // array indexé
$object = { 
    name: "item_1",
    age: "item_2",
    job: "item_3"
}; // object literal
// En PHP, les deux sont des arrays :
$array = ["item_1", "item_2", "item_3"]; // array indexé
$array = [
    "name" => "item_1",
    "age" => "item_2",
    "job" => "item_3"
]; // tableau associatif
Un tableau peut également être mixte (indexé et associatif).
Le concept d'objet en PHP renvoie à la POO et donc à l'instance d'une classe.
Conditions

Conditions classiques (if, elseif, else)

if ($expression) {
    // instructions
}
if ($expression) {
    // instructions
} elseif ($secondExpression) {
    // instructions
} else {
    // instructions
}
// Un early return peut remplacer un else 
function showExpression($expression) {
    if (!$expression) {
        return "No expression";
    }
    return $expression;
}
En HTML

<?php if ($expression): ?>
<p>Affiché si $expression est vraie</p>
<?php else: ?>
<p>Affiché si $expression est fausse</p>
<?php endif; ?>
Ternaire

$result = $expression ? "L'expression est truthy" : "L'expression est falsy";
$result = $expression ?: "L'expression est falsy";
    // si $expression est truthy, $result === $expression, sinon $result === "L'expression est falsy".
    // !! si $expression n'est pas set, alors throw une erreur

$result = $expression ?? "L'expression est falsy";
    // si $expression n'est pas définie ou null, $result === "L'expression est falsy".
    // si $expression est définie, $result === $expression.

$result = $expression && "L'expression est truthy";
    // si $expression est truthy, $result === "L'expression est truthy".
    // sinon, $result === false;
switch

switch ($day) {
    case "monday":
        echo "I work";
        break;
    case "friday":
        echo "I'm in love";
        break;
    default: 
        echo "I play video games";
}
La structure match a été introduite en PHP 8, nous ne nous y attarderons donc pas ici.
Boucles

for

for ($i = 1; $i <= 10; $i++) {
    echo $i;
}
// a partir de $i = 1 et tant que $i est inférieur ou égal à 10, on incrémente $i à chaque tour de boucle
foreach

// Pour chaque item dans array, do something
// Chaque élément dans array devient un item sur lequel la boucle va agir
$array = ["item_1", "item_2", "item_3"];
foreach ($array as $item) {
    // instructions;
    echo $item;
}

// Même chose mais avec une paire clef/valeur plutôt que juste un item
foreach ($array as $index => $item) {
    // instructions
    echo "$index : $item";
}
while

Teste une condition avant chaque itération. La condition doit être établie en amont et évoluer dans la boucle pour éviter les boucle infinie. L'incrémentation n'est pas automatique comme dans une boucle for.
$i = 0;
while ($i < 10) {
    // instructions
    $i++;
}
do ... while

$i = 0;
do {
    echo $i;
} while ($i > 0);
une boucle while est plus flexible qu'une boucle for mais demande aussi plus de setup.
Fonctions

function name ($value, $value_2 = 1) use ($otherValue): bool {
    // use permet d'utiliser des variables externes
    return $value != $otherValue;
}

Les fonctions peuvent être anonymes.
Un argument assigné dans la définition de la fonction est optionnel.
On peut appeler une fonction par son nom entre guillemets 'call' pour une fonction globale, sinon avec [$this, 'maMethode'] dans le cas de callbacks.
Une variable static dans une fonction garde sa valeur entre les appels et n'est initialisée qu'une seule fois même si la fonction est appelée plusieurs fois.

POO

abstract class Vehicle {
    protected $speed = 0;

    public function accelerate() {
        $this->speed += 10;
        echo "Vitesse : $this->speed km/h<br>";
    }
}
interface Boostable {
    public function booster();
}

trait Turbo {
    public function turboBoost() {
        echo "Turbo activé !";
    }
}

class Kart extends Vehicle implements Boostable {
    use Turbo;

    public $name;
    protected $nitro;

    public function __construct($name) {
        $this->name = $name;
        $this->nitro = 1;
    }

    public function booster() {
        echo "Kart boosté avec $this->nitro nitro(s) !";
    }
}

class : Plan pour créer un objet avec ses propriétés et méthodes. Instanciée avec new ou getModel().
interface : Un contrat qui oblige les classes qui l'implémentent à déclarer certaines méthodes.
implements : Lie une classe à une interface.
abstract class : Une classe qui ne peut pas être instanciée directement. Elle sert de base à d'autres classes et peut contenir des méthodes définies ou abstraites.
extends (héritage) : Permet à une classe d'hériter des propriétés et méthodes d'une autre classe.
public : Propriété accessible partout.
private : Propriété accessible uniquement dans la classe où elle est déclarée.
protected : Propriété accessible dans la classe qui la déclare ainsi que dans ses classes filles mais pas à l'extérieur.
function (méthode) : Une méthode est une fonction rattachée à une classe.
__construct : Méthode magique appelée automatiquement à l'instanciation de l'objet. Un constructeur n'est obligatoire que si on souhaite initialiser les propriétés de la classe, leur donner des valeurs initiales. Le nom __construct() est standardisé et réservé.
trait : Bloc de code PHP contenant des méthodes qu'on peut réutiliser dans plusieurs classes, sans utiliser l’héritage. Utilisé avec le mot-clé use.
static : Lié à la classe plutôt qu'à l'objet instancié. On peut y accéder sans instancier d'objet.

Méthodes magiques

Elles commencent par __ et existent automatiquement dans certains contextes en PHP. Elles permettent de surcharger le comportement par défaut des objets.
💡 Méthode (contexte d'appel) : ce qu'elle fait.

__construct() (à l'instanciation) : injecte des valeurs aux propriétés de l'objet.
__destruct() (à la destruction de l'objet) : exécute du code juste après la destruction de l'objet.
__toString() (à la conversion).
__get($name) (lorsqu'on accède à une propriété innexistante (ou private/protected)) : permet de définir le comportement qui doit se produire et d'éviter l'erreur normalement lancée.
__set($name, $value) (lors de l'assignation d'une valeur inexistante) : même principe que pour __get().

Existent aussi, entre autres : __isset($name), __unset($name) ou encore __call($name, $arguments).
Namespace

Permet de trier le code dans des "boîtes" pour éviter les conflits de noms entre classes, fonctions ou constantes (ex. User).
On utilise le mot-clef réservé use pour importer d'autres classes, interfaces, traits ou fonctions définis dans d'autres namespaces.
// Syntaxe : déclaration de namespace (toujours en haut du fichier).
namespace App\Models;

class User {
    public $name;    
}
// Syntaxe : import.
use App\Models\User;

$user = new User();
Si un fichier a besoin d'être placé dans un namespace et d'importer d'autres classes, on déclare namespace en premier puis on liste les use. Un fichier qui ne fait qu'exécuter du code qui n'a pas vocation à être importé ailleurs n'a pas besoin de déclarer de namespace.
Fonctions utilitaires (et leurs équivalents en JS)

str_replace() / preg_replace() (.replace()) : Remplace toutes les occurrences d’une chaîne par une autre.
str_replace($search, $replace, $subject);
preg_replace($pattern, $replace, $subject); // avec regex

exemple : 
$variable = "c h a u s s e t t e";
$result = str_replace(" ", "", $variable);
// $result === "chaussette"
explode() / str_split() (.split()) : Découpe une chaîne en un tableau à partir d’un délimiteur.
explode($separator, $string, $limiter?);
// le limiter (délimiteur) est optionnel
// Il peut être positif (la chaine est séparée en fonction du separator un certain nombre de fois)
// ou négatif (la chaine est séparée en fonction du separator et les derniers éléments sont supprimés (le dernier si le limiter = -1))

str_split($string); // Découpe une chaîne en tableau sans délimiteur
implode() (.join()) : Concatène les éléments d’un tableau en une chaîne avec un séparateur.
implode($separator, $array); // $separator doit être un string
substr() (.substr() / .substring()) : Extrait une sous-chaîne à partir d’une position donnée.
substr($string, $start, $length?);

$result = substr("chaussette", 0, 5); // "chauss"
$result = substr("chaussette", -3);   // "tte"
strlen() (.length) : Retourne la longueur d’une chaîne.
$result = strlen("chaussette"); // 10
$result = strlen("chaussette") - 1; // 9
strpos() (.indexOf()) : Recherche la position de la première occurrence d’une sous-chaîne.
strpos($haystack, $needle, $offset): int | false;
str_repeat() : Répète un certain nombre de fois ($times) une string ($string).
str_repeat($string, $times);
strtolower() (.toLowerCase()) : Convertit une chaîne en minuscules.
strtoupper() (.toUpperCase()) : Convertit une chaîne en majuscules.
ucfirst() / ucwords() : Met en majuscule la première lettre d'un mot (ucfirst) ou la première lettre de chaque mot d'une string (ucwords).
strrev() : inverse une chaîne de caractères.
trim(), ltrim(), rtrim() (.trim(), .trimStart(), .trimEnd()) : Suppriment les espaces ou autres caractères en début et/ou fin de chaîne.
array_merge() (.concat()) : Fusionne un ou plusieurs tableaux en un seul.
$result = array_merge($array_1, $array_2);
in_array() (.includes()) : Vérifie si une valeur existe dans un tableau et retourne un booléen.
in_array($needle, $haystack); // $haystack doit être un array
in_array($needle, $haystack, boolean); // ce boolean correspond au mode strict qui vérifie aussi que le type correspond s'il est set à true
array_push() / $array[] = $var; (.push()) : Ajoute un ou plusieurs éléments à la fin d’un tableau.
array_push($array, $values): int;
// Il peut y avoir plusieurs values ($value_1, $value_2)
// Retourne le nombre d'éléments dans le tableau
// Retourne une erreur si $array n'est pas un tableau

$array[] = $var;
// Ajoute $var à la fin du tableau
// !! Ajoute un seul élément à la fin du tableau
// Ne retourne rien
// Crée un nouveau tableau si $array n'est pas un tableau
array_unshift() (.unshift()) : Ajoute un ou plusieurs éléments au début d’un tableau.
array_unshift($array, $values): int;
// Peut ajouter plusieurs values ($value_1, $value_2)
array_pop() (.pop()) : Supprime et retourne le dernier élément d’un tableau.
array_shift() (.shift()) : Supprime et retourne le premier élément d’un tableau.
count() (.length) : Compte le nombre d’éléments dans un tableau.
array_slice() (.slice()) : Extrait une portion d’un tableau.
array_slice($array, int $offset, int $length?, bool $preserve_keys?): array;
array_splice() (.splice()) : Supprime une portion d’un tableau et peut la remplacer par d’autres éléments.
array_splice(
    array &$array,
    int $offset,
    ?int $length = null,
    mixed $replacement = []
): array;
array_map() (.map()) : Applique une fonction sur chacun des éléments d’un tableau.
array_map(
    $callback, // fonction nommée avant array_map ou anonyme et définie dans la map
    $array
);
Le call de la callback nommée se fait entre guillemets: 'call' pour une fonction globale ou [$this, 'maMethode'].
array_filter() (.filter()) : Filtre les éléments d’un tableau à l’aide d’une fonction de rappel.
array_filter($array, $callback?): array
// Si aucune callback n'est passée, les entrées vides du tableau seront supprimées
// Si la callback retourne true, la valeur est retournée dans un tableau
preg_match() / preg_match_all() (.match()) : Recherche une correspondance avec une expression régulière dans une chaîne. Preg_match cherche la première correspondance, preg_match_all les cherche toutes.
preg_match($pattern, $subject, $matches?, $flags?, $offset?): int | false;
    // retourne 1 ou 0 selon s'il y a un match ou non, false si erreur
preg_match_all($pattern, $subject, $matches?, $flags?, $offset?)
    // retourne le nombre d'occurences du pattern et les rassemble dans l'array $matches en fonction de $flags et $offset
json_encode() (JSON.stringify()) : Convertit une valeur PHP en chaîne JSON.
json_decode() (JSON.parse()) : Transforme une chaîne JSON en variable PHP.
die() / exit() (process.exit()) : Termine l’exécution du script.
isset() (typeof variable !== "undefined") : Vérifie si une variable est définie (non null) et n’est pas undefined.
empty() : Retourne true si la variable n'existe pas ou est falsy.
max() : Retourne la plus grande valeur parmis les arguments qui lui sont soumis.
abs() : Retourne la valeur absolue d'un nombre (similaire à (* -1)).
assert() : Vérifie que la comparaison passée est vraie.
usort() : Trie un tableau en fonction d'une comparaison personnalisée.
usort($array, $callback);
Sujets divers

Printing variables

Il y a plusieurs méthodes pour loguer des variables selon le type de variable et le formatage désiré.
/* Strings */
echo $string;
print $string; // retourne toujours 1, contrairement à echo
print_r($string); // informations mises en forme
var_dump($string); // informations détaillées (type, taille, valeur)

/* Arrays et objets */
echo // ne peut pas imprimer un array (Warning: Array to string conversion) mais donne son type
print_r($array); // informations lisibles
$result = print_r($array, true); // le résultat est stocké sous forme de string
var_dump($array); // print l'associative array (key => value) et ses infos (longueur, longueur des strings)
echo json_encode($array); // transforme l'array en json, plus lisible

/* Autres print utiles */
var_export($variable); // Mise en forme en code PHP, peut aussi être stocké dans une variable en lui ajoutant un paramètre true
Les fonctions utilitaires d'impression de variables ne sautent pas de lignes entre elles, il faut echo "<br>"; entre deux pour forcer une mise en page.
PHP_EOL permet de faire un saut de ligne en console.
Les balises <pre> permettent de conserver la mise en forme de l'objet.
echo "<pre>";
print_r($array);
echo "</pre>";
💡 echo a aussi une syntaxe courte <?= $variable ?> qui correspond à <?php echo $variable ?>.
Try/catch

La syntaxe try/catch + throw error est sensiblement la même en PHP et en JS, elle permet de gérer proprement les erreurs en les capturant, sans faire planter toute l'app.
try {
    $filePath = sys_get_temp_dir() . '/' . $this->_inputFile;

    if (!file_exists($filePath)) {
        throw new \Exception("Le fichier d'import '{$this->_inputFile}' n'existe pas dans le dossier temporaire : " . sys_get_temp_dir());
    }
} catch (Exception $e) {
    // Log l'exception dans var/log/exception.log
    Mage::logException($e);
}
A noter : \Exception (avec antislash) indique à Magento d'utiliser la classe native Exception et non celle définie pour le namespace courant.
Divers divers

<=> : opérateur "spaceship", opérateur de comparaison combinée, introduit en PHP 7. Il compare deux valeurs et retourne :

-1 si la première est inférieure à la seconde
0 si elles sont égales
1 si la première est supérieure à la seconde

Il est souvent utilisé avec usort() pour trier des valeurs.
Magento 1.5

Magento repose sur une architecture MVC et un système de surcharge.
Il fonctionne en blocs (classes) qui héritent des blocs coeur de Magento (ex. Mage_Core_Block_Template ou Mage_Core_Block_Abstract).
Autoload spécifique

Mage::getModel('catalog/product'); // charge automatiquement Mage_Catalog_Model_Product
Il n'est pes necessaire de faire des require manuels.
Conventions de nommage

Magento charge les classes automatiquement en fonction de leur nom en suivant la structure Namespace_Module_Dossier_Fichier.
Mage_Catalog_Model_Product
// = app/code/core/Mage/Catalog/Model/Product.php
Architecture


app/code/core : Code source à surcharger, ne jamais modifier directement.
app/code/community : Modules tiers.
app/code/local : Modules personnalisés qui surcharegnt les deux précédents.
app/design/frontend : Thèmes (.phtml et .xml).
app/etc/module : Fichiers .xml qui déclarent les modules.
var/ : Cache, sessions.

Magento sépare les responsabilités :

un model ou classe (Mage_Catalog_Model_Product) représente l'objet métier instanciable
le resource model (Mage_Catalog_Model_Resource_Product) gère les requêtes SQL liées à cet objet
la collection (Mage_Catalog_Model_Resource_Product_Collection) gère une liste d'objets.

Méthodes héritées

Héritées de Mage :

Mage est la classe centrale de Magento (app/Mage.php), c'est le singleton (une seule instance possible) qui donne accès aux composants du framework.

Mage::app() : Initilialise et retourne l'application.
Mage::getModel('module/class) : Retourne une nouvelle instance d'une classe (équivalent à new).
Mage::getsingleton('module/class) : Retourne une instance unique et partagée (singleton) d'une classe.
Mage::getResourcemodel('module/class) : Retourne le resource model (gestion de base) associé.
Mage::helper('module/helper) : Retourne un helper.
Mage::getStoreConfig('chemin/config') : Récupère une configuration dans le fichier system.xml.
Mage::dispatchEvent() : Déclenche un évènment (event observer).

Héritées de Mage_Core_Block_Abstract :

Méthodes pour les blocs qui gèrent l'affichage front et back.

setData($key, $value) : Assigne une seule donnée au bloc.
getData($key = null) : Récupère une donnée (ou toutes si aucun argument passé). $key correspond au champ demandé.
hasData($key) : Vérifie si une donnée existe.
unsetData($key) : Supprime une donnée.
assign() : Permet d'assigner des données à un bloc.
toHtml() : Render le bloc en HTML (appelé automatiquement dans les templates).
getChildHtml($alias) : Récupère le HTML d’un bloc enfant via son alias.
setChild($alias, $bloc) : Ajoute un bloc enfant avec un alias.
getLayout() : Récupère l'objet de layout (parent).
getTemplate() : Récupère le template .phtml du bloc.
setTemplate($tpl) : Définit le template .phtml à utiliser pour le bloc.

A noter : l'alias est une clef de référence appliquée à un bloc enfant pour y accéder plus facilement plus tard. setChild($alias, $bloc) définit l'alias et getChildHtml($alias) accède au bloc grâce à lui.
// Dans un bloc
$this->setChild('mon_texte', $this->getLayout()->createBlock('core/text')->setText('Coucou'));
// Dans le .phtml
<?php echo $this->getChildHtml('mon_texte'); ?>
Héritées de Mage_Core_Model_Abstract :

Méthodes de resource models via Mage::getResourcemodel('core').

load($id, $field?) : Charge l'objet depuis la base. $field correspond au champ de la table utilisée dans la recherche. Si $field n'est pas précisé, c'est l'ID.
save() : Sauvegarde l'objet (insert/update).
delete() : Supprime l'objet.
addData(array $data) : Assigne plusieurs valeurs à la fois.
getData($key?) : Récupère la donnée $key ou toutes les données si $key est null.
setData($key, $value) : Définit la donnée $key.
getId() : Récupère l'ID de l'objet.
setId($id) : Définit l'ID de l'objet.
getResource() : Retourne le resource model lié.
getResourceCollection() : Retourne la collection liée.
hasDataChangedFor($key) : Indique si une donnée a changé (pour savoir s'il faut enregistrer par exemple). La $key correspond au nom du champ à surveiller.
isObjectNew() : Vérifie si l'objet est nouveau (pas encore en base).
getOrigData($key?) : Récupère les données d'origine avant modification.

Héritées de Mage_Core_Helper_Abstract :

Méthodes de helpers via Mage::helper('core').

__('texte à traduire') : Traduction (internationalisation).
isModuleEnabled($moduleName) : Vérifie si un module est activé.
urlEncode($data) : Trim/encode une URL pour s'assurer que le lien ne contienne que des caractères valides.
htmlEscape($data) : Échappe les caractères spéciaux HTML pour éviter des failles XSS.
getStoreConfig($path) : Récupère une config dans system.xml.
formatDate(), formatTime() : Formatent des dates/temps.

Héritées de Mage_Core_Controller_Front_Action :

Méthodes de contrôleurs.

$this->_redirect($url) : Redirige vers une autre page.
$this->loadLayout() : Charge le layout défini en XML.
$this->renderLayout() : Render le layout chargé.
$this->_initLayoutMessages() : Initialise les messages de session.
$this->getRequest() : Retourne l’objet de la requête (ex. $_GET, $_POST).
$this->getResponse() : Retourne l’objet de réponse HTTP (ex. header).
$this->_getSession() : Récupère la session du module courant.
No results found