init

.gitignore

@@ -0,0 +1 @@
+_book

README.md

@@ -0,0 +1,6 @@
+# PHP 5
+## Simon Vieille <simon@deblan.fr>
+
+### LPWD Alt - IUT-BM - 2015/2016
+
+Licence [WTFPL](http://www.wtfpl.net/)

SUMMARY.md

@@ -0,0 +1,24 @@
+# Summary
+
+* [Introduction](README.md)
+* [Histoire](histoire/README.md)
+* [Installer PHP](installer_php/README.md)
+* [Les bases](les_bases/README.md)
+   * [Introduction](les_bases/introduction.md)
+   * [Insérer du php dans une page](les_bases/inserer_du_php_dans_une_page.md)
+   * [Commentaires](les_bases/commentaires.md)
+   * [Les variables](les_bases/les_variables.md)
+   * [Les types de données](les_bases/les_types_de_donnees.md)
+   * [Les opérateurs de calcul](les_bases/les_operateurs_de_calcul.md)
+   * [Les opérateurs d'assignation](les_bases/les_operateurs_dassignation.md)
+   * [Les opérateurs d'incrémentation](les_bases/les_operateurs_dincrementation.md)
+   * [Les opérateurs de comparaison](les_bases/les_operateurs_de_comparaison.md)
+   * [Les opérateurs logiques](les_bases/les_operateurs_logiques.md)
+   * [Les structures de contrôle](les_bases/les_structures_de_controle.md)
+   * [Les boucles](les_bases/les_boucles.md)
+   * [Exercice](les_bases/test.md)
+* [Un peu plus loins…](un_peu_plus_loins/README.md)
+   * [Les variables superglobales](un_peu_plus_loins/les_variables_globales.md)
+   * [Les constantes](un_peu_plus_loins/les_constantes.md)
+   * [Les fonctions](un_peu_plus_loins/les_fonctions.md)
+

histoire/README.md

@@ -0,0 +1,22 @@
+# Histoire
+
+> Le langage PHP fut créé en 1994 par Rasmus Lerdorf pour son site web. C'était à l'origine une bibliothèque logicielle en C6 dont il se servait pour conserver une trace des visiteurs qui venaient consulter son CV. Au fur et à mesure qu'il ajoutait de nouvelles fonctionnalités, Rasmus a transformé la bibliothèque en une implémentation capable de communiquer avec des bases de données et de créer des applications dynamiques et simples pour le Web. Rasmus décida alors en 1995 de publier son code, pour que tout le monde puisse l'utiliser et en profiter7.
+>
+> [...]
+>
+> PHP: Hypertext Preprocessor3, plus connu sous son sigle PHP (acronyme récursif), est un langage de programmation libre4 principalement utilisé pour produire des pages Web dynamiques via un serveur HTTP3, mais pouvant également fonctionner comme n'importe quel langage interprété de façon locale. PHP est un langage impératif orienté objet comme C++.
+>
+>PHP a permis de créer un grand nombre de sites web célèbres, comme Facebook, YouTube, Wikipedia, etc.5 Il est aujourd'hui considéré comme la base de la création des sites Internet dits dynamiques.
+
+Source : [Wikipedia](https://fr.wikipedia.org/wiki/PHP)
+
+## En gros, PHP c'est quoi ?
+
+- C'est un langage de programmation interprété
+- Il s'exécute coté serveur
+- Il est flexible et supporte une variété de techniques de développement
+    - Programmation fonctionnelle
+    - Programmation orentié objet (POO)
+- Il est composé de beaucoup de bibliothèques lui permettant de faire tout et n'importe quoi
+- On l'utilise principalement pour créer des sites mais il peut s'exécuter en ligne de commandes
+

installer_php/README.md

@@ -0,0 +1,39 @@
+# Installer PHP
+
+Dans notre contexte, PHP sera utilisé au travers d'un serveur web. Il est donc nécessaire d'installer un ensemble d'outils en plus de PHP.
+
+4 logiciels seront nécessaires pour travailler ensemble : un serveur web (Apache), PHP (version 5.4 minimum), MySQL et PhpMyAdmin.
+
+Apache va vous permettre d'accéder à du contenu de votre machine via le protocole HTTP. PHP sera utilisé par Apache pour exécuter les documents PHP pour délivrer le résultat à votre navigateur. MySQL est un serveur de base de données. PhpMyAdmin est une GUI pour administrer MySQL.
+
+Si vous être un warrior, ça sera via votre gestionnaire de paquet. Typiquement, la démarche à suivre sous Debian :
+
+```bash
+sudo aptitude install apache2 libapache2-mod-php5 mysql-server phpmyadmin
+```
+
+Les Mac users et les Windowsiens devront installer respectivement MAMP et WAMP qui contiennent tout ce qu'il faut avec en prime une jolie interface graphique pour (presque) tout gérer.
+
+Une fois ces logiciels installés, vous aurez un répertoire de travail nommé ```www```,  ```htdocs``` ou similaire dans votre serveur web. Si vous êtes sous Linux, il sera par défaut dans ```/var/www```. Sur Mac, il est du coté de ```/Application/MAMP``` et concernant Windows, vous devriez avec un répertoire à la racine de votre disque C: (```C:\Wamp\```).
+C'est ici que vous allez travailler.
+
+## Votre premier script
+
+Dans le répertoire de travail, ajoutez un répertoire ```test``` dans lequel vous placerez un fichier ```index.php```. Voici son contenu :
+
+```php
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>Mon premier script</title>
+</head>
+<body>
+
+<p><?php echo 'Hello world'; ?></p>
+
+</body>
+</html>
+```
+
+En accédant à la page http://localhost/test/index.php, vous allez voir apparaître le message ```Hello World```.

les_bases/README.md

@@ -0,0 +1,2 @@
+# Les bases
+

les_bases/commentaires.md

@@ -0,0 +1,34 @@
+# Commentaires
+
+Un commentaire est un morceau de texte qui ne sera pas interprété.
+
+Pour rédiger des commentaires, plusieurs écritures sont possibles :
+
+```php
+// Un commentaire sur une seule ligne
+```
+ou
+```php
+# Un autre commentaire sur une seule ligne
+```
+et
+
+```php
+/* Un commentaire
+sur plusieurs
+lignes
+*/
+```
+
+Il existe des commentaires particuliers nommées "annotations". Ces commentaires sont suceptibles d'êtres interprétés par des outils externes. Typiquement, quand vous souhaitez générer une documentation technique, vous en avez besoin.
+
+```php
+/*
+ * @return String
+ * @param $name String Le nom de la personne à qui dire bonjour
+ */
+function helloWorld($name) {
+    return 'Hello world, ', $name;
+}
+
+```

les_bases/inserer_du_php_dans_une_page.md

@@ -0,0 +1,12 @@
+# Insérer du php dans une page
+
+PHP est un langage qui a pour objectif principal de générer du code HTML. Il est donc possible d'écrire du PHP dans du code HTML. Pour que PHP soit interprété comme tel, il doit être utilisé entre des balises particulières :
+
+```php
+<p>Voici du code html <?php et du code PHP (qui ne fonctionne pas tel quel) ?></p>
+```
+
+Il existe aussi les notations ```<? ?>``` et ```<% %>``` mais elles sont très dépréciées.
+
+Quand un document est terminé par du PHP, il n'est pas nécessaire d'utiliser la balise de fermeture.
+

les_bases/introduction.md

@@ -0,0 +1,13 @@
+# Introduction
+
+Un code bien écrit est un code qui se débug plus facilement. Pour ne pas partir dans tous les sens, on va utilier la convention PSR-2 : https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md
+
+Je vous recommande versionner votre code. Libre à vous de choisir votre outil de versionning. Je vous recommande GIT mais vous pouvez aussi jouer avec Subversion (SVN). Soit vous passez par un service externe (Github par exemple) ou bien en locale (votre machine).
+
+Quand vous avez un problème :
+
+- (Re)lire la documentation (RTFM n'est pas une légende) : **http://php.net/**
+- Rechercher sur la toile car vous n'inventerez aucun nouveau problème
+- Vous avez aussi le droit de me payer une bière et de me poser des questions
+
+

les_bases/les_boucles.md

@@ -0,0 +1,40 @@
+# Les boucles
+
+La boucle est une structure qui permet de faire d'itérer du code suivant une condition ou une donnée.
+
+## La boucle for
+
+```php
+for ($u = 0; $u < 10; $u++) {
+    // le code qui s'exécute tant que la condition $u < 10 est vraie
+}
+```
+
+Cette boucle prend 3 paramètres :
+- un paramètre d'initialisation des données, ici ```$u = 0```
+- une condition : ici ```$u < 10```
+- une opération : ici ```$u++```
+
+Si ```$u``` n'est pas modifié dans le code exécuté, alors cette boucle sera exécutée 10 fois.
+
+## La boucle while
+
+```php
+while (condition) {
+    // code qui s'exécute tant que la condition est vraie
+}
+
+do {
+    // code qui s'exécute une fois puis tant que la condition est vraie
+} while (condition);
+```
+
+## La boucle foreach
+
+```php
+foreach ($tableauDeDonnees as $index => $valeur) {
+    // parcours toutes les valeurs de $tableauDeDonnees
+}
+```
+
+Les boucles ```while``` et ```for``` sont des cas d'erreur fréquent : quand la condition est toujours vraie, elles n'exécutent indéfiniment et le serveur crash.

les_bases/les_operateurs_dassignation.md

@@ -0,0 +1,10 @@
+# Les opérateurs d'assignation
+
+Ils s'appuient sur les opérateurs de calcul et réduisent la quantité de code à écrire :
+
+- ```$a += $b``` : additionne \$b à \$a, équivalent de ```$a = $a + $b```
+- ```$a -= $b``` : soustrait \$b de \$a, équivalent de ```$a = $a - $b```
+- ```$a *= $b``` : multiplie \$a par \$b, équivalent de ```$a = $a * $b```
+- ```$a /= $b``` : divise \$a par \$b, équivalent de ```$a = $a / $b```
+- ```$a %= $b``` : donne le reste de la division euclidienne de \$a par \$b, équivalent de ```$a = $a % $b```
+- ``` $a .= $b``` : concatène la chaine \$b à \$a, équivalent de ```$a = $a . $b```

les_bases/les_operateurs_de_calcul.md

@@ -0,0 +1,41 @@
+# Les opérateurs de calcul
+
+## Addition
+
+```php
+$a = $b + $c;
+```
+
+## Soustraction
+
+```php
+$a = $b - $c;
+```
+
+## Mutiplication
+
+```php
+$a = $b / $c;
+```
+
+## Division
+
+```php
+$a = $b + $c;
+```
+
+## Reste division euclidienne
+
+```php
+$a = $b % $c;
+```
+
+## La concaténation
+
+```php
+$a = $b . $c;
+
+// Si $b = "Je suis "
+// Et $c = "beau"
+// Alors $a = "Je suis beau"
+```

les_bases/les_operateurs_de_comparaison.md

@@ -0,0 +1,12 @@
+# Les opérateurs de comparaison
+
+- Pour tester une égalité : ```$a === $b```
+- Pour tester une inégalité : ```$a !== $b```
+- Pour tester une valeur plus grande : ```$a > $b```
+- Pour tester une valeur plus grande ou égale : ```$a >= $b```
+- Pour tester une valeur plus petite : ```$a < $b```
+- Pour tester une valeur plus petite ou égale : ```$a <= $b```
+
+Ces opérations retournent ```true``` ou ```false```.
+
+

les_bases/les_operateurs_dincrementation.md

@@ -0,0 +1,19 @@
+# Les opérateurs d'incrémentation
+
+```php
+$a = 0;
+echo $a++; // Affiche : 1
+echo $a; // Affiche : 1
+
+$b = 1;
+echo $b--; // Affiche : 0
+echo $b; // Affiche : 0
+
+$c = 0;
+echo ++$c; // Affiche : 0, $c est modifié à l'instruction suivante
+echo $c; // Affiche : 1
+
+$d = 1;
+echo --$d; // Affiche : 1 $d est modifié à l'instruction suivante
+echo $d; // Affiche : 0
+```

les_bases/les_operateurs_logiques.md

@@ -0,0 +1,9 @@
+# Les opérateurs logiques
+
+
+- ET logique : ```condition && autreCondition```
+- OU logique : ```condition || autreCondition```
+- NON logique : ```!condition```
+- Les parenthèses : ```condition || (autreCondition && !uneAutreCondition)```
+
+Ces opérations retournent ```true``` ou ```false```.

les_bases/les_structures_de_controle.md

@@ -0,0 +1,25 @@
+# Les structures de contrôle
+
+Pour exécuter du code suivant certaines conditions, on utilise des structures de contrôle.
+
+```php
+if (condition) {
+    // code
+} elseif (autreCondition) {
+    // code
+} else {
+    // code
+}
+
+switch (valeur) {
+    case test1:
+        // action si test1 vrai
+        break;
+    case test2;
+        // action si test2 vrai
+        break;
+    case default: // action par défaut
+}
+
+$valeur = condition ? siVrai : siFaux;
+```

les_bases/les_types_de_donnees.md

@@ -0,0 +1,35 @@
+# Les types de données
+
+Un type est ce qui caractérise une donnée. Suivant le type d'une donnée, des opérations seront possibles ou pas. PHP n'est pas un langage fortement typé. On dit qu'il fait  du typage dynamique : une variable peut sucessivement contenu des types différents.
+
+```php
+$entier = 10;
+
+$flottant = 5.5; // notation anglaise de la virgule
+
+$chaine = "Je suis une chaine de caractères";
+
+$tableau = array(
+    "première valeur",
+    "deuxième valeur",
+    3,
+); // ou bien ["a", "b", "c",] depuis PHP 5.4
+
+$booleen = true;
+
+$autreBooleen = false;
+
+$objet = new DateTime();
+
+$closure = function() {
+    // code
+}
+```
+
+Connaître le type d'une variable est essentiel pour ne pas générer de bug. Dans le cadre d'un développement, vous pourrez analyser ce que contient une donnée avec ```var_dump``` :
+
+```php
+$variable = "foo";
+
+var_dump($variable); // Affiche : string(3) "foo"
+```

les_bases/les_variables.md

@@ -0,0 +1,23 @@
+# Les variables
+
+Les variables permettent de stocker des données. En PHP, une variable peut recevoir plusieurs type de données qu'on verra dans le slide suivant.
+
+Pour déclarer une variable, on utiliser le signe ```$``` suivi de son nom. Il ne peut comporter que des lettres non accentuées (majuscules et minuscules), des chiffres et des "_". Les chiffres ne sont pas autorisés en début de nom.
+
+```php
+$prenom = "Simon";
+$nom = "Vieille";
+$age = 26;
+$une_autre_variable = "foo"; // la norme PSR-2 déprécie cette écriture non camelCase
+```
+
+À tout moment le contenu d'une variable pour être modifié.
+
+Pour afficher le contenu d'une variable, on utilise la fonction ```echo```.
+
+```php
+$prenom = 'Simon';
+echo $prenom; // Affiche : Simon
+```
+
+Vous pouvez remarquer qu'à chaque fin d'instruction, il y a un ";". Il est impératif de l'ajouter sinon vous aurez des erreurs.

les_bases/test.md

@@ -0,0 +1,47 @@
+# Exercice
+
+Réaliser un programme qui affiche les tables de multiplication. Je souhaite également que si le résultat de l'opération est ```42``` alors un message particulier est affiché.
+
+Le résultat attendu est :
+
+```
+1 multiplié par 1 vaut 1
+1 multiplié par 2 vaut 2
+1 multiplié par 3 vaut 3
+1 multiplié par 4 vaut 4
+1 multiplié par 5 vaut 5
+1 multiplié par 6 vaut 6
+1 multiplié par 7 vaut 7
+1 multiplié par 8 vaut 8
+1 multiplié par 9 vaut 9
+2 multiplié par 1 vaut 2
+2 multiplié par 2 vaut 4
+2 multiplié par 3 vaut 6
+2 multiplié par 4 vaut 8
+2 multiplié par 5 vaut 10
+2 multiplié par 6 vaut 12
+2 multiplié par 7 vaut 14
+2 multiplié par 8 vaut 16
+2 multiplié par 9 vaut 18
+3 multiplié par 1 vaut 3
+....
+6 multiplié par 6 vaut 36
+6 multiplié par 7 est la réponse à la grande question sur la vie, l'univers et le reste !
+6 multiplié par 8 vaut 48
+....
+```
+
+## Aide
+
+Il est possible d'imbriquer les boucles :
+
+```php
+for (....) {
+    for (....) {
+
+    }
+}
+```
+…et c'est pareil avec les conditions.
+
+N'oubliez pas que vous allez générer de l'HTML. Pensez à placer les lignes générées dans des paragraphes ou ajoutez des ```<br>``` pour les retours chariot !

un_peu_plus_loins/README.md

@@ -0,0 +1,4 @@
+# Un peu plus loins…
+
+Maitenant que vous avez le vocabulaire de base, nous allons etoffer quelques notions.
+

un_peu_plus_loins/les_constantes.md

@@ -0,0 +1,5 @@
+# Les constantes
+
+Les constantes sont un genre de variables…qui ne peut pas varier. Elles ont les même contraintes de nommage que les variables mais ne possède pas de ```$```. Par ailleurs, elles sont définies avec la fontion ```define``` et une seule fois seulement.
+
+Des constantes PHP existent déjà telles que ```PHP_VERSION``` et ```PHP_OS``` mais aussi tout un tas de paramètres pour les fonctions.

un_peu_plus_loins/les_fonctions.md

@@ -0,0 +1,57 @@
+# Les fonctions
+
+Les fonctions peuvent être assimilté à des robots. Elles sont utilisées pour énormément de choses et vous avez la possibilité d'en créer.
+
+Elles sont créées pour réaliser une tâche bien précise qui est suceptible d'être répétée plusieurs fois dans l'application.
+
+Exemple : j'ai besoin de calculer la surface de 10 carrés donc je connais les dimensions qui sont respectivement : 10, 198, 72, 17, 92, 7293, 1287, 32, 1238, 7 (en m).
+
+Un code naïf aurait cette forme :
+
+```php
+echo 'La surface du rectangle avec la dimension 10 est '.(10 * 10).'m²';
+echo 'La surface du rectangle avec la dimension 198 est '.(198 * 198).'m²';
+echo 'La surface du rectangle avec la dimension 72 est '.(72 * 72).'m²';
+echo 'La surface du rectangle avec la dimension 17 est '.(17 * 17).'m²';
+echo 'La surface du rectangle avec la dimension 92 est '.(92 * 92).'m²';
+echo 'La surface du rectangle avec la dimension 7293 est '.(7293 * 7293).'m²';
+[...]
+```
+On réalise ici que le code, bien qu'il fonctionne, est très répétitif. On se doute que si la phrase doit être modifiée, alors ça prendrait un temps important pour tout modifier.
+
+On remarque qu'on répète toujours la même chose : afficher une phrases contenant 2 éléments variants : la dimension et la surface.
+
+```
+function surface($dimension) {
+    $surface = $dimension * $dimension;
+    return 'La surface du rectangle avec la dimension '.$dimension.' est '.$surface.'m²';
+}
+
+echo surface(10);
+echo surface(198);
+echo surface(72);
+echo surface(17);
+echo surface(92);
+echo surface(7293);
+echo surface(1287);
+echo surface(32);
+echo surface(1238);
+```
+
+En plus d'avoir du code plus simple à lire (et à comprendre), il est aussi plus simple à débugger.
+
+Mais du coup, on peut aller un peu plus loin encore. Finalement, la dizaine de dimensions est une liste qu'il suffirait de parcourir avec une boucle.
+
+```php
+function surface($dimension) {
+    $surface = $dimension * $dimension;
+    return 'La surface du rectangle avec la dimension '.$dimension.' est '.$surface.'m²';
+}
+
+$dimensions = [10, 198, 72, 17, 92, 7293, 1287, 32, 1238, 7];
+
+foreach ($dimensions as dimension) {
+    echo surface($dimension);
+}
+```
+

un_peu_plus_loins/les_variables_globales.md

@@ -0,0 +1,39 @@
+# Les variables superglobales
+
+Les variables superglobales sont générées autoamtiquement par l'environnement PHP. Elles incluent tout un tas de choses telles que des informations sur le serveur et les données envoyées par l'utilisateur. Elles sont accessibles partout dans une application mais varient en fonction du serveur et de l'internaute.
+
+Il en existe quelques-unes dont les plus importantes sont :
+
+- ```$_GET``` : un tableau contenant les données de la **query_string** d'une requête HTTP. Typiquement, la partie en rouge de cette url : https://www.qwant.com/?<span style="color: red">**q=deblans&client=opensearch**</span>
+
+```
+array(2) {
+  'q' =>
+  string(6) "deblan"
+  'client' =>
+  string(10) "opensearch"
+}
+```
+
+- Vous avez la variantes avec les requêtes HTTP Post où les données sont dans l'entête : ```$_POST```.
+- La variable ```$_SERVER``` détails toutes les informations du système : OS, mémoire, configuration, etc.
+
+```
+array(62) {
+  'MAIL' =>
+  string(15) "/var/mail/simon"
+  'USER' =>
+  string(5) "simon"
+  'XDG_SEAT' =>
+  string(5) "seat0"
+  'SSH_AGENT_PID' =>
+  string(4) "3490"
+  'SHLVL' =>
+  string(1) "1"
+  'HOME' =>
+  string(11) "/home/simon"
+  [...]
+```
+
+- Les cookies sont accessibles via ```$_COOKIE``` et les données stockées en session (coté serveur et coté client) avec ```$_SESSION```
+