La syntaxe

PHP ressemble à du C avec un $ devant chaque variable, -> pour les membres et . pour concaténer les chaînes. Si vous lisez du Java, du JavaScript ou du C#, vous lisez déjà du PHP, et le reste de ce chapitre est la liste des endroits où vos doigts vont taper la mauvaise chose.

Un fichier, de haut en bas

<?php
declare(strict_types=1);

$name = 'world';
$count = 3;

echo "Hello, {$name}!", PHP_EOL;
echo 'Hello, ' . $name . '! Count: ' . $count . PHP_EOL;

Le fichier s’ouvre sur <?php. Tout ce qui précède cette balise, même une ligne vide, part tel quel dans la sortie, parce que PHP a commencé sa vie comme langage de gabarits. Un fichier qui ne contient que du code s’ouvre sur <?php et ne referme jamais la balise, parce qu’un ?> final suivi d’un saut de ligne oublié ferait fuir ce saut de ligne dans votre réponse HTTP.

declare(strict_types=1); vient ensuite, sur sa propre ligne, et désactive la conversion automatique des arguments scalaires dans les appels faits depuis ce fichier. Le système de types explique précisément ce que cette ligne couvre et ce qu’elle ne couvre pas ; pour l’instant, mettez-la dans chaque fichier, et considérez un fichier qui ne l’a pas comme un fichier portant un panneau d’avertissement.

Les variables commencent par $ et ne se déclarent jamais : vous affectez, et la variable existe, sans let, sans var et sans type devant. Les noms de variables sont sensibles à la casse, alors que les noms de fonctions et de classes ne le sont pas, même si personne ne s’appuie sur cette tolérance.

Les instructions se terminent par un point-virgule. echo prend une liste séparée par des virgules et l’affiche, print fait la même chose avec un seul argument et se voit rarement, et PHP_EOL est le saut de ligne de la plateforme.

Les chaînes

L’opérateur de concaténation est ., pas +. Écrire $a + $b avec deux chaînes pousse PHP à les additionner comme des nombres, ce qui donne une TypeError pour des chaînes non numériques sous PHP 8.

Les guillemets simples vous donnent les octets que vous avez tapés, tandis que les guillemets doubles interpolent les variables et traduisent les séquences comme \n. Entourez d’accolades tout ce qui dépasse une simple variable :

<?php
declare(strict_types=1);

$user = ['name' => 'Ada'];
$items = 3;

echo "Hi {$user['name']}, you have {$items} items\n";
echo 'Hi {$user[name]}\n'; // printed literally, backslash included

Pour du texte sur plusieurs lignes, un heredoc interpole et un nowdoc n’interpole pas. Le marqueur de fin peut être indenté (depuis PHP 7.3), et cette indentation est retirée de chaque ligne :

<?php
declare(strict_types=1);

$title = 'Report';

$html = <<<HTML
    <h1>{$title}</h1>
    <p>Generated by PHP</p>
    HTML;

$raw = <<<'TXT'
    No {$interpolation} in here.
    TXT;

echo $html, PHP_EOL, $raw, PHP_EOL;

Trois flèches

PHP a trois symboles en forme de flèche, et leurs rôles ne se recouvrent jamais. -> entre dans une instance, comme dans $user->name ou $user->save(). :: entre dans une classe, comme dans User::create(), User::MAX_AGE ou self::$count. => associe une clé à une valeur dans un tableau littéral ou une branche de match, comme dans ['id' => 1].

<?php
declare(strict_types=1);

final class Money
{
    public const string CURRENCY = 'EUR'; // typed constant, PHP 8.3

    public function __construct(public readonly int $cents)
    {
    }

    public static function zero(): self
    {
        return new self(0);
    }
}

$price = new Money(1999);
echo $price->cents, ' ', Money::CURRENCY, ' ', Money::zero()->cents, PHP_EOL;
// 1999 EUR 0

Dans une méthode, l’instance courante est $this. Les classes et les objets ont leur propre chapitre, Les classes, et cet exemple montre seulement quelle flèche va où.

L’égalité

Utilisez ===, et considérez == comme un opérateur hérité. Le double égal convertit les deux côtés vers un type commun avant de comparer, ce qui a produit les absurdités célèbres du vieux PHP. Depuis PHP 8, un nombre comparé à une chaîne non numérique est comparé comme une chaîne, donc 0 == 'foo' vaut false, mais '1' == '01' vaut toujours true : le comportement est plus sain qu’avant, et reste un jeu de devinettes. Le triple égal compare la valeur et le type, sans rien deviner.

La même règle vaut pour !== contre !=, et pour in_array() et array_search(), qui prennent un troisième argument true pour comparer strictement.

<=> est l’opérateur vaisseau spatial : il renvoie -1, 0 ou 1, et existe pour les fonctions de tri.

Null, en trois opérateurs

<?php
declare(strict_types=1);

$config = ['debug' => null, 'owner' => null];

$debug = $config['debug'] ?? false;      // false: ?? treats null like missing
$config['level'] ??= 'info';             // assign only if null or missing
$length = $config['owner']?->name;       // null, no error: nullsafe chain
$mode = $config['debug'] ? 'on' : 'off'; // plain ternary, same as everywhere

var_dump($debug, $config['level'], $length, $mode);

?? est la coalescence de null, et il avale aussi « clé indéfinie » et « variable indéfinie », ce qui en fait la façon idiomatique de lire une entrée optionnelle d’un tableau. ??= n’affecte que si le côté gauche est null ou absent, et ?-> (PHP 8.0) arrête une chaîne d’appels au premier null et renvoie null. Le ternaire abrégé ?: existe aussi ($a ?: $b renvoie $a s’il est vrai au sens large) ; il convient aux booléens et trompe avec tout le reste.

Le flux de contrôle, d’un seul coup

<?php
declare(strict_types=1);

$scores = ['ada' => 92, 'linus' => 71, 'grace' => 85];

foreach ($scores as $who => $score) {
    if ($score >= 90) {
        $grade = 'A';
    } elseif ($score >= 80) {
        $grade = 'B';
    } else {
        $grade = 'C';
    }
    echo "{$who}: {$grade}", PHP_EOL;
}

for ($i = 0; $i < 3; $i++) {
    echo $i;
}
echo PHP_EOL;

$attempts = 0;
while ($attempts < 3) {
    $attempts++;
}

$label = match (true) {
    $attempts === 0 => 'never tried',
    $attempts < 3 => 'a few tries',
    default => 'gave it everything',
};
echo $label, PHP_EOL;

Rien ici ne demande d’explication, à part deux détails. foreach est la boucle des tableaux et de tout itérable, et elle vous donne la clé et la valeur ensemble avec as $key => $value. match est une expression qui compare avec ===, ne tombe pas dans la branche suivante et lève une exception si rien ne correspond, alors que switch, que vous trouverez dans le code ancien, compare avec == et enchaîne les branches. Énumérations et match montre à quoi sert match.

Trois panneaux côte à côte : une flèche marquée -> pointe vers un objet unique, une flèche marquée :: pointe vers le plan d'une classe, et une double flèche marquée => relie une carte clé à une carte valeur

Tout le reste sur un écran

<?php
declare(strict_types=1);

namespace App\Billing;         // one per file, mirrors the folder

use App\Money;                 // import a class from another namespace
use function App\format_cents; // functions and constants can be imported too

const TAX_RATE = 0.2;          // compile-time constant, namespaced
define('LEGACY', true);        // runtime constant, global, older style

// one-line comment
# also a one-line comment, rarer
/* block
   comment */

/**
 * Docblock: read by editors, PHPStan and Psalm, not by PHP itself.
 */
function total(int ...$cents): int
{
    return array_sum($cents);
}

$parts = [100, 250];
echo total(...$parts), PHP_EOL; // 350: ... unpacks on both sides

... déplie un tableau en arguments et, dans une liste de paramètres, rassemble le reste dans un tableau. Les arguments nommés (total(cents: 5)) existent depuis 8.0. null est une valeur, en minuscules par convention, comme true et false. Les espaces de noms et use font exactement ce que vous attendez des packages Java ou des imports ES, et Namespaces, Composer et autoloading explique comment les fichiers sont trouvés.

Côte à côte

	Python	JavaScript	Java	PHP
Concaténation	`a + b`	`a + b`	`a + b`	`$a . $b`
Égalité stricte	`a == b`	`a === b`	`a.equals(b)`	`$a === $b`
Coalescence de null	`a or b`	`a ?? b`	(aucun)	`$a ?? $b`
Accès sûr au membre	(aucun)	`a?.b`	(aucun)	`$a?->b`
Lambda	`lambda x: x * 2`	`x => x * 2`	`x -> x * 2`	`fn($x) => $x * 2`
Dictionnaire littéral	`{'k': 1}`	`{k: 1}`	`Map.of("k", 1)`	`['k' => 1]`
Interpolation	`f"{x}"`	`${x}`	(aucune)	`"{$x}"`
Membre d’instance	`obj.name`	`obj.name`	`obj.name`	`$obj->name`
Membre statique	`Cls.name`	`Cls.name`	`Cls.name`	`Cls::$name`
Ternaire	`a if c else b`	`c ? a : b`	`c ? a : b`	`$c ? $a : $b`

Le piège

Deux choses font trébucher un nouveau venu dans la première heure. La première est ==, une comparaison qui a l’air juste et passe les tests évidents, puis décide que '1e1' == '10' et que null == false. Tapez === jusqu’à ce que ce soit un réflexe, et laissez strict_types attraper le reste.

La seconde est la bibliothèque standard, où l’on trouve strpos($haystack, $needle) mais array_search($needle, $haystack), str_replace avec un tiret bas mais strlen sans, et array_key_exists à côté de in_array. Le nommage n’a jamais été conçu, il s’est accumulé au fil des versions. Les fonctions récentes sont cohérentes (str_contains, array_is_list, array_find), les anciennes ne changeront pas, et le remède n’est pas la mémoire mais un éditeur avec complétion et un analyseur statique qui signale l’ordre d’arguments inversé.

Une haute commode dont chaque tiroir porte un nom de fonction PHP dans un lettrage différent, certains avec des tirets bas et d'autres sans, et un petit éléphant tenant une lampe torche qui éclaire le bon tiroir

Une fois la syntaxe réglée, les questions intéressantes commencent, à commencer par ce que garantit vraiment int. Le système de types y répond avec plus de nuances que vous ne l’auriez souhaité.

Keyboard shortcuts

🐘 Et maintenant, PHP - 0.1.0