Il est possible d'afficher toutes les solutions via ?solutions=1.
Rappel : vos programmes PHP doivent être transférés sur le serveur forge dans votre répertoire forge_html avant d'être utilisés. Vous pouvez les éditer sous Windows ou sous Linux, mais au final ils doivent être exécutés sur forge. Il faut utiliser ssh -X -Y login@janus.info.univ-angers.fr pour vous connecter ou ssh -X -Y login@forge si vous êtes dans une des salles locales de TP.
Ecrire un programme PHP qui fonctionne en mode CLI (ligne de commande) qui affiche la date et l'heure et le numéro de la version du PHP utilisé sur le serveur.
Pour la date et l'heure, on utilise la même fonction de PHP nommée date mais avec des paramètres différents. Il est conseillé de lire au moins une fois le manuel de PHP à l'adresse http://php.net/manual/fr/function.date.php pour voir toutes les options possibles. Voici ce qu'on peut écrire pour réaliser l'exercice :
<?php
echo "La date est ".date("d/m/Y")." et l'heure ".date("H:i")."." ;
echo "\n" ;
echo "Version de PHP : ".phpversion().".\n" ;
?>
La fonction nommée phpversion() renvoie, en plus du numéro de version le nom du système d'exploitation. Par contre l'instuction phpinfo() renvoie toute la configuration de PHP. Ainsi, le simple programme
<?php phpinfo() ?>
renvoie tout ce que vous pouvez lire à l'URL phpinfo.php. Cela permet en particulier de savoir comment est configuré le serveur, quel codage il utilise pour les accents, quels modules sont disponibles...
Ecrire un programme PHP qui fonctionne en mode CLI qui a besoin de deux paramètres : une valeur numérique et le mot "pouces" ou le mot "cm". On effectuera alors la conversion idoine, sachant qu'un pouce vaut 2,54 cm. Voici un exemple de ce qu'on voudrait comme fonctionnement :
$gh> php convcminch.php
Désolé, mais je n'ai pas assez d'informations pour convertir.
Vous devez fournir un nombre et le mot pouces ou le mot cm.
Par exemple, si vous tapez php convcminch.php 9 pouces, je ferai la conversion en centimètres.
$gh> php convcminch.php 10 pouces
10 pouces = 25.4 cm.
$gh> php convcminch.php 10 cm
10 cm = 3.9370078740157 pouces.
# mieux :
$gh> php convcminch.php 10 cm
10 cm = 3.94 pouces (arrondi).
Volontairement, on n'utilisera aucune fonction et on ne fera aucun test sur la valeur numérique afin de voir commment PHP se comporte en cas de donnée mal typée.
Y a-t-il une façon standard d'écrire des paramètres sous Linux ?
Ecrire un programme similaire qui fonctionne avec les paramètres val et unit passés en méthode GET dans l'URL. Voir la page convcminch2.php comme exemple. On pourra utiliser les fichiers debutpage.php et finpage.php de l'archive debutfin.zip pour générer le début et la fin de la page.
Ecrire enfin une page XHTML Strict valide basée sur le "squelette" de page sqs.htm avec un formulaire dont l'attribut action est convcminch2.php.
Pour tester le nombre d'arguments, on peut utiliser argc et pour leur valeur on utilise argv qui font partie des variables dites réservées. Un exemple de solution est convcminch.php :
<?php
# (gH) -_- convcminch.php ; TimeStamp (unix) : 25 Février 2013 vers 12:19
#####################################################################
# #
# conversion pouce/cm en ligne de commande (dans les deux sens) #
# #
#####################################################################
# ATTENTION : ce programme s'utilise en ligne de commande !
# si vous ne comprenez pas comment sont stockés les paramètres,
# décommentez l'instruction suivante :
# print_r($argv) ;
# s'il y a moins de 3 paramètres, on ne peut pas effectuer de conversion
# et on le dit
if ($argc<3) {
echo "\n" ;
echo " Désolé, mais je n'ai pas assez d'informations pour convertir.\n" ;
echo " Vous devez fournir un nombre et le mot pouces ou le mot cm. \n" ;
echo " Par exemple," ;
echo " si vous tapez php convcminch.php 9 pouces, je ferai la conversion en centimètres.\n\n" ;
exit(-1) ; # force à quitter le programme
} # fin si
# arrivé ici, on est sur d'avoir le bon nombre de paramètres
$valeur = $argv[1] ; # car $argv[0] est le nom du programme en cours d'exécution
$unite = $argv[2] ; # sans doute pouce ou cm
if ($unite=="pouces") {
$fact = 2.54 ;
$autreu = "cm" ;
} ; # fin si
if ($unite=="cm") {
$fact = 1/2.54 ;
$autreu = "pouces" ;
} ; # fin si
echo " $valeur $unite = ".($valeur*$fact)." $autreu.\n" ;
# sans doute mieux, avec arrondi et calcul séparé de l'affichage :
$valCnv = $valeur*$fact ;
$valCnv_f = sprintf("%0.2f",$valCnv) ;
echo " $valeur $unite = $valCnv_f $autreu (arrondi).\n" ;
?>
Si on se trompe sur l'unité, par exemple en écrivant pomme ou pouce au lieu de pouces (donc sans "S"), la variable $fact n'est pas définie, pas plus que $autreu, d'où deux erreurs. De même, si on ne fournit pas un nombre mais une chaine, il devrait y avoir une erreur mais PHP renvoie 0, tout simplement :
$gh> php convcminch.php 10 pommes
PHP Notice: Undefined variable: fact in /home/gh/public_html/internet/convcminch.php on line 48
PHP Stack trace:
PHP 1. {main}() /home/gh/public_html/internet/convcminch.php:0
PHP Notice: Undefined variable: autreu in /home/gh/public_html/internet/convcminch.php on line 48
PHP Stack trace:
PHP 1. {main}() /home/gh/public_html/internet/convcminch.php:0
10 pommes = 0 .
$gh> php convcminch.php deux pouces
deux pouces = 0 cm.
deux pouces = 0.00 cm (arrondi).
Sous Linux, on écrit des paramètres nommés à l'ancienne mode avec un tiret et un espace, à la nouvelle mode avec deux tirets et un signe égale. Voici ce que cela donnerait si on décide de nommer unit et val les paramètres :
$gh> # ancien style :
php convcminch.php -val 10 -unit pouces
$gh> # nouveau style :
php convcminch.php --val=10 --unit=pouces
Le code-source PHP de la page nommée convcminch2.php qui gère ces paramètres avec la méthode GET est ici et un exemple de formulaire basé sur sqs.htm est là.
Quelqu'un vous dit que la fonction ucfirst() fait une «quasi uppérisation» d'une chaine de caractères. Avez-vous besoin d'écrire un programme php pour tester ce que fait cette fonction ?
Téléchargez l'archive debutfin.zip et reproduisez le programme suivant que vous nommerez essaipage.php. Où seront les sauts à la ligne dans la page Web ? Et dans le code-source généré de la page Web ? Que se passe-t-il s'il y a une erreur, par exemple si on écrit echi au lieu de echo ? Au passage, rappelez où on peut trouver une liste des entités XHTML.
On en profitera pour installer HTML VALIDATOR de M. Gueury.
<?php
require "debutpage.php" ;
echo "<h1>Page valide</h1>\n" ;
echo "<p>Bonjour \n à tous " ;
echo " et à " ;
echo "toutes.<br />A bientôt.</p> " ;
require "finpage.php" ;
?>
Il est possible de rapatrier l'archive et de la décompresser en ligne de commandes (dans le bon répertoire !) via :
> cd ~/forge_html/
> wget http://forge.info.univ-angers.fr/~gh/internet/debutfin.zip
> unzip debutfin.zip
Les sauts de ligne dans le code source HTML apparaissent uniquement quand on demande à PHP de produire \n. Par contre au niveau de la page Web, vous devez vous rappeler que tous les espaces, tabulations et sauts de ligne sont remplacés par un seul espace. Donc seules des balises explicites comme <br>, <p>, <li>... ou des marges induites par le CSS permettent de passer à la ligne. Ce qui signifie que le texte "à tous et à toutes." est sur une seule ligne, les mots étant séparés par un seul espace. Vérification : ici.
En cas d'erreur, par exemple avec echi au lieu d'echo, le serveur réagit en fonction de sa configuration. Ainsi sur forge, une erreur fait que la page est vide... dommage ! Avec un serveur configuré autrement, on peut avoir le détail (pas toujours très compréhensible) de l'erreur comme ci-dessous :
Pour retrouver une liste d'entités XHTML, Google est notre ami, soit le lien français entités ou le lien anglais entities. Parmi les listes proposées, nous conseillons celle de la W3 School, celle de elizabethcastro et enfin celle du wiki anglais.
Combien de cas faut-il envisager et tester avant d'être convaincu que le programme en ligne de commande convcminch.php est correct et qu'on a «tout prévu» ?
Au passage, quelle est la différence entre développer et programmer ?
Il faut certainement prévoir et tester au moins 7 cas :
un cas sans aucun paramètre ;
un cas avec tous les paramètres corrects en nom et en valeur ;
un cas avec le paramètre val absent ;
un cas avec le paramètre unit absent ;
un cas avec la valeur du paramètre val mal typée ;
un cas avec la valeur du paramètre unit mal typée ;
un cas avec des valeurs des paramètres avec beaucoup de décimales.
Programmer, c'est juste écrire un programme. Développer, c'est réfléchir au problème, l'analyser, choisir des solutions, les programmer, les documenter, les tester...
Ainsi, pour l'exemple de conversion, un «vrai» développeur ajoutera la détection de l'initiale (p pour pouce, c pour cm), viendra certainement ajouter un s à pouce pour obtenir pouces au lieu de reprocher à l'utilisateur une mauvaise orthographe, il (elle) proposera peut-être d'utiliser aussi l'initiale i pour inch(es), voire même d (pour Daumen en allemand) si la page est beaucoup lue en Allemagne...
Reproduire la page mille.php. On utilisera debutpage.php et finpage.php comme précédemment mais aussi std.css afin d'avoir une page XHTML valide et «jolie». On produira le tableau avec une seule boucle pour dont l'indice variera de 1 à 15. Les valeurs seront arrondies et affichées à droite avec deux décimales.
Si on lit la documentation de list, on voit qu'il est effectivement possible de réaliser plusieurs affectations avec list à gauche et un tableau (array) à droite. Cela permet par exemple de permuter deux variables en une seule ligne, comme dans l'exemple suivant :
On voudrait implémenter une fonction pour produire des titres de niveau 1 avec <h1>. Ecrire une fonction achin() qui correspond au comportement suivant :
achin() ; # affiche un titre <h1> xhtml vide mais valide
achin("bonjour") ; # affiche <h1>bonjour</h1>\n
achin("oui","grouge","t25") ; # affiche <h1 class='grouge' id='t25'>oui</h1>\n
achin("oui","grouge","t25","onclick='show()'") ;
# affiche <h1 class='grouge' id='t25' onclick='show()'>oui</h1>\n
Quelle serait la syntaxe pour avoir juste une indication de classe ? Et d'id ?
On voudrait trouver la plus grande valeur d'un tableau et le nombre de fois où elle apparait. Pour cela, on commencera par écrire une fonction valMax($leTableau) qui calcule la plus grande valeur du tableau et on utilisera une deuxième boucle pour compter le nombre d'occurences du maximum.
Recommencer l'exercice en utilisant cette fois une seule boucle pour déterminer à la fois le maximum et son nombre d'occurences. On utilisera les valeurs 1 8 2 8 3 6 8 2 comme jeu d'essai dans un premier temps. Dans un second temps, on utilisera les valeurs "a", "b", "oui", "c", "oui", "d" comme jeu d'essai. On donnera aussi la position de la première et de la dernière occurence du maximum. On pourra se contenter d'une version en ligne de commandes.
On trouvera la solution dans valmax.php. Le non-typage explicite de PHP permet d'utiliser les instructions qu'il s'agisse d'un tableau de nombres ou de chaines de caractères. Voici la solution avec les lignes non numérotées :
<?php
##################################################################
function valMax($leTableau) {
##################################################################
# nbelt : nombre d'éléments dans le tableau
# maxjl : maximum courant (Jusque Là)
# idv : indice de valeur dans le tableau
# valc : valeur courante dans le tableau à l'indice idv
$nbelt = count($leTableau) ;
$maxjl = $leTableau[0] ;
for ($idv=0;$idv<$nbelt;$idv++) {
$valc = $leTableau[$idv] ;
if ($valc>$maxjl) { $maxjl = $leTableau[$idv] ; } ;
} ; # fin pour idv
return( $maxjl ) ;
} # fin de fonction valMax
##################################################################
$tableau = preg_split("/\s+/","1 8 2 8 3 6 8 2") ;
# si vous décommentez la ligne suivante, on trie des chaines de caractères :
# $tableau = preg_split("/\s+/","le chat, le chien et le rat sont des animaux") ;
echo "Voici le tableau utilisé :\n" ;
print_r($tableau) ;
# version 1 : utilisation de valMax et utilisation d'une boucle
# pour calculer le nombre d'occurences du max
$vmax = valMax($tableau) ;
echo "Version 1 : le plus grand élément est $vmax " ;
$nbmax = 0 ;
$nbelt = count($tableau) ;
for ($idv=0;$idv<$nbelt;$idv++) {
$valc = $tableau[$idv] ;
if ($valc==$vmax) { $nbmax++ ; } ;
} ; # fin pour idv
echo " et il apparait $nbmax fois.\n\n" ;
# version 2 : tout en une seule boucle
# nbelt : nombre d'éléments dans le tableau
# maxjl : maximum courant (Jusque Là)
# idv : indice de valeur dans le tableau
# valc : valeur courante dans le tableau à l'indice idv
# prem : première fois où on la voit
# dern : dernière fois où on la voit
# nboc : nombre d'occurences
$nbelt = count($tableau) ;
$maxjl = $tableau[0] ;
$prem = 1 ;
$dern = 1 ;
$nboc = 0 ;
for ($idv=0;$idv<$nbelt;$idv++) {
$valc = $tableau[$idv] ;
if ($valc==$maxjl) {
$nboc++ ;
$dern = $idv+1 ;
} else {
if ($valc>$maxjl) {
$maxjl = $tableau[$idv] ;
$nboc = 1 ;
$prem = $idv+1 ;
$dern = $idv+1 ;
} ; # fin si
} ; # fin de si
} ; # fin pour idv
echo "Version 2 : le plus grand élément est $vmax " ;
echo " et il apparait $nboc fois,\n" ;
echo "la première fois en position $prem et " ;
echo "la dernière fois en position $dern.\n\n" ;
/**************************************************
Affichage :
Voici le tableau utilisé
Array
(
[0] => 1
[1] => 8
[2] => 2
[3] => 8
[4] => 3
[5] => 6
[6] => 8
[7] => 2
)
Version 1 : le plus grand élément est 8 et il apparait 3 fois.
Version 2 : le plus grand élément est 8 et il apparait 3 fois,
la première fois en position 2 et la dernière fois en position 7.
avec les chaines de caractères :
--------------------------------
Voici le tableau utilisé :
Array
(
[0] => le
[1] => chat,
[2] => le
[3] => chien
[4] => et
[5] => le
[6] => rat
[7] => sont
[8] => des
Version 1 : le plus grand élément est sont et il apparait 1 fois.
Version 2 : le plus grand élément est sont et il apparait 1 fois,
la première fois en position 8 et la dernière fois en position 8.
**************************************************/
?>
Il serait possible de tout déterminer sans utiliser de boucle explicite car PHP dispose de nombreuses fonctions sur tableau. Voici par exemple comment trouver le maximum et son nombre d'occurences. Il faut bien sûr noter qu'utiliser ces fonctions ne garantit pas l'efficacité (et donc la rapidité de la solution).
<?php
/**************************************************/
function maxOcc($leTableau) {
/**************************************************/
echo "Voici le tableau utilisé :\n" ;
print_r($leTableau) ;
$tabOcc = array_count_values($leTableau) ;
echo "Voici la fréquence de chaque élément du tableau :\n" ;
print_r($tabOcc) ;
$vmax = max($leTableau) ;
$nboc = $tabOcc[ $vmax ] ;
echo "Le plus grand élément du tableau est $vmax " ;
echo " et il apparait $nboc fois.\n" ;
} # fin de fonction maxOcc
/**************************************************/
/**************************************************/
$tableau = preg_split("/\s+/","1 8 2 8 3 6 8 2") ;
# si vous décommentez la ligne suivante, on trie des chaines de caractères :
# $tableau = preg_split("/\s+/","le chat, le chien et le rat sont des animaux") ;
maxOcc( $tableau) ;
/**************************************************/
/**************************************************
Affichage :
Voici le tableau utilisé :
Array
(
[0] => 1
[1] => 8
[2] => 2
[3] => 8
[4] => 3
[5] => 6
[6] => 8
[7] => 2
)
Voici la fréquence de chaque élément du tableau :
Array
(
[1] => 1
[8] => 3
[2] => 2
[3] => 1
[6] => 1
)
Le plus grand élément du tableau est 8 et il apparait 3 fois.
Chaines de caractères :
---------------------
Voici le tableau utilisé :
Array
(
[0] => le
[1] => chat,
[2] => le
[3] => chien
[4] => et
[5] => le
[6] => rat
[7] => sont
[8] => des
[9] => animaux
)
Voici la fréquence de chaque élément du tableau :
Array
(
[le] => 3
[chat,] => 1
[chien] => 1
[et] => 1
[rat] => 1
[sont] => 1
[des] => 1
[animaux] => 1
)
Le plus grand élément du tableau est sont et il apparait 1 fois.
**************************************************/
?>
Calculer le maximum et son nombre d'occurrences en une seule boucle ne présente pas vraiment d'intérêt pour un "petit tableau" (disons quelques centaines ou quelques milliers d'éléments). Par contre, si on dépasse le million d'éléments, c'est non négligeable. Par exemple, si une image comme celle-ci -- 7 Go ! -- doit être traitée pour trouver le maximum d'intensité des pixels (ce qui correspond à l'intensité maximale de la maladie), le parcours de l'image mise dans un tableau dure environ 6 minutes. Avec deux boucles, il faut donc en tout 12 minutes ; avec une seule boucle, la durée d'exécution est plutôt proche de 8 minutes (il y a un "surcout" de temps à cause des tests dans la boucle).
On voudrait implémenter en ligne de commandes la notion de pile où on ne peut ajouter qu'en haut de pile. Pour cela on utilisera un tableau PHP. Voici un exemple de ce qu'on voudrait pouvoir écrire :
$p = creerPile() ; # un simple tableau
montrerPile($p) ; # doit afficher "la pile est vide"
$p = empiler(5,$p) ; # la pile ne contient que 5
$p = empiler(2,$p) ; # la pile contient 5 et, au-dessus, 2
montrerPile($p) ; # affiche 5 (bas de la pile) et 2 (haut de la pile)
list($x,$p) = depiler($p) ; # renvoie 2 dans x et modifie p
echo "on a enlevé $x (du haut) de la pile\n" ;
list($y,$p) = depiler($p) ; # renvoie 5 dans y et modifie p
list($x,$p) = depiler($p) ; # afficher "impossible, la pile est vide" ou renvoyer "erreur" ?
Implémenter les fonctions citées en utilisant seulement return(), array(), count(), l'indexation et unset().
Comment dit-on une pile en anglais ? Et empiler ? Et dépiler ? Y a-t-il des fonctions PHP prévues pour cela ?
Consulter pilev1.php pour un listing numéroté, mais vous pouvez vous contenter de ce qui suit :
<?php
# ----------------------------------
function creerPile() {
return( array() ) ;
} # fin de fonction creerPile
# ----------------------------------
function pileVide($p) {
return( count($p)==0 ) ;
} # fin de fonction pileVide
# ----------------------------------
function empiler($valeur,$pile) {
$pile[ count($pile) ] = $valeur ;
return( $pile ) ;
} # fin de fonction empiler
# ----------------------------------
function depiler($pile) {
$idd = count($pile) - 1 ; # idd : indice du dernier
if ($idd>=0) {
$dep = $pile[ $idd ] ;
unset( $pile[ $idd ] ) ;
} else {
$dep = "" ;
} # finsi
return( array($dep,$pile) ) ;
} # fin de fonction depiler
# ----------------------------------
function montrerPile($pile) {
$nbe = count($pile) ;
if (pileVide($pile)) {
echo "la pile est vide.\n" ;
} else {
echo "Contenu de la pile :\n" ;
for ($ide=$nbe-1;$ide>=0;$ide--) {
echo " valeur numéro ".sprintf("%2d",$ide)." : ".sprintf("%4d",$pile[$ide]) ;
if ($ide==$nbe-1) { echo " (haut de la pile)" ; } ;
if ($ide==0) { echo " (bas de la pile)" ; } ;
echo "\n" ;
} ; # fin pour ide
} ; # finsi
} # fin de fonction montrerPile
# ----------------------------------
$p = creerPile() ; # un simple tableau
montrerPile($p) ; # doit afficher "la pile est vide"
$p = empiler(5,$p) ; # la pile ne contient que 5
$p = empiler(2,$p) ; # la pile contient 5 et, au-dessus, 2
montrerPile($p) ; # voir plus bas
list($x,$p) = depiler($p) ; # renvoie 2
echo "on a enlevé $x (du haut) de la pile\n" ;
list($x,$p) = depiler($p) ; # renvoie 5
list($x,$p) = depiler($p) ; # afficher "impossible, la pile est vide" ou renvoyer "erreur" ?
/***************************************
Affichage :
la pile est vide.
Contenu de la pile :
valeur numéro 1 : 2 (haut de la pile)
valeur numéro 0 : 5 (bas de la pile)
on a enlevé 2 (du haut) de la pile
***************************************/
?>
Dans le contexte informatique, une pile se dit stack en anglais, empiler to stack, dépiler ou désempiler to unstack. PHP dispose des fonctions array_push et array_pop ce qui fait qu'on n'a pas besoin d'inventer de fonction pour résoudre le problème, comme le montre le programme ci-dessous :
<?php
$p = array() ; # un simple tableau
print_r($p) ; # affichage d'un tableau vide
array_push($p,5) ; # la pile ne contient que 5
array_push($p,"2") ; # la pile contient 5 et, au-dessus, 2
print_r($p) ; # affichage du tableau
$x = array_pop($p) ; # renvoie 2
echo "on a enlevé $x de la pile\n" ;
$x = array_pop($p) ; # renvoie 5
echo "on a enlevé $x de la pile\n" ;
$x = array_pop($p) ; # renvoie chaine vide
echo "on a enlevé $x de la pile\n" ;
print_r($p) ; # affichage du tableau
################################################################
#
# Affichage :
#
# Array
# (
# )
# Array
# (
# [0] => 5
# [1] => 2
# )
# on a enlevé 2 de la pile
# on a enlevé 5 de la pile
# on a enlevé de la pile
# Array
# (
# )
#
?>
On notera au passage le comportement de array_pop lorsque la pile est vide.
Contrairement à ce qu'on croit dans les «petites classes», un polynome n'est pas une fonction de x, mais un "objet mathématique" défini par une liste de coefficients. Par exemple la liste
correspond à x3 -2 x + 6 avec les puissances décroissantes, et à 1 - 2 x2 + 6 x3 avec les puissances croissantes.
Ecrire un programme PHP qui lit une telle liste et qui affiche le polynome comme ci-dessus.
Pour les plus courageuses et les plus courageux, implémenter la saisie d'un deuxième polynome, puis calculer et afficher leur somme, leur produit, leur polynome équivalent à leur fonction primitive et celui de leur fonction dérivée.
Retour à la page principale de
(gH)