30
Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Embed Size (px)

Citation preview

Page 1: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Introduction à la programmation I

Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Page 2: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Les Fonctions

Page 3: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Définir une fonction Sections de code indépendantes que l’on peut appeler à n’importe quel moment et dans n’importe

quel ordre. Bout de code que l’on peut insérer comme s’il s’agissait de petit programme indépendant Moins de code à écrire, moins à vérifier Mieux penser la structure du programme

Définir une fonction :

lui donner un nom : mot clé « function » suivi du nom que l’on veut donner à la fonction les paramètres sont listés entre parenthèses

function nomfonction (paramètres){Le code de la fonction est inséré ici….}

Page 4: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Définir une fonction (suite) La fonction peut contenir autant de ligne de code que l’on souhaite

Pour renvoyer une valeur, placer « return » sur la dernière ligne de la fonction montre que l’on a fini et que la fonction s’arrête là.

Pour afficher la valeur renvoyée par la fonction, on utilise l’instruction « echo ». « Return » n’affiche pas la valeur, mais transmet le résultat à la fonction

Une fonction peut être appelée aussi souvent qu’on le souhaite.

Ex : $Prix = 1600 ;echo (reduction($Prix)) ;

si on veut donner plusieurs paramètres à une fonction, les séparer par une virgule

Ex :function reduction ($Prix, $Reduction){$Prix = $Prix – $Reduction ;return $Prix ; }

dans ce cas, pour appeler la fonction, on doit faire appel à deux valeurs

Cf. Ex1

Page 5: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Ordre des éléments au sein d’une fonction La position de la définition de la fonction, de son exécution et de son appel peut varier.

Cependant, la fonction n’est pas utilisée tant qu’elle n’est pas appelée dans la dernière ligne avec « echo ».

Ex:

<?php$Salaire=1600; L’exécution commence ici$TauxCharges=25;echo (charges($Salaire, $TauxCharges)); La fonction est appelée ici

function charges($Salaire, $TauxCharges) La fonction est définie ici{

$Salaire = $Salaire – (($Salaire/100)*$TauxCharges);return;

}?>------------------------------------------------------------------------------------------------------------------<?phpfunction charges($Salaire, $TauxCharges) La fonction est définie ici{

$Salaire = $Salaire – (($Salaire/100)*$TauxCharges);return;

}$Salaire=1600; L’exécution commence ici$TauxCharges=25;echo (charges($Salaire, $TauxCharges)); La fonction est appelée ici?>

Page 6: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Noms des variablesOn est pas obligé de donner aux variables hors de la fonction le même nom que celui des paramètres.

Ex : $Blabla = 1600 ;$Lalala = 500 ;echo (reduction($blabla, $Lalala)function reduction ($Prix, $Reduction){

$Prix = $Prix – $Reduction ;return $Prix ;

}

Dans ce cas-ci, la variable utilisée comme paramètre $Prix prend la valeur de $Blabla et la variable$Reduction, celle de la variable $Lalala.

Faire des essais :- créer une fonction en utilisant les éléments décrits plus haut- modifier la position des éléments

Page 7: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Autres applications ou méthodesHormis la méthode de transmission de valeur qui vient de vous être présentée, il existe également uneméthode qui permet de passer les arguments de fonctions « par référence », c’est-à-dire qui implique que la valeur passée soit modifiée à l’intérieur de la fonction.Mais nous ne la verrons pas ici.

Page 8: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Structures de contrôle

Page 9: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

IntroductionLes structures de contrôle (boucles) permettent d’effectuer des tâches répétitives.Cependant, ce ne sont pas des structures conditionnelles dans la mesure où elles peuvent êtreexécutées indéfiniment.

Pour résumer en deux mots le fonctionnement d’une boucle, nous dirons qu’elle fonctionne ainsi:- Une condition est testée et le code de la boucle est exécuté, si la condition est satisfaite. - Ensuite, la condition est retestée et si elle est toujours « true », elle est re-exécutée. - Et ainsi de suite.

Chaque passage de la boucle est appelée une itération.

Il existe plusieurs types de boucles, chacun adapté à une situation différente. Nous allons les passer en revue ici: La boucle while La boucle do while La boucle for La boucle foreach (que nous verrons dans le chapitre des tableaux)

Page 10: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

La boucle whileLa boucle while est la plus simple des boucles.

Elle présente des ressemblances avec l’instruction « if »La boucle while vérifie le résultat d’une condition. Selon que la condition est « true » ou « false », la portion de code placée entre accolades (après l’instruction conditionnelle) est exécutée.

while (la condition est « true »){Exécuter le contenu des accolades}

Une fois le contenu entre accolades exécuté, la condition située juste au dessus est revérifiée.

Dans le cas où c’est à nouveau « true », le contenu de l’accolade est ré-exécuté.

Dans le cas où la condition est « false », le code entre accolades est ignoré et l’on passe directement à la première ligne de code qui suit les accolades.

Page 11: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

La boucle do whileLa boucle do while est environ similaire à la boucle « while » si ce n’est que l’instruction conditionnelleest testée à la fin de la boucle et non au début.

Cela implique donc que le contenu des accolades sera appliqué au moins une fois, même si la condition est « false »

Ex :do{Exécuter le contenu des accolades}while (la condition est « true ») ; retourner et recommencer

oudo{Exécuter le contenu des accolades}while (la condition est « false ») ; sortir de la boucle et passer à la ligne de code suivante

Cf. Exemple des nombres premiers

Cf. Ex verifier_do_while.php

Page 12: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

La boucle forLa boucle for est idéale pour répéter une section de code un certain nombre de fois.Elle offre la possibilité de spécifier le nombre de fois que l’on souhaite parcourir la boucle.

Cette boucle est plus complexe que la boucle « while »

Ex :for (définir le compteur de boucles ; tester le compteur de boucles ; ajouter ou soustraire au compteur){exécuter le contenu des accolades}

Le concept de compteur de boucles est introduit ici.

Ex :for ($compteur=1 ; $compteur<=10 ; $compteur++){echo « Mon nom est Bob ! » ;}

La boucle for va :

- compter combien de fois la boucle a été parcourue = itérations - puis finir la boucle une fois le nombre défini dépassé.- s’assurer que la valeur du compteur se modifie à chaque itération, d’où l’apparition de « ++ » qui représente

l’incrémentation du compteur

Faire des essais

Cf. Ex for.php

Page 13: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Structures de données

Page 14: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

IntroductionLes tableaux sont constitués de variables d’indice qui, surtout si elles sont associées à une boucle, peuvent être très efficace.

Un tableau est composé d’une série de valeurs qui ont toutes le même nom

Chacune de ces valeurs ayant un indice différent

Chaque constituant d’un tableau est appelé « élément »

On peut créer des tableaux de la même façon qu’on crée des variables, tant que l’on oublie pas de mettre des crochets pour signaler l’indice.

Ex :$ PaysEurope[1] = "France"  ;$ PaysEurope[2] = "Espagne"  ;

L’ordre des n° n’est pas important et l’on peut même utiliser des caractères

Ex : $ PaysEurope["F"] = "France"  ;$ PaysEurope["E"] = "Espagne"  ;$ PaysEurope["Ch"] = "Suisse"  ;

On peut également attribuer des valeurs mélangées aux indices des tableaux, à savoir valeur numériques ou caractères.

Page 15: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

InitialisationL’initialisation est la définition des valeurs initiales des variables des tableaux

$Pays[] = « France »$Pays[] = « Suisse »

Sans les crochets, la valeur de la première variable serait automatiquement remplacée par la seconde dans la suite du programme.

L’absence de valeur d’indice fait que PHP va décider lui-même de stocker les valeurs dans $Pays[0] et $Pays[1].

Pas besoin de prédéfinir les types de données du tableau en indiquant s’il s’agit de données textuelles ou numériques.

Pas besoin de spécifier la taille du tableau avant de le créer

Page 16: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

La construction « array »$Pays = array (" France ", " Espagne ", " Suisse ") ;

PHP génère automatiquement les valeurs d’indice. Elles commencent à zéro. Les nouvelles valeurs sont insérées dans un élément vide avec la valeur d’indice la plus petite.

Ex :

echo $Pays[2] ; afficherait   " Suisse "

Ex: $PaysEurope = array (1 => " France ", " Espagne ", " Suisse ", "Hollande", "Belgique", "Portugal", "Angleterre", "Danemark", "Allemagne", "Italie") ;

Cf. Ex pays.php

Page 17: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Les itérations dans un tableauLes boucles sont utilisées dans les tableaux, afin d’éviter un travail laborieux qui consisterait à récupérer individuellement chaque élément du tableau afin de l’afficher par exemple.

La boucle for :

Exemple afficher tous les pays recensés dans notre tableau :

for ($compteur=1 ; $compteur<11 ; $compteur++) {echo " <BR>$Pays[$compteur] "  ;}

Commencer à 1 et aller jusqu’à 10, en augmentant à chaque fois le compteur de 1. Cela donnerait :

echo " <BR>$Pays[1]  "  ;echo " <BR>$Pays[2]  "  ;echo " <BR>$Pays[3]  "  ;echo " <BR>$Pays[4]  "  ;echo " <BR>$Pays[5]  "  ;echo " <BR>$Pays[6]  "  ;echo " <BR>$Pays[7]  "  ;echo " <BR>$Pays[8]  "  ;echo " <BR>$Pays[9]  "  ;echo " <BR>$Pays[10]  "  ;

Cf. Ex pays.php

Page 18: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Les itérations dans un tableau (suite)Les boucles while ou do while :

Ces boucles nous obligent à définir un compteur nous-mêmes

$compteur=1;while ($compteur<11) {

echo « <BR>$Pays[$compteur] » ;$compteur=$compteur+1 ;

}

Le résultat sera semblable à l’exemple précédent.

Cf. Ex pays_while.php

Page 19: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

La boucle foreachCette boucle est utilisée lorsque nous avons un tableau avec un nombre d’éléments inconnu.Elle effectue des itérations jusqu’à la fin du tableau

Pour chaque élément du tableau, on effectue une itération à travers la boucle foreach.

foreach ($PaysEurope As $IndicePays => $Pays){

echo "<BR>$IndicePays - $Pays ";}

$PaysEurope = nom du tableau$IndicePays = nom de variables que l’on crée nous-mêmes qui contient les valeurs d’indice.$Pays = nom de variables que l’on crée nous-mêmes qui contient l’élément correspondant

L’avantage de cette boucle est que nous n’avons pas besoin d’effectuer le décompte du nombre d’éléments du tableau, puisqu’elle la découvre toute seule.

En ajoutant un nouvel élément qui ne suit pas les élément déjà présents dans le tableau, la boucle va le prendre en compte et l’afficher, sans avoir à vérifier les éléments vides présents entre.

Faire des essais:- Créer un tableau du même genre de « Pays » et tester les différentes boucles pour l’afficher

Cf. Ex foreach.php

Page 20: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Les tableaux non séquentielsLes tableaux non-séquentiels sont des tableaux qui ne sont pas remplis dans l’ordre croissant de leur indice, mais dans un ordre aléatoire.

Ex:$Taille[1234]= " Enorme ";$Taille[1]= " Minuscule ";$Taille[654]= " Très grand ";

Le problème avec une vérification séquentielle de ce genre de tableau est qu’il risque de ne contenir quetrès peu de valeur en réalité et comporter des espaces vide

Fonctions current() et key()

Ces fonctions sont des pointeurs pour conserver la trace d’un élément donné lors des déplacements dans un tableau.La fonction current() permet de voir quel élément est en train d’être utilisé par PHPLa fonction key() permet de rechercher la valeur d’indice affectée à l’élément key est synonyme «d’ indice » ici.

Ex :$ValeurIndiceCourant = key($Realisateur) ; renvoie la valeur d’indice du 1er élément placé dans le tableauecho ($ValeurIndiceCourant) ;

$ContenuCourant = current($Realisateur) ;echo ($ContenuCourant) ;

renvoie la valeur du premier élément.

Page 21: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Les tableaux non-séquentiels (suite)Fonctions next() et prev()

Ces deux fonctions permettent de naviguer au sein des tableaux, ainsi que de trouver la valeur d’un nouvel élément ajouté au tableau.

Ex :$Realisateur[4]= "Orson Welles";$Realisateur[1]= "Carol Reed";$Realisateur[93]= "Fritz Lang";$Realisateur[24]= "Jacques Tourneur";$Realisateur[]= "Alfred Hitchcock";

next($Realisateur)

$ValeurIndiceCourant = key($Realisateur) ; echo ($ValeurIndiceCourant) ;

La valeur affichée est 1 et current() renvoie le nom « Carol Reed »

Pour résumer:

Pour naviguer dans le tableau, nous utilisons les fonctions next() et prev() Pour afficher la position courante, les fonctions current() et key()

Cf. Ex next_prev.php

Page 22: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Les tableaux non-séquentiels (suite)Fonctions list() et each()

Les fonctions list() et each() permettent de renvoyer uniquement les éléments du tableau contenant des données, au lieu de passer des données vides qui peuvent être nombreuses.Nous utiliserons la boucle while peut effectuer cela

while (list(ValeurIndice,ContenuElement) = each(NomTableau))

ValeurIndice = à l’indice de l’élémentContenuElement = au contenu de l’élément

Exemple

while (list(ValeurIndiceElement,ContenuElement) = each($Realisateur)){ echo "<BR>$ValeurIndiceElement - $ContenuElement ";}

La fonction list() renvoie d’abord la valeur de l’indice, puis le contenu de l’élément.

Cf. Ex list_each.php

Page 23: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Array functionsPour découvrir les array fonctions : cf. http://tecfa.unige.ch/guides/php/php5_fr/ref.array.html

Trier les tableaux

Il y a plusieurs fonctions de tri de tableau. Passons-en en revue cinq ici.

Fonction sort()

Fonction qui trie les éléments d’un tableau par ordre alphabétique :

sort(NomTableau)

Fonction asort()

Fonction qui trie les éléments d’un tableau par ordre alphabétique, mais en conservant les indices de chaîne :

asort(NomTableau)

Fonction rsort et arsort

Tri inversé. Idem que les deux précédentes, mais par ordre décroissant.

Fonction ksort

Trie le contenu d’un tableau associatif en fonction des indices de chaîne. Le principe est le même que pour les autres indices de tri.

Page 24: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Exemples d’array functions (suite) Fonctions array_push() et array_pop()

Permettent d’ajouter ou de supprimer un élément à un tableau :Ex :

a)array_push($Pays,   "Italie"  , "Suède") ; ajoute ces deux pays

b)$Pays [2] = "Suisse"  ;$Pays [1] = "France" ;$Pays [8] = "Espagne"  ;$Pays [10] = "Angleterre" ;array_pop($Pays) ;

supprime le dernier élément ajouté au tableau (ici « Angleterre »). Mais cette fonction ne supprime qu’un élément à la fois.

Fonctions Implode et Explode

Fonctions qui permettent de stocker tout le contenu d’un tableau en tant que chaîne ou l’inverse.Implode concatène les éléments d’un tableau et crée une chaîne séparée par un délimiteur.

$NomChaine = implode ("délimiteur", $NomTableau) ;

Ex :$Pays_separes = implode ("-", $Pays) ;echo ($Pays_separes) ;

Cela va donner : Suisse-France-etc

Explode produit l’inverse, c’est-à-dire qu’elle sépare les éléments de la chaîne.

Page 25: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Les tableaux multidimensionnelsNous n’en parlerons pas ici.

Les tableaux multidimentionnels sont des tableaux de tableau.

Ex: NomTableau = array (indice => array (Contenu du tableau))Ex : annuaire téléphoniqueL’indice serait « Jessica Claude » et le contenu (« 10 ch. Rieu », « 022/----- »)

Page 26: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

La portée des variables

Les variables locales et globales

Page 27: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Variables locales vs globalesLes variables à l’intérieur d’une fonction ont une portée locale. Elle n’existent qu’à l’intérieur mêmed’une fonction et donc uniquement pour la durée d’appel de cette fonction.

Les variables dont la durée de vie correspond à la durée de vie d’une page ont une portée globale.

Illustration:

<php?$MessageBienvenue = « Hello world  »; VARIABLE GLOBALEfunction traduire_message ( $MessageFrancais){

$MessageFrancais = « Bonjour à tout le monde »; VARIABLE LOCALEreturn $MessageFrancais;

}traduire_message ();echo $MessageBienvenue;echo $MessageFrancais;?>

Ce morceau de code ne renvoie pas la valeur de $MessageFrancais, puisque la durée de la variable locale se termine quand la fonction renvoie une valeur. La valeur renvoyée par la fonction n’a donc pas d’effet une fois que la fonction se termine

Solution pour afficher

Cf. Ex variables_locales_globale.php

Page 28: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Variables locales vs globales (suite)Utiliser les variables globales à l’intérieur des fonctions

L’exemple de $GLOBAL

<?php$MessageBienvenue = " Hello world "; function traduire_message ( $MessageFrancais){

echo $GLOBAL [" MessageBienvenue "];$MessageFrancais = " Bonjour à tout le monde ";return $MessageFrancais;

}traduire_message ();echo $MessageBienvenue;echo (traduire_message($MessageFrancais));?>

Page 29: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

L’exercice

Page 30: Introduction à la programmation I Fonctions Structures de contrôle Structures de données (arrays simples et indexés) Variables locales et globales

Consignes

Reprenez votre exercice STAF 14 de l’année passée et reproduisez-le à l’aide d’array, deboucles et de fonctions, comme nous venons de le voir.

L’idée est de ne plus utiliser une structure envahie de « if », « then  ».