Cours PHP HB

TP01.md

Exercice 0 : Setup de l'environnement de développement

Le développement web en PHP est composé de 3 couches :

• couche serveur HTTP (Apache, Nginx, IIS...)
• couche langage (PHP et extensions)
• couche BDD (MySQL, PostgreSQL...)

Vous utiliserez l'éditeur de code VSCode en effectuant les modifications suivantes après installation :

1. Supprimez l'extension PHP Intellisense
2. Installez l'extension PHP Intelephense

Exercice 1 : XAMPP

Nous allons installer l'environnement de développement nécessaire.

1. Téléchargez XAMPP et installez la version avec PHP 7.3 (https://www.apachefriends.org/fr/download.html). XAMPP contient un stack AMP tout prêt : un serveur Apache, le langage PHP et des extensions classiques (php-cli, php-xml, php-mbstring...), et une base de données MySQL ou MariaDB.

Pour vérifier que PHP est installé, ouvre un terminal et saisissez : php -v.

Exercice 2 : Hello World

1. Maintenant que XAMPP est installé, lancez-le et activez Apache.
2. Nous allons créer notre premier fichier PHP: ouvrez le dossier c:/xampp/htdocs/ et créez dedans un fichier hello.php.
3. Dans ce fichier, saisissez le code suivant :

<?php echo "Hello world;"; ?>

4. Par défaut, le port de Apache est le port 80 (HTTP). Ouvrez donc l'URL suivante: http://localhost:80.

Exercice 3 : Xdebug

1. Afin de voir la configuration de PHP en cours, nous allons créer un fichier phpinfo.php et saisir dedans :

<?php phpinfo(); ?>

2. Accédez à ce fichier. Il nous présente toute la configuration en cours pour notre instance de PHP.
3. Nous allons installer une extension de PHP nous permettant d'afficher les erreurs d'une meilleure façon: Xdebug.
4. Copiez-collez le contenu de la page HTML du phpinfo dans le formulaire de la page suivante : https://xdebug.org/wizard.php. Le site vous retournera les instructions d'installation pour configurer Xdebug sur votre ordinateur, suivez-les !

Exercice 4 : Découvrir PHP

Créez un nouveau fichier PHP et réalisez les exercices suivants :

1. Déclaration de variables et typage dynamique, et débuguage de code

/**
 * 1. Déclarer ces deux variables et les débuguer avec var_dump :
 * => nombre = 123
 * => texte = "hello world"
 */
$nombre =
$texte  =
var_dump($nombre, $texte);

2. Concaténation : liez deux variables ainsi $var1 . $var2.

/**
 * 2. a. Ajoutez 32 à la variable nombre
 * 2. b. Transformez la variable $texte en "hello world, cette variable est écrite en PHP." en utilisant la concaténation
 *
 * Ensuite, débuguez les avec var_dump.
 */
$nombre =
$texte  =
var_dump($nombre, $texte);

3. Déclarez un tableau avec une des deux structures suivantes :

$array = ['value1', 'value2', 'value3'];
$array = array('value1', 'value2', 'value3'); // Deprecated

/**
 * 3. a. Déclarez un tableau simple :
 * => "tomates", "navets", "carottes", "oignons"
 * 3. b. Affichez dans un var_dump la valeur "carotte".
 */
$tableauSimple =
var_dump(...);

4. Déclarez un tableau associatif avec la structure suivante :

$array = [
    'key1' => 'value1',
    'key2' => 'value2,
];

/**
 * 4. a. Déclarez un tableau associatif, qui contient des données utilisateur en clés (nom, prénom, adresse).
 * 4. b. Affichez dans un var_dump la valeur de "prénom".
 */
$tableauAssociatif =
var_dump(...);

5. Créez un tableau multi-dimensionnel avec la structure suivante :

$array = [
    'key1' => [
        'value1',
        'value2',
    ],
    'key2' => [
        'value1',
        'value2',
    ],,
];

/**
 * 5. a. Déclarez un tableau multi-dimentionnel, qui contient des saisons, lesquelles contiennent des 2 légumes, lesquels contiennent les clés "quantité" et "prix"
 * 5. b. Affichez dans un var_dump le prix d'un légume d'été.
 */
$tableauMultidimentionnel =
var_dump(...);

6. Rédigez une condition avec la structure suivante :

if ($a <= 10) {
    echo "la valeur est inférieure ou égale à 10"; // echo permet d'afficher du texte
}

/**
 * 6. a. Déclarez nombre et donnez lui une valeur numérique.
 * 6. b. Ecrivez une condition : si nombre est inférieur à 100, affichez "trop petit", sinon, affichez "ok c'est bon".
 */
$nombre =
if...

7. Découvrez la documentation PHP et essayez de résoudre l'exercice grâce à la doc de la fonction date() : https://php.net/manual/fr/function.date.php

/**
 * 7. a. Déclarez une variable "year" qui contiendra l'année actuelle, grâce à la fonction date()
 * 7. b. Ecrivez une condition : si l'année actuelle (avec $year) est 2019, affichez "bonne année !", sinon "mauvaise année."
 */
$year =
if...

8. Conditions

/**
 * 8. a. Testez si $year est bissextile (modulo 4). Si oui, affichez "$year est bissextile", sinon "$year n'est pas bissextile"
 */
if...

9. Conditions ternaires : découvrez une autre manière de rédiger une condition en PHP

/**
 * 9. a. Créez une variable $age contenant un âge
 * 9. b. Faites une condition ternaire (  $var = (condition) ? valeur_si_vrai : valeur_si_faux;   ) qui enregistrera dans une variable
 * $statut "majeur" si l'âge est >= 18 ans, "mineur" sinon.
 */
$age =
$statut =

10. Passez un array dans une boucle

/**
 * 10. Reprenez le tableau 3 (tableau simple) et affichez chaque élément grace à une boucle foreach de cette façon:
 * "Elément 0 : xxx"
 * "Elément 1 : xxx"
 * ...
 *
 * N'oubliez pas les <br> pour les sauts de ligne !
 *
 * Rappel : foreach ($array as $key => $value) { echo $value; }
 */
foreach ...

11. Affichez du HTML avec PHP et une boucle

/**
 * 11. Reprenez le tableau 4 (array associatif) et affichez dans un <ul><li> les éléments de l'utilisateur, par exemple:
 *
 * - Nom : John
 * - Prénom : Doe
 * - Adresse  : 14 rue des champs
 *
 * Attention au placement des "ul" et des "li", lesquelles dois-je mettre dans le foreach, lesquels à l'exterieur ?
 * Rappel : foreach ($array as $key => $value) { ... }
 */
foreach ...

12. Réalisez une boucle dans une boucle avec PHP

/**
 * 12. Reprenez le tableau 5 (array multidimentionnel) et affichez :
 *
 * - Ete
 *  - Fruit 1 : (quantité : 3 , prix : 10€)
 *  - Fruit 2 : (quantité : 3 , prix : 10€)
 *  * - Automne
 *  - Fruit 1 : (quantité : 3 , prix : 10€)
 *  - Fruit 2 : (quantité : 3 , prix : 10€)
 * ...
 *
 * Attention: il y a un foreach pour chaque "sous-tableau". Attention au nommage des variables intermédiaires ($key => $value) de telle sorte
 * que vous vous rappeliez bien du contenu de chacune.
 *
 * Rappel : foreach ($array as $key => $value) { ... }
 */
foreach ...

13. Rédigez des fonctions en PHP

/**
 * 13. Fonctions
 * a. Ecrire une fonction qui ne prend pas d'arguments, qui affichera "hello world" et qui retournera "true".
 * b. Ecrire une fonction à 1 argument, qui retournera l'argument en majuscules.
 * c. Ecrire une fonction à 2 arguments, qui comparera les deux nombres et retournera le plus grand des deux.
 */
function hello() {}
function maj($texte) {}
function compare($a, $b) {}

14. Typage d'arguments

/**
 * 14. Validations
 * a. Prenez la fonction 13b. et typez les arguments : testez les cas d'erreur.
 * b. Prenez la fonction 13c. et typez les arguments : testez les cas d'erreur.
 */
function maj(string $texte) {}
function compare(int $a, int $b) {}

TP02.md

TP02 : POO et PHP

Classes

class MyClass {

}

Classes abstraites

abstract class AbstractMyClass {

}

Classes finales

final class FinalMyClass {

}

Méthodes et attributs

class MyClass {
    public $attribute;
    protected $attribute2;
    private $_attribute;

    public function getAttribute() {
        return $this->attribute;
    }

    private function checkAttribute2($attribute2) {
        return ( $attribute2 > 10 );
    }

    public function setAttribute2($attribute2) {
        if ( $this->checkAttribute2($attribute2) ) {
            $this->attribute2 = $attribute2;
            return $this;
        }

        return;
    }
}

Constructeur

class MyClass {

    private $_a;
    private $_b;

    public function __construct(string $a, int $b) {
        $this->_a = $a;
        $this->_b = $b;
    }
}

Instantiation

// Sans appel du constructeur
$object = new MyClass;

// Avec appel du constructeur défini ci-dessus
$object = new MyClass("hello", 12);

Attributs et méthodes statiques

class MyClass {
    public $attribute;
    public static $staticAttribute;

    public function classicFunction() {

    }

    public static function staticFunction() {

    }
}

Appels d'attributs et méthodes statiques et non statiques à l'extérieur de la classe

// Non statiques :
$object = new MyClass;
$var = $object->attribute;
$result = $object->classicFunction();

// Statiques :
$var = MyClass::$staticAttribute;
$result = MyClass::staticFunction();

Appels d'attributs et méthodes statiques et non statiques à l'intérieur de la classe

class MyClass {
    public $attribute;
    public static $staticAttribute;

    public function classicFunction() {

    }

    public static function staticFunction() {

    }

    public function exampleAppelsNonStatiques() {
        $attribute = $this->attribute;
        $result = $this->classicFunction();
    }

    public function exampleAppelsStatiques() {
        $attribute = self::$attribute;
        $result = self::staticFunction();
    }
}