PHP

Le PHP est le langage de programmation le plus accessible, il est au cœur du CMS le plus populaire : WordPress et est assez puissant pour faire fonctionner le réseaux social le plus utilisé : Facebook.

Spécificités du PHP

PHP est l’acronyme de Hypertext Preprocessor. C’est un langage sous licence open source qui s’exécute sur le serveur. Le PHP permet de manipuler des données et de renvoyer des informations traité par des opérations qui sont effectuer par des fonctions. Facile à utiliser et permissif c’est le langage idéal pour commencer à programmer.

Qu’est ce qu’un fichier PHP ?

C’est un fichier ayant une extension .php, qui peut contenir du HTML, du CSS, du javaScript et du code PHP. Quand un fichier PHP est appellé il exécute les fonctions qu’il contient et retourne le résultat.

Fonctionnalités du PHP

Le PHP permet quantité d’opérations différentes :

  • Générer du contenu dynamique.
  • Créer, ouvrir, lire, écrire supprimer et fermer ds fichiers sur le serveur.
  • Collecter les information d’un formulaire.
  • Envoyer et recevoir des cookies.
  • Ajouter modifier ou supprimer des données dans une base de données.
  • Etre utilisé pour contrôler des niveaux d’autorisations.
  • Crypter les données.

Le PHP permet de manipuler n’importe quels formats de fichiers compatible HTML5 (images, PDF, vidéos, textes, XML ou encore XHTML).

Avantages du PHP

Les avantages du PHP sont multiples :

  • Inter-compatibilité : Fonctionne sur différents systeme d’exploitation (Windows, Linux, Unix, Mac OS X…).
  • Et sur les différents serveurs utilisé actuellement (Apache, IIS…)
  • Supporte les différentes base de données du marché.
  • Le PHP est gratuit.
  • Accessible aux débutants tout en étant performant.

Installation du PHP

Pour installer un serveur PHP il faut dans un premier temps installer un interpréteur PHP. Afin d’éviter les configurations est les installations successives de plusieurs logiciels, nous utiliserons WAMP qui permet d’installer un interpréteur PHP et une base de donnée qui nous sera utile pour la suite de la formation.

WAMP nous sera utile pour les tests en local, mais l’objectif étant de travailler sur un serveur afin de rendre le site accessible via internet. Nous prendrons garde à choisir un hébergeur proposant le PHP dans son offre (normalement tout les hébergeurs propose du PHP).

La syntaxe PHP

Pour rédiger du code PHP (script PHP) il suffit d’utiliser la syntaxe <?php au début et de fermé le script avec ?>.

<!DOCTYPE html>
<html>
<body>

<h1>Ma première page PHP</h1>

<?php
echo "Hello World!";
?>

</body>
</html>
Sources : PHP.net

Une requête PHP se termine systématiquement par un « ;« .

Output

Pour afficher le résultat d’une opération ou peut utiliser deux méthodes, echo et print.

<?php
echo "<h2>PHP c'est rigolo !</h2>";
print "Hello world!<br>";
//et on peut aussi combiner des valeurs ou des variable
$x = " et facile";
echo "<h2>PHP c'est rigolo !</h2>".$x." et rapide";
$z = " et les autres"
print "Hello world!<br>".$z." si ils écoutent";

Nous avons vu les sorties print et echo, qui retourne des résultats sous la forme de chaîne de caractères mais il est aussi possible des retourner des variables.

function somme($x, $y) {
    $z = $x + $y;
    return $z;
}
echo "5 + 10 = " . somme(5, 10) . "<br>";

Les commentaires en PHP

Comme pour les autres langages de programmation, il est recommandé d’utiliser les commentaires pour expliciter les fragments de code que vous allez rédiger.

Si au début utiliser des commentaires semble superflu, au fur et à mesure que vous complexifierez le code ou si vous reprenez un code rédigé un an plus tôt, cela vous fera gagner du temps en vous évitant de réinterpréter l’ensemble de votre code.

<!DOCTYPE html>
<html>
<body>

<?php
// Ceci est un commentaire sur une ligne

# Cette ligne aussi

/*
Ici la syntaxe permet
de commenter sur plusieurs
lignes
*/

// Peuvent aussi servir à ignorer l'exécution d'une partie de votre code
$x = 5 /* + 15 */ + 5;
echo $x;
// ainsi $x = 10 et non 25.
?>

</body>
</html>
Sources : PHP.net

Sensibilité à la case

En PHP les mots clés (if, else, while, echo etc.), les classes, fonctions intégrées et les fonctions personnalisées ne sont PAS sensible à la case (majuscule et minuscule).

<?php
ECHO "Hello World!<br>";
echo "Hello World!<br>";
EcHo "Hello World!<br>";
?>
Sources : PHP.net

Ici les trois exemples fonctionnent, ainsi le code affichera trois fois « Hello World« .

A contrario les variables sont sensible à la case.

<?php
$color = "rouge";
echo "Mon pull est " . $color . "<br>";
echo "Mon pull est " . $COLOR . "<br>";
echo "Mon pull est " . $coLOR . "<br>";
?>
Sources : PHP.net

Dans cet exemple seul la première ligne fonctionnera correctement, les autres retourneront une valeur NULL ou vide car elles ne pourront identifier correctement la variable appelée. Cela ne provoquera pas d’erreur PHP mais votre code ne pourra pas fonctionner comme attendu.

Variables PHP

Les variables sont la base d’un langage de programmation. En mathématique vous avait forcement utilisé des variables pour résoudre des équations (x = 3+2). X et la variable, 5 est la valeur de l’expression 3+2.

A lire  Posez vos questions sur le site !

Pour choisir le nom de vos variables il faut garder certains impératifs, incompatibilités et bonne pratique :

  • Les variables ne peuvent commencer par un chiffres.
  • Les majuscules sont à proscrire pour éviter les collusions avec les variables super-globales ainsi que les fautes de frappes.
  • Le nom d’un variable ne peut contenir de point.
  • La variable $this est réservé par le système et ne peut être réattribués.
  • Si vous pouvez utiliser $_mavariable, les doubles underscore « __ » sont aussi réservés et ne doivent être utilisés que suivant la documentation PHP sur les « fonctionnalités magiques » disponible sur PHP.net.

Exemples :

<?php
$var = 'ma';
$Var = ' variable';
echo "$var, $Var";         // affiche "ma variable"

$2var = 'echec';     //  commence par un nombre
$_2var = 'ok';    //  commence par un souligné
$michaël = 'ok';    //  'ë' est ASCII.
?>
Sources : PHP.net

 

Une variable peut contenir huit types de valeurs

4 types scalaires
  • Booléen (boolean) : vrai ou faux (TRUE ou FALSE).
  • Nombre entier (integer) : un nombre entier sans virgules (4863).
  • Nombre à virgule flottante (float ou double) : Une nombre à virgule (3.1416).
  • Chaîne de caractère (string) : Une suite de caractère alphanumérique (tout ce que vous voudrez ou presque)
2 types composés :
  • Tableau (array) : Une succession de valeurs attribuées à des clés, permettant la distinction entre les différentes valeurs.
array(
    key  => value,
    key2 => value2,
    key3 => value3,
    ...
)
Sources : PHP.net
  • Les objets (object) : Les objets sont le résultat d’une fonction, ils nécessitent l’utilisation de classe mais nous y reviendrons. Pour le moment il faut retenir le fait que les objets sont dynamique, là ou les array sont statiques, comprenez que la valeur d’un array ne change pas en fonction du contexte alors que c’est justement l’utilité des objets.
2 types spéciaux
  • Ressource : une ressource est une variable contenant une référence à une ressource externe permettant la récupération de la valeur.
  • NULL : Absence de valeur.
Exemples
<?php
$a_bool = TRUE;   // un booléen
$a_str  = "foo";  // une chaîne de caractères
$a_str2 = 'foo';  // une chaîne de caractères
$an_int = 12;     // un entier

echo gettype($a_bool); // affiche :  boolean
echo gettype($a_str);  // affiche :  string

// Si c'est un entier, incrément de 4
if (is_int($an_int)) {
    $an_int += 4;
}

// Si $a_bool est une chaîne de caractères, on l'affiche
if (is_string($a_bool)) {
    echo "String: $a_bool";
}
?>
Sources : PHP.net

Variables prédéfinies

PHP propose des variables intégrées afin de faciliter l’accès a certains informations dépendantes aussi bien du serveur que du contexte des requêtes.

<?php
echo $_SERVER['SERVER_NAME'];
?>
Sources : PHP.net

Ici le PHP répondra avec le nom de domaine du serveur exécutant la requêtes (www.occitaweb.fr).

Liste et détails des variables disponibles sur PHP.net.
  • Les Superglobales — Les Superglobales sont des variables internes qui sont toujours disponibles, quel que soit le contexte
  • $GLOBALS — Référence toutes les variables disponibles dans un contexte global
  • $_SERVER — Variables de serveur et d’exécution
  • $_GET — Variables HTTP GET
  • $_POST — Variables HTTP POST
  • $_FILES — Variable de téléchargement de fichier via HTTP
  • $_REQUEST — Variables de requête HTTP
  • $_SESSION — Variables de session
  • $_ENV — Variables d’environnement
  • $_COOKIE — Cookies HTTP
  • $php_errormsg — Le dernier message d’erreur
  • $HTTP_RAW_POST_DATA — Données POST brutes
  • $http_response_header — En-têtes de réponse HTTP
  • $argc — Le nombre d’arguments passés au script
  • $argv — Tableau d’arguments passés au script

La portée des variables

Le PHP utilise des instances de script <?php instance du scritpt ?> et les valeurs que vous créerez seront lié à l’instance qui les a défini.

<?php
$a = 1; /* portée globale */
function test()
{ 
    echo $a; /* portée locale */
}
test();
?>
Sources : PHP.net

Dans l’exemple ci-dessus, $a retournera une valeur NULL. Car nous avons défini la valeur de $a dans une instance différente de la fonction qui appelle la variable.

Mot clé global

Pour utiliser une variable créée avec une portée locale, dans une requêtes globale, on peut déclarer une variable comme étant globale dans une instance locale.

<?php
$a = 1;
$b = 2;
function somme() {
    global $a, $b;
    $b = $a + $b;
}
somme();
echo $b;
Sources : PHP.net

Notre code PHP retournera bien une valeur de $b = 3.

Utilisation des variables static

Le mot clé static permet de définir des valeurs afin d’effectuer des opérations récursives. En clair de mettre en place des compteurs dont la valeur ne sera initialisé que si elle n’existe pas.

<?php
function test()
{
    static $a = 0;
    echo $a;
    $a++;
}
?>
Sources : PHP.net

Dans l’exemple la valeur de $a est incrémenté de +1 à chaque itération de la fonction. Sans l’utilisation du mot clé static, la valeur de $a serai systématiquement de 1 après chaque appel de la fonction.

La valeur d’une variable statique doit être défini par une valeur, et non pas le résultat d’une expression.

<?php
function foo(){
    static $int = 0;          // correct
    static $int = 1+2;        // faux  (car c'est une expression)
    static $int = sqrt(121);  // faux  (car c'est aussi une expression)

    $int++;
    echo $int;
}
?>
Sources : PHP.net

Les variables dynamiques

Utiliser des variables en utilisant une variable comme nom.

<?php
$a = 'variable1';
$variable1 = 3;
echo $$a; //affiche 3

?>

Sources : PHP.net

Exemples à manipuler

<?php
class foo {
    var $bar = 'I am bar.';
    var $arr = array('I am A.', 'I am B.', 'I am C.');
    var $r   = 'I am r.';
}

$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo $foo->$bar . "\n";
echo $foo->$baz[1] . "\n";

$start = 'b';
$end   = 'ar';
echo $foo->{$start . $end} . "\n";

$arr = 'arr';
echo $foo->$arr[1] . "\n";
echo $foo->{$arr}[1] . "\n";

Sources : PHP.net
?>

Et plus encore

$Bar = "a";
  $Foo = "Bar";
  $World = "Foo";
  $Hello = "World";
  $a = "Hello";

  $a; //Affiche Hello
  $$a; //Affiche World
  $$$a; //Affiche Foo
  $$$$a; //Affiche Bar
  $$$$$a; //Affiche a

  $$$$$$a; //Affiche Hello
  $$$$$$$a; //Affiche World

Sources : PHP.net

Variables externe à PHP

Pour gérer les informations transmisent par des formulaires, PHP utilise les variables $_REQUEST et $_POST qui sont des variables super-globale

A lire  SQL

Mais préalablement il nous faut créer un formulaire en HTML afin d’envoyer des données au PHP.

<form action="foo.php" method="post">
    Nom  :  <input type="text" name="username" /><br />
    Email: <input type="text" name="email" /><br />
    <input type="submit" name="submit" value="Envoie!" />
</form>

Sources : PHP.net

Afin de récupérer les données transmissent nous utiliserons :

<?php
echo $_POST['username'];
echo $_REQUEST['email'];
?>

Sources : PHP.net

Cookies HTTP

Le PHP permet de créer des cookies facilement :

<?php
if (isset($_COOKIE['compte'])) {
    $compte = $_COOKIE['compte'] + 1;
} else {
    $compte = 1;
}
setcookie('Panier', $compte, time()+3600);
setcookie("Panier[$compte]", $item, time()+3600);
?>

Sources : PHP.net
Description de l’exemple

Pour commencer on utilise l’instruction if pour déterminer si le cookie « compte » existe, ensuite si il existe on incrémente sa valeur et la stocke dans la variable locale $compte. Si non on attribut la valeur 1 à $compte.

Enfin on utilise la fonction setcookies() avec la valeur panier la variable $compte et la fonction time() plus 3600 secondes (soit 24h).

Manipuler les STRING

Et oui avec le PHP vous allez devoir apprendre à manipuler des chaines de caractères (effectivement ça perd à la traduction…).

PHP propose des fonctions pour effectuer des opérations de base.

Fonctions fondamentales

Les fonctions strlen(), str_word_count(), strrev(), strpos(), str_replace() permettent :

  • strlen() : Compte le nombre de caractères de la chaines.
  • str_word_count() : Compte le nombre de mots.
  • strrev() : Inverse la chaîne de caractère.
  • strpos() : Compte le nombre de caractère avant le ou les caractères recherché(s).
    Attention : le premier caractère est 0 pas 1 !
  • str_replace() : Recherche un caractère et le remplace dans une chaîne.
<?php
echo strlen("Hello world!"); 
// affiche 12
echo str_word_count("Hello world!"); 
// affiche 2
echo strrev("Hello world!"); 
// affiche !dlrow olleH
echo strpos("Hello world!", "world"); 
// affiche 6
echo str_replace("world", "Dolly", "Hello world!"); 
// affiche Hello Dolly!

?>

Constantes

Le PHP permet de définir des constantes qui vous pourrez rappeler.

<?php
define("BONJOUR", "Bien le Bonjour !", true);
echo bonjour;
?>

Les constantes ont une portée globale.

<?php
define("BONJOUR", "Bien le Bonjour !", true);

function salut() {
    echo BONJOUR;
}
 
salut();
?>

Opérateurs

En PHP les opérateurs sont des entités permettant l’assignation et la comparaison des variables.

Opérateurs arithmétiques

Le PHP permet de manipuler des valeurs et des variables via des opérateurs arithmétiques :

  • Addition : Renvoi la somme des valeurs ($x + $y).
  • Sous-traction : Effectue la différence entre les éléments ($x - $y).
  • Multiplication : Multiplie les éléments ($x * $y).
  • Division : Divise les éléments ($x / $y).
  • Modulo : Affiche la différence avec le résultat de la division ($x % $y).
  • Exponentiel : X puissance Y ($x ** $y).

Opérateurs d’assignation

On peut aussi effectuer les opérations lors de l’assignation de variable.

  • x = y correspond à x = y.
  • x += y correspond à  x = x + y.
  • x -= y correspond à x = x - y.
  • x *= y correspond à x = x * y.
  • x /= y correspond à x = x / y.
  • x %= y correspond à x = x / y.

Opérateurs de comparaisons

Ils permettent de comparer les éléments lors d’une opération conditionnelle.

  • == : Egal.
  • === : Identique.
  • != ou <> : Non égal.
  • !== : Non identique.
  • > : Supérieur à.
  • < : Inférieur à.
  • >= : Supérieur ou égal à.
  • <= : Inférieur ou égal à.

Opérateurs d’incrémentation / décrémentation

Augmente ou diminue la valeur de la variable.

  • ++$x : Pré-incrémentation
  • $x++ : Post-incrémentation
  • --$x : Pré-décrémentation
  • $x-- : Post-décrémentation

Opérateurs logique

Dans les fonctions nous aurons à effectuer des comparaisons, à cette fin nous utiliserons des opérateurs logiques.

  • and /&& : opérateur et.
  • or /|| : opérateur ou.
  • xor / ! : opérateur ou pas.

Opérateurs de chaîne

Enfin vous pourrez associer des chaines pour les afficher à la suite les une des autres.

  • . : Opérateur de concaténation. Permet d’écrire $x.$y.
  • .= : Permet de concaténer les éléments lors de l’assignation.

Les déclarations

En PHP on utilise les déclarations pour effectuer des opérations conditionnelles.

If, else, elseif

Pour commencer les déclarations, il faut utiliser les opérateurs que nous venons de voir.

if (condition) {
    //code à exécuter si la condition est remplis;
}

Cette déclaration est sommaire, mais si il y a un si il y a un sinon, et c’est ce que fait else.

if (condition) {
    //code à exécuter si la condition est remplis;
} else {
    //Code à exécuter si la condition n'est pas rempli;
}

Maintenant on peut utiliser plusieurs déclarations avec elseif.

if (condition) {
    //code à exécuter si la condition est remplis;
} elseif(condition2) {
    //code à exécuter si la condition2 est remplis;
} else {
    //code à exécuter si la condition et la condition2 ne sont pas remplis;
}

Switch

Elseif est intéressant mais si vous avez un grand nombres de possibilités, il est plus pratique d’utiliser switch qui permet d’exécuter une déclaration si la valeur est dans un des cas que vous avez prévu mais un exemple sera plus parlant :

<?php
$cas= "premier";

switch ($favcolor) {
    case "premier":
        echo "cas n°1 !";
        break;
    case "second":
        echo "cas n°2 !";
        break;
    case "troisiéme":
        echo "cas n°3 !";
        break;
    default:
        echo "cas indéfini !";
}
?>

Les boucles

Une des fonctionnalités essentielle de PHP, permet d’utiliser les array. Ces derniers permettent de stocker plusieurs variables dans des champs.

<?php 
$premiertrim = array(1 => 'Janvier', 'Février', 'Mars');
print_r($premiertrim );
?>
//affichera :
Array
(
    [1] => Janvier
    [2] => Février
    [3] => Mars
)

<?php 
echo $premiertrim[1];

?>
//affichera :
Janvier

Les boucles permettent de traiter les champs à tour de rôle sans avoir besoin de rédiger une nouvelle déclaration à chaque fois.

A lire  Construire une page en HTML5

While

La boucle while permet de répéter une déclarations tant qu’une condition retourne la valeur booléenne TRUE.

<?php 
$x = 1; 

while($x <= 3) {
    echo "Le mois est : $premiertrim[$x] <br>";
    $x++;
} 
?>
//Le résultat sera :
Le mois est : Janvier
Le mois est : Février
Le mois est : Mars

Do while

A la différence de while, do while effectuera la déclaration une première fois avant de vérifier si il faut ou non répété la déclaration.

<?php 
$x = 1; 

do {
    echo "le nombre est : $x <br>";
    $x++;
} while ($x <= 5);
?>

For

La boucle PHP for fonctionne comme while mais on l’utilise quand on souhaite limiter par avance le nombre d’itération.

for (compteur; validité du compteur; incrémentation du compteur) {
    code à répéter;
}

Dans les faits la boucle fonctionne comme les exemples précédent mais en simplifiant le code.

<?php 
for ($x = 0; $x <= 10; $x++) {
    echo "le nombre est : $x <br>";
} 
?>
//se répète de 0 a 10.
//car l'itération de la valeur s’exécute à la fin de la boucle.

For each

Enfin la boucle for each permet elle, de répéter la déclaration pour chaque champ d’un array.

<?php 
$mois = array("janvier", "février", "mars"); 

foreach ($mois as $m) {
    echo "$m <br>";
}
?>
//affichera les 3 premiers mois sur 3 lignes.

Fonctions

Les fonctions permettent de rappeler des déclarations. Certaines déclarations sont complexes d’autres récurrentes, on utilise les fonctions pour enregistrer des déclarations et rappeler facilement.

function mafonction() {
   echo "je suis une fonction !";
}

mafonction();
//affichera : "je suis une fonction !

Vous remarquez qu’une fonction s’écrit avec des parenthèses, ces dernières sont destiné à accueillir des paramètres.

<?php
function familyName($fname, $year) {
    echo "$fname Refsnes. Né en $year <br>";
}

familyName("Hege", "1975");
familyName("Stale", "1978");
familyName("Kai Jim", "1983");
?>

Il est possible de définir la valeur par défaut de paramètres.

function definirtaille($minheight = 50) {
}

Les classes en PHP

Les classes sont aux fonctions ce que les array() sont aux variables. Une classe permet de créer des objets qui seront manipuler. C’est ce qu’on appelle la programmation orienté objet ou POO. A la différence de la méthode procédurale que nous avons utiliser jusqu’ici, la POO ne sépare pas les données des fonctions.

En créant une classe on crée un objet qui regroupe des variables et des fonctions, afin de traiter facilement des données.

Créer un objet en PHP

Pour commencer il nous faut créer l’objet à manipuler

$obj = new Monobjet;

L’objet est maintenant stocké dans la variable $obj. Mais il ne contient rien, pour mieux comprendre ce que nous allons faire, nous prendrons le cas d’une équipe sportive.

Notre modèles va définir des variables comme le nombres de victoire, de défaites, et de match nul. Qui seront lié à des méthodes comme la victoire, la défaite et le nul.

<?php
class Equipe
{
  private $_victoire;
  private $_defaite;
  private $_nul;
        
  // Nous déclarons une méthode dont le seul but est d'afficher un texte.
  public function victoire()
  {
    echo 'Victoire';
  }
  public function defaite()
  {
    echo 'Défaite !';
  }
  public function nul()
  {
    echo 'Nul !';
  }
}
    
$e = new Equipe;
$e->victoire();

Premiérement on crée la classe Equipe avec class Equipe, on défini les variables de la classe avec private $_*, ensuite on crée les méthodes avec function *() et enfin on crée l’objet avec new.

La dernière ligne utilise la méthode victoire de l’objet $e.

 

© 2018 Occitaweb formation WordPress et média sociaux