Aller au contenu

Serveur - PHP Langage

Commentaires#

Les commentaires sont classiques

Sur une ligne

<?php
//ceci est un commentaire sur une ligne
?>

Sur plusieurs lignes

<?php
/* ceci est un commentaire sur 
plusieurs lignes */
?>

Variables#

Les identificateurs de variable sont précédés du symbole dollars $ comme par exemple $toto.

<?php
$str = 'bonjour';      // $str vaut la chaîne 'bonjour'
$nbr = 12;   // $nbr vaut le nombre 12
?>

Le typage des variables est implicite en PHP, il n’est donc pas nécessaire de déclarer leur type au préalable ni même de les initialiser avant leur utilisation.

Il est également possible de définir des constantes. Les constantes ne portent pas le symbole $ en début d’identificateur.

  • define("FOO", valeur): définit la constante FOO à valeur
<?php
define("FOO","bar");
echo FOO; // affiche bar
define("YEAR", 2000);
echo YEAR; // affiche 2000
?>

Opérateurs#

Opérateurs
Opérateurs arithmétiques +, -, *, /, %, ++, --
Opérateurs d’assignement =, *=, /=, +=, -=, %=
Opérateurs logiques and, &&, or, ||,xor, !
Opérateurs de comparaison ==, <, <=, >, >=, !=

Booléens#

Les variables booléennes prennent pour valeurs true (vrai) et false (faux). Une valeur entière nulle (0), une chaîne de caractères vide ("") ou les chaînes "0" et '0' sont automatiquement considérées comme false.

<?php
$variable_boolean = (8 > 5);
// $variable_boolean est vrai.
// on peut alors la tester
?>

Chaines de caractères#

Une variable chaine de caractères est délimitée par des simples quotes (') ou des doubles quotes (").

<?php
$nom = "Naimarre";
$prenom = 'Jean';
?>

Les doubles quotes permettent l’évaluation des variables et caractères spéciaux contenus dans la chaine alors que les simples ne le permettent pas. Le caractère de concaténation est le point (.)

<?php
$foo = "Hello";
$bar = "Word";
echo $foo . ' the ' . $bar; // affiche Hello the World
echo "$foo the $bar";  // affiche aussi Hello the world
echo '$foo the $bar';  // ne fonctionne pas: affiche $foo the $bar

// variables "complexes"
echo "Hello {$tab['cle']}";
?>

Quelques fonctions utiles :

  • strlen($str) : retourne le nombre de caractères d’une chaine
  • strtolower($str) : conversion en minuscules
  • strtoupper($str) : conversion en majuscules
  • trim($str) : suppression des espaces de début et de fin de chaine
  • substr($str, $i, $j) : retourne une sous chaine de $str de taille $j et débutant à la position $i
  • strtr($str, $from, $to) : retourne la chaine $str après avoir remplacé chaque caractère de $from par ceux de $to, un à un

Tests#

La structure de test if permet de conditionner l’exécution d’un bloc de code.

<?php
if (condition) {
    // code à exécuter si condition est vraie
}
?>

On peut ajouter un bloc à exécuter dans le cas contraire.

<?php
if (condition) {
    // code à exécuter si condition est vraie
} else {
    // code à exécuter si condition est fausse
}
?>

On peut enfin tester d’autres conditions dans le cas ou la première serait fausse.

<?php
if (condition) {
    // code à exécuter si condition est vraie
} elseif (nouvelle_condition) {
    // code à exécuter si la première condition est fausse et la nouvelle condition vraie
} else {
    // code à exécuter dans le cas contraire
}
?>

Quelques fonctions utiles :

  • empty($var): renvoie vrai si la variable est vide
  • isset($var): renvoie vrai si la variable existe

Boucles#

Les structures de boucle permettent de répéter un bloc de code un certain nombre de fois.

Quand le nombre de répétition est connu, on peut utiliser une boucle for qui utilise une variable d’indice qui s’incrémente au fil des tours.

<?php
for ($i = 0; $i < 100; $i++) {
    // code à exécuter 100 fois (avec $i variant de 0 à 99)
}
?>

Quand le nombre de répétition est inconnu ou indéterminé, on peut utiliser une boucle while. La deuxième forme do while permet d’exécuter le bloc au minimum une fois.

<?php
while (condition) {
    // code à exécuter tant que la condition est vraie
    // la condition peut (devrait) évoluer
}

do {
    // code à exécuter tant que la condition est vraie
    // la condition peut (devrait) évoluer
} while (condition);
?>

Affiche un message en fonction de la date

<?php
// 25/12
if ($mois == 12) {
    if ($jour < 25) {
        echo "C’est bientôt Noël";
    } elseif ($jour > 25) {
        echo "Noël est passé";
    } else {
       echo "C’est Noël !";
    }
}
?>

Affiche 10 titres de niveau 3

<?php
for ($i = 0; $i < 10; $i++) {
    echo "<h3>Titre n°$i</h3>";
}
?>
// ou
<?php for ($i = 0; $i < 10; $i++) { ?>
    <h3>Titre n°<?= $i ?></h3>
<?php } ?>

Cherche un nombre entre 50 et 55

<?php
$nombre = 0;
while ($nombre < 50 || $nombre > 55) {
    $nombre = rand(0,100);
    echo "<span>$nombre</span>";
}
echo "<p>Le nombre $nombre fait sortir de la boucle</p>";
?>
  • L’instruction break permet de quitter prématurément une boucle
  • L’instruction continue permet de passer à l’itération suivante d’une boucle immédiatement

Tableaux#

Tableaux simples#

Une variable tableau est de type array, on parle aussi de liste. Les éléments d’un tableau peuvent être de types différents et sont séparés d’une virgule. L’élément d’un tableau peut être un autre tableau.

Initialisation de 2 tableaux

<?php
$tab_colors = ['red', 'yellow', 'blue', 'white'];
$tab = ['foobar', 2002, 20.5, $name];
?>

Initialisation de 2 tableaux au fur et à mesure

<?php
$prenoms[] = "Clément";
$prenoms[] = "Justin";
$prenoms[] = "Tanguy";

$villes[0] = "Paris";
$villes[1] = "Londres";
$villes[2] = "Lisbonne";
?>

L’appel à un élément du tableau se fait à partir de son indice (dont l’origine est zéro).

Afficher le 11e élément

<?php
echo $tab[10];
?>

Pour le parcours d’un tableau, une boucle d’énumération existe :

Afficher tous les éléments du tableau

<?php
$tab = ['Hugo', 'Jean', 'Mario'];
foreach ($tab as $elem) {
    echo $elem;
}

// equivalent avec un for classique
for ($i = 0; $i < sizeof($tab); $i++) {
    echo $tab[$i];
}
?>

Quelques fonctions utiles :

  • sizeof($tab) : retourne le nombre d’éléments du tableau
  • in_array($var, $tab) : dit si la valeur $var existe dans le tableau $tab
  • shuffle($tab) : mélange les éléments d’un tableau
  • sort($tab) : trie alphanumérique les éléments du tableau
  • implode($str, $tab) : retourne une chaîne de caractères contenant les éléments du tableau $tab joints par la chaîne $str
  • explode($delim, $str) : retourne un tableau dont les éléments résultent du hachage de la chaîne $str par le délimiteur $delim
  • array_merge($tab1, $tab2, $tab3…) : concatène les tableaux passés en arguments

Tableaux associatifs#

Les tableaux associatifs permettent de préserver une structure de données et sont aussi appelés dictionnaire ou hashtable. On associe à chacun de ses éléments une clé dont la valeur est de type chaine de caractères. L’initialisation d’un tableau associatif est similaire à celle d’un tableau simple.

Initialisation d’un tableau associatif

<?php
$personne = ["Nom" => "César", "Prénom" => "Jules"];
$personne["Nom"] = "César";
$personne["Prénom"] = "Jules";
// Ici à la clé "Nom" est associée la valeur "César".
?>

Boucle de parcours d’un tableau associatif

<?php
foreach ($personne as $key => $elem) {
    echo $key . " : " . $elem;
}
?>

Rappel, pour l’évaluation de variables complexes (par exemple des tableaux associatifs) dans une chaine de caractères en double-quote, il est possible d’utiliser {$var}.

<?php
$tab = ['foo' => 'bar'];

echo "Coucou $tab['foo']"; // NOK
echo "Coucou {$tab['foo']}"; //OK

// ou sinon une simple concaténation
echo "Coucou " . $tab['foo'];
?>

Fonctions#

Comme tout langage de programmation, PHP permet l’écriture de fonctions :

  • elles peuvent prendre des arguments dont il n’est pas besoin de spécifier le type
  • elles peuvent de façon optionnelle retourner une valeur
  • l’appel à une fonction peut ne pas respecter son prototypage (nombre de paramètres)
  • les identificateurs de fonctions sont insensibles à la casse
<?php
function mafonction ($toto) {
    $toto += 15;
    return $toto + 10;
}

$nbr = mafonction(15.1);
/* retourne 40.1 */
?>

Les paramètres sont passés par copie et les résultats sont retournés par copie (sauf si on force le passage par référence avec &).

Passage de paramètres par référence avec le caractère &

<?php
function change (&$var) {
    $var += 100;
}

$toto = 12;
change($toto);
echo $toto;
?>

On peut donner une valeur par défaut aux arguments lors de la déclaration de la fonction. Ainsi, si un argument est «oublié» lors de l’appel de la fonction, cette dernière lui donnera automatiquement la valeur voulue par le programmeur.

<?php
function setColor ($color = "black") {
    $selectedColor = $color;
}
?>

Fonctions utiles#

Quelques fonctions générales utiles :

  • json_encode($array) encode un tableau associatif en JSON (chaine de caractères)
  • json_decode($json, $type) pour convertir une chaine JSON en tableau associatif PHP ($type doit être défini à true)

Inclusions#

On peut inclure dans un script PHP le contenu d’un autre fichier.

  • include() évalue et insert à chaque appel (même dans une boucle) le contenu du fichier passé en argument
  • require() identique à include mais produit une erreur fatale si une erreur survient
  • include_once() permet d’éviter de recharger un fichier qui à déjà été inclus
  • require_once() similaire à require mais le code ne sera inclus qu’une seule fois
<?php
require("fichier.html");
include("fichier.php");
?>

C’est très utile pour créer des pages différentes où la même information se répète (entete d'un site, menu de navigation, etc.) ou simplement factoriser son code (connexion à une base de données).

Souvent masqué par l’utilisation de framework et de templates.

Variables superglobales#

Ce sont des tableaux créés automatiquement par le serveur qui contiennent des informations générales, notamment sur le script en cours d’exécution :

  • $_SERVER contient des informations sur le serveur et sur le script en cours d’exécution
  • $_GET contient les variables passées dans l’URL
  • $_POST contient les variables passées dans l’entête HTTP
  • $_REQUEST c’est la concaténation des tableaux $_GET et $_POST
  • $_FILES contient les infos sur le fichier téléchargé par formulaire
  • $_COOKIE contient les variables stockées sur l’ordinateur de l’utilisateur
  • $_SESSION contient les variables propres à l’utilisateur mais stockées sur le serveur
<?php
// on suppose que l'url du script est : http://monserveur.org/mapage.php?nom=cédric
$nom = $_GET["nom"];
$ip = $_SERVER['REMOTE_ADDR'];
echo "<h1>bienvenue ".$nom.", ton IP est :".$ip."</h1>";
?>

Orienté Objet#

PHP peut être utilisé en notation objet. Voici un exemple de définition de classes Coordonnee et Coordonnee3D :

<?php
//classe définissant un objet coordonnée
class Coordonnee {
    public $x;
    public $y;

    //constructeur
    public function __construct($_x, $_y) {
        $this->x = $_x;
        $this->y = $_y;
    }

    //calcul de la distance à un autre point
    public function Distance($coord = null) {
        if ($coord == null) {
            $coord = new Coordonnee(0, 0);
        }
        return sqrt(
            pow($this->x - $coord->x, 2) +
            pow($this->y - $coord->y, 2)
        );
    }
}

//extension de la classe précédente en une coordonnée 3D
class Coordonnee3D extends Coordonnee {
    public $z;

    public function __construct($_x, $_y, $_z) {
        parent::__construct($_x, $_y);
        $this->z = $_z;
    }

    public function Distance($coord=null) {
        if ($coord == null) {
            $coord = new Coordonnee3D(0, 0, 0);
        }
        return sqrt(
            pow($this->x - $coord->x, 2) +
            pow($this->y - $coord->y, 2) +
            pow($this->z - $coord->z, 2)
        );
    }
}

// une coordonnée
$point = new Coordonnee(50, 32);
echo $point->x . "," . $point->y . " dist:" . $point->Distance();

// une coordonnée 3D
$point3d = new Coordonnee3D(100, 100, 100);
echo $point3d->x . "," . $point3d->y . "," . $point3d->z . " dist:" . $point3d->Distance();

Afin d’éviter les inclusions de classes à la main (quand chaque classe est définie dans son propre fichier), PHP a un mécanisme de chargement automatique.

<?php
// fonction d’autochargement pour PHP < 8
function __autoload($class_name) {
    include $class_name . '.php';
}

// fonction d’autochargement pour PHP >= 8
spl_autoload_register(function ($class_name) {
    include $class_name . '.php';
});

// l’inclusion se fait automatiquement lors de l’instanciation
$obj  = new Coordonnee();
?>