Présentation

PHP: Hypertext Preprocessor est un langage libre de 1994. Exécuté coté serveur web, il peut génèrer du code HTML.

Avantages

  • populaire
  • interprété par le serveur, indépendant de l’OS
  • non verbeux
  • création de page web dynamiques
  • disponible sur tous les hébergements

Inconvenients

  • syntaxe fouillie, ajout de l’objet à posteriori
  • prise en charge des types incomplete
  • plus lent et moins  à la mode que NodeJS

 

Utilisation

Il peut être déployé sur différents serveurs web comme

  • Internet Information Services IIS, de Microsoft
  • Apache HTTP Server de la Apache Software Foundation
  • lighttpd de Jan Kneschke ;
  • nginx d’Igor Sysoev ;

Attention, les anciens accès aux bases MySQL sont dépréciés (mysql_query par exemple).

Les métiers

 

Premier code

On doit indiquer les balises HTML et insérer du code PHP.
Tout code PHP commence par une balise < ?php et termine par ?> sauf pour les fichiers 100% PHP.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>mon titre</title>
</head>

<body> 
<?php 
echo "Je suis un script PHP qui va être affiché en HTML » ; 
?> 
</body> 
</html>

Envoie du code HTML depuis le serveur PHP

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>mon titre</title>
</head>

<body> 
Je suis un script PHP qui va être affiché en HTML 
</body> 
</html>

Toutes les variables commencent par des $, on termine les lignes d’instructions par des ;
Par défaut il n’y a pas de type de variables.

<?php 
$a=5;
//commentaire
/*com-
mentaire */

Inclusion de code

On utilise include ou require pour importer du code. Il sera alors exécuté à l’endroit où il est inséré.
L’instruction require bloquera le script si une erreur survient, par exemple si le fichier n’est pas trouvé.
On peut utiliser require_once ou include_once pour n’inclure qu’une seule fois le script.

maPage.php

<?php  echo « meumeu » ;

secondePage.php

<?php require_once ‘maPage.php’;

Changement automatique de page

On souhaite aller sur le site de Google en appelant une page
Il est nécessaire de ne pas placer de sortie HTML avant le header. Une balise HTML provoquera une erreur de la fonction header (On lui demande de changer de page alors qu’on lui a passé un script qui génère une page, d’où le conflit)

<?php 
header("Location: http://www.google.com/");  
/* Pour être certain que le code se bloque à la redirection*/ 
exit; 

Le typage

Il est possible d’obliger les fonctions à prendre certains types pour leurs paramètres.  De grandes évolutions depuis la version 7.2

public function test(int $a) { 
        echo $a; 
    }

Variables prédéfinies

PHP possède plusieurs variables utiles accessibles sur vos pages.
http://www.php.net/manual/fr/reserved.variables.php

Les variables HTTP

Un tableau associatif des valeurs passées au script courant via le protocole HTTP et la méthode POST. Cf formulaire

session_start();
$_POST[‘monNameDeInput’] ;

Un tableau associatif des valeurs passées au script courant via le protocole HTTP et la méthode GET. Cf formulaire

session_start();
$_GET[‘monNameDeInput’] ;

Un tableau associatif des valeurs passées au script courant via le protocole http. Il contient les variables de $_GET, $__POST et $_COOKIE

session_start();
$_REQUEST[‘monNameDeInput’] ;

Les variables de sessions

Un tableau associatif des valeurs stockées dans les sessions, et accessible au script courant.
On pourra s’intéresser par la suite au tableau associatif cookie et files.

session_start();
$_SESSION[‘maVariable’] =28;

Les formulaires

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>mon titre</title>
</head>
<body>

<form method="post" id="frmConnection" action="recuperation.php">
    <label for="email"> Votre email:</label>
    <input type="email" name="txtEmail" id="txtEmail" autofocus />
    </br>
    <label for=" txtPass "> Mot de passe :</label>
    <input type="password" name="txtPass" required />
    <input type="submit" name="cmd" id="cmd" value=" envoie " />
</form>

</body>
</html>

 

Fichier recuperation.php
On récupère les champs d’un formulaire grâce aux attributs name
La fonction isset() vérifie que le paramètre est renseigné. Si le champ n’est pas rempli dans le formulaire, la variable n’existera pas dans recuperation.php, ce qui génère une erreur si on y accède.

<?php session_start();

if (isset($_POST[‘txtEmail’])) {
    echo $_POST[‘txtEmail’];
}

Retour sur même page de formulaire

maPage.php
La page sera rechargée avec l’affichage des données entrées

<?php session_start()?>

<!DOCTYPE html>
<html>
<head>

    <meta charset="utf-8" />
    <title>mon titre</title>
</head>
<body>

<?php

if(isset($_POST["cache"])){
    echo "vos valeurs ".$_POST[txtEmail]." ".$_POST[txtPass];

}else{
    ?>
    <form method="post" id="frmConnection" action=" maPage.php">
        <label for="email"> Votre email:</label>
        <input type="email" name="txtEmail" id="txtEmail" autofocus />
        </br>
        <label for=" txtPass "> Mot de passe :</label>
        <input type="password" name="txtPass" required />
        <input type="hidden" name="cache" id=" cache " value="1" />
        <input type="submit" name="cmd" id="cmd" value=" envoie " />
    </form>
    <?php
}
?>
</body>
</html>

Liste déroulante dynamique

$mesCLients est un tableau d’objet Client contenant l’email et d’autres variables

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>mon titre</title>
</head>
<body>

<?php
$mesClients =["Lina","Winie","John","Harry"];
print("<select name=’maListe’ size=’1’>");

    foreach($mesClients as client){
    print("<option>".$client." </option>");

    }
    print("</select >");
?>
</body>
</html>

Connexion aux bases de données

L’API PDO

L’API PDO est une interface de programmation d’application (Application Programming Interface). Elle regroupe les classes qui vont permettre de réaliser des fonctions aux SGBDR via PHP.,L’API PDO requiert PHP 5.1 au minimum. Attention, les anciens accès aux bases MySQL sont dépréciés (mysql_query par exemple). On ne peut donc plus les utiliser. Ils sont considérés comme non sécurisés et génère une alerte.,Toutefois, il n’est pas obligatoire d’utiliser PDO. D’autres API existent.

Si vous ne souhaitez pas d’une application portable sur plusieurs SGBDR et profiter au maximum des fonctionnalités qu’offre par exemple MySQL dans ses dernières versions, il faut utiliser l’API Mysqli. MySQLi pour Mysql improved permet d’avoir plus de fonctionnalités que PDO pour MySQL. Par contre, une grande partie du code sera à modifier si vous changez de SGBDR. Cette extension n’est utile qu’à partie de la version 4.3.1 de MySQL.

Création d’une connexion MySQL

Les paramètres du constructeur sont des chaines de caractères. Seul le premier est obligatoire.
On instancie l’objet PDO avec au minimum le Data Source Name ou DSN. Le DSN contient les informations pour se connecter à la BD du SGBDR quel que soit l’utilisateur. Le login et le mot de passe sont des paramètres optionnels.

Attention la syntaxe du Data Source Name est dépendante de chaque base de données. D’après le site de php.net :
Le try{}catch{} permet de capturer les exceptions déclenchées par la création de l’objet en cas d’erreurs.

<?php
$dsn='mysql:dbname=testdb;host=127.0.0.1';
$user='dbuser';
$password='dbpass';

try{
    $dbh=new PDO($dsn,$user,$password); 
}catch(PDOException $e){
    echo'Connexion échouée:'.$e->getMessage(); 
}

PostgreSQL et port

<?php
$dsn = "pgsql:host=192.168.1.14;port=5432;dbname=maBase"; 
try { 
    $dbh = new PDO($dsn, »root », » »); 
} catch (PDOException $e) { 
    echo 'Connexion échouée : ' . $e->getMessage(); 
}

Exécution de requêtes

Après avoir réalisée une connexion, il est possible d’effectuer des requêtes. Deux manières s’offre à nous.

Exec

<?php
$sql="DELETEFROMclientWHEREnom='Dupond'";
 $count=$dbh->exec($sql);
print("Effacementde$countlignes.\n");

La fonction d’instance exec renvoie le nombre de lignes affectées par la requête. Cette fonction peut aussi générer des erreurs (généralement une erreur dans la requête SQL). Il est possible de les afficher grâce à l’instruction « or die ». On réutilise l’objet PDO dbh créé précédemment.

Query

Le nom des colonnes sera exactement les mêmes que celles de la base de données. Il faut éviter les accents et les espaces qui sont sources d’erreur lors du passage des informations du SGBDR au serveur PHP.

<?php
$sql="SELECT nom, prenom FROM client";
$statement=$dbh->query($sql) ordie(print_r($dbh->errorInfo(),true)); 
foreach ($statement->fetchAll(PDO::FETCH_OBJ) as $ligne) {
    echo 'Utilisateur : '.$ligne->nom.'<br>';
}
$statement->closeCursor();

Query exécute une requête SQL, retourne un jeu de résultats en tant qu’objet PDOStatement. La fonction setFetchMode de l’objet PDOStatement va influer sur l’accès des données.
Il faut imaginer le résultat sous forme de tableau. Ce tableau se nomme un curseur. Quand on exécute la fonction fetch, on place l’accès au curseur à la première ligne.

Nom Prenom
Durand Dinan
Daria David
Lini Louis

Pour passer à la deuxième ligne on exécute une nouvelle fois la fonction fetch.

Nom Prenom
Durand Dinan
Daria David
Lini Louis

Pour libérer la connexion du serveur PHP au SGBDR, on ferme le curseur (closeCursor). On accède à une case du tableau en étant d’abord sur la bonne ligne puis en accédant à la colonne correspondante.

 

Les requêtes préparées

Les requêtes préparées permettent d’améliorer les performances et la sécurité. Le pilote sera autorisé à utiliser le cache coté client ou serveur. Ce type de requête protège des injections SQL. Il n’est plus nécessaire d’utiliser des fonctions spécifiques pour s’en prémunir. La requête est préparée avec des variables appelées marqueurs que l’on va insérer dans la requête SQL. On peut ré-exécuter la requête de cette manière profitant pleinement du cache. On préférera cette méthode aux méthodes précédentes surtout pour des variables récupérées par un client.

exec

<?php
$sql="DELETE FROM client WHERE nom=:nom";
$statement=$dbh->prepare($sql);
$nom ="harry";
$statement->bindParam(":nom", $nom);
$b=$statement->execute();

Cette méthode bien que sécurisée, ne renverra que true dans la variable b ou false si elle n’est pas exécutée.

query

<?php
$sql = "SELECT nom, prenom FROM client WHERE login=:login AND mdp=:mdp";
$resultats = $dbh->prepare($sql);

$login = "login";
$mdp = "mdp";

$resultats->bindParam(":login", $ login);
$resultats->bindParam(":mdp", $mdp);
$resultats->execute(); 
foreach ($resultats->fetchAll(PDO::FETCH_OBJ) as $ligne) {
    
    echo 'Utilisateur : ' . $ligne->nom . '<br>';
}

PHP Objet

Les objets en PHP fonctionnent par référence. Si on enregistre un objet dans une variable, ce sera une référence vers cet objet qui sera enregistré.

La classe

<?php

class Client
{
    private $nom;

    public function getNom()
    {
        return $this->nom;
    }
} 

Utilisation d’un objet

$monClient = new Client();

On accède à une variable d’un objet de la manière suivante

$monClient->nom ;

L’objet this fonctionne dans une méthode d’instance comme en Java

$this->nom ;

Les visibilités

Les visibilités s’appliquent sur les variables et les fonctions. Elles sont identiques à Java : public, protected, ou private. On respectera les principes de l’encapsulation.

Comparaison d’objets

On utilise deux manières pour comparer les objets.

Le == permet de comparer les valeurs de l’objet. Ils doivent être de la même classe et posséder les mêmes variables de valeurs identiques.
Le === vérifie la référence de l’objet. L’objet doit donc ici être le même alors qu’avec l’autre méthode, l’objet doit être égal.

Les constantes

Ceci est différent de Java, on n’utilise pas le mot clef final

class A {
    const ZOZO= 'valeur constante';
}
printA::ZOZO;

Par contre le mot clef final est utilisé de la même manière pour les classes et les méthodes. Une méthode final ne pourra être surchargée et une classe final ne pourra être héritée.

 final public function waza() { 
       echo "c'est la fin !"; 
   } 

Le mot clef static

<?php

class A
{
    public static $maVarStatic = ‘titi‘;   
    public static function maFonction()
    {
        echo "ma fonction";
    }
}

printA::$maVarStatic;
printA::maFonction();

Parcours de collection

<?php
foreach ($collection as $key => $value) {
    print $key => $value;
     }
foreach ($collection as $value) {
    print $value;
}

Le constructeur

<?php

class Client
{
    function __construct()
    {
        print"constructeur de la classe mere";
    }
}

On note _ _ avant construct pour réaliser un constructeur.
Les méthodes ayant le même nom que la classe dans laquelle elle se trouve ne sont plus traitées comme des constructeurs.
Client() sera considérée comme une fonction et non comme un constructeur.

    function Client() { 
        print "simple fonction"; 
    }

Constructeur avec paramètres

class Client{ 
    function __construct($param1, $param2) { 
        print "constructeur avec 2 paramètres"; 
    } 
}

L’héritage

Comme en Java, Il n’est pas possible d’hériter de plusieurs classes. La notation des variables et méthides static est soulignée.

class Fille extends Mere{ }

Le mot réservé self désigne la classe elle-même (this). Le mot parent désigne la classe mère (super).

<?php

class Mere
{
    public static $maVarStatic = "titi";
    public $var;

    const CONST_VALUE = "Unevaleurconstante";

    public static function Value(){
     return self::$maVarStatic;
}

public static function maFonction(){}
public function maDeuxiemeFonction(){}
}

/*****************************************/

class Fille extends Mere
{
    public function renvoieStatic()
    {
        parent::maFonction();
        parent::$maVarStatic;
    }

    public function maDeuxiemeFonction()
    {
        parent::maDeuxiemeFonction();
    }
}

/*******************************************/
printMaFille::$maVarStatic;

//accès à la variable static

$mam= new Mere();
$mam->var;

$fille = new Fille();
print $fille->renvoieStatic();

Constructeur

Parent remplace ici super de Java.

class Mere { 
    function __construct() { 
        print "constructeur de la classe mere"; 
    } 
} 

class Fille extends Mere { 
    function __construct() { 
        parent::__construct(); 
        print "constructeur de la classe fille"; 
    } 
}

Les classes et méthodes abstraites

Même comportement qu’en Java. Il est nécessaire d’implémenter les méthodes abstraites. La notation des classes abstraite est en italique.

abstract class Personne
{ 
    // Force les classes filles à définir cette méthode 
    abstract protected function getValue(); 
    abstract protected function setValue($a); 

} 

class Client extends Personne
{ 
     protected function getValue() { 
       return "ConcreteClass1"; 
     } 

     public function setValue($a) { 
       return  $a; 
    } 
}

Les interfaces

Toutes les méthodes des interfaces doivent être implémentées dans la classe.

interface iTemplate 
{ 
    public function setVariable($name, $var); 
    public function getHtml($template); 
} 

class Template implements iTemplate 
{ 
    private $vars = array(); 
    public function setVariable($name, $var) 
    { 
        $this->vars[$name] = $var; 
    } 

    public function getHtml($template) 
    { 
        foreach($this->vars as $name => $value) { 
            $template = str_replace('{' . $name . '}', $value, $template); 
        } 

        return $template; 
    } 
} 

// Ceci ne fonctionnera pas 
class BadTemplate implements iTemplate 
{ 
    private $vars = array(); 
    public function setVariable($name, $var) 
    { 
        $this->vars[$name] = $var; 
    } 
}