Les structures de contrôle - partie 3

Écrit par Jean-Michel CHRISOSTOME. Publié dans Blog

Dans cette troisième partie consacrée aux structures de contrôle nous allons étudier certains types de boucles particulièrement adaptées aux tableaux (for, foreach), la structure de contrôle switch qui permet d'écrire des ensembles de conditions plus simplement qu'avec la structure if.

Les boucles for

La boucle for permet de faire plusieurs choses. Premièrement, elle permet d'attribuer une valeur de départ à une variable. Ensuite elle applique une condition, par exemple tant que la variable initialisée est inférieur à une valeur maximale fixée. Et enfin elle permet de réaliser une action, par exemple l'incrémentation (valeur+1) ou la décrémentation (valeur-1) de la variable.

Voici à quoi cela ressemble d'un point de vue logique

POUR (POSITION=VALEUR ; TANT QUE POSITION INFÉRIEUR A VALEUR MAX ; ACTION SUR POSITION) {
	// Instructions à exécuter
	// A chaque passage dans la boucle, POSITION aura une valeur différente selon que l'on choisisse
	// de l'incrémenter ou décrémenter
	// Pour sortir prématurément d'une boucle
	break ;
}

Dans nos exemples ci-dessous, nous utiliserons la variable position que nous allons initialiser à 0 pour traiter les 8 valeurs contenues dans nos tableaux. Ainsi la valeur maximale de la variable position sera 7 (de 0 à 7, nous avons bien 8 valeurs).

Les tableaux de données utilisés seront les suivants :

PERSONNES
0 Marie
1 Marc
2 Antoine
3 Jean
4 Eric
5 Simone
6 Pierre
7 Martine
VILLES
0 Lyon
1 Grenoble
2 Paris
3 Beauvais
4 Bordeaux
5 Valence
6 Nantes
7 Auxerre

Création d'une boucle for en C

 
#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
        /* Définition des variables */
        int position;
        int max=8;
        /* Définition du tableau personnes */
        char personnes[8][16]={
                "Marie", "Marc", "Antoine", "Jean", "Eric", "Simone",
                "Pierre", "Martine"
        };
        /* Définition du tableau villes */
        char villes[8][16]={
                "Lyon", "Grenoble", "Paris", "Beauvais", "Bordeaux",
                "Valence", "Nantes", "Auxerre"
        };
 
        /* Traitement des tableaux avec une boucle for */
        for (position=0; position < max; position++) {
                printf("%s travaille à %s\n", personnes[position], villes[position]);
        }
        return EXIT_SUCCESS;
}
 

Une fois compilé et exécuté, le code ci-dessus affichera ceci :

Marie travaille à Lyon
Marc travaille à Grenoble
Antoine travaille à Paris
Jean travaille à Beauvais
Eric travaille à Bordeaux
Simone travaille à Valence
Pierre travaille à Nantes
Martine travaille à Auxerre

Nous constatons que à la valeur 0 du tableau personnes on trouve "Marie", dans le tableau villes à la même position nous trouvons "Lyon", le résultat avec position à 0 affiche donc "Marie travaille à Lyon". Et on recommence ce même cycle jusqu'à 7 qui correspond à la dernière valeur des deux tableaux.

En Javascript à présent

 
var personnes=[ 'Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine' ] ;
var villes=[ 'Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre' ] ;
var pos ;
// Nombres d'éléments dans le tableau personnes
max=personnes.length ;
// Parcours du tableau avec la boucle for
for (pos=0 ; pos < max ; pos++) {
  console.log(personnes[pos] + ' travaille à ' + villes[pos]) ;
}
 

Le code ci-dessus affichera :

Marie travaille à Lyon
Marc travaille à Grenoble
Antoine travaille à Paris
Jean travaille à Beauvais
Eric travaille à Bordeaux
Simone travaille à Valence
Pierre travaille à Nantes
Martine travaille à Auxerre

En PHP

 
&lt ;?PHP
$personnes=array('Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine') ;
$villes=array('Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre') ;
// Nombre d'éléments dans le tableau personnes
$max=count($personnes) ;
// Parcours du tableau avec la boucle for
for ($pos=0 ; $pos < $max ; $pos++) {
  echo $personnes[$pos]." travaille à ".$villes[$pos]."<br/>" ;
}
 
// Méthode alternative pour parcourir un tableau en PHP
$pos=0 ;
// A chaque passage, $prenom contiendra le nom de l'élément du tableau puis passera au suivant à la fin de la boucle
foreach ($personnes AS $prenom) {
  echo $prenom." travaille à ".$villes[$pos]
  $pos++ ;
}
 
?&gt ;
 

De la même manière le code ci-dessus affichera :

Marie travaille à Lyon
Marc travaille à Grenoble
Antoine travaille à Paris
Jean travaille à Beauvais
Eric travaille à Bordeaux
Simone travaille à Valence
Pierre travaille à Nantes
Martine travaille à Auxerre

En Perl

 
#!/usr/bin/perl
 
use strict;
 
# Définition des tableaux
my @personnes=('Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine');
my @villes=('Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre');
 
my $pos;
 
# Parcours des tableaux
for ($pos=0; $pos < scalar(@personnes); $pos++) {
        print $personnes[$pos]." travaille à ".$villes[$pos]."\n";
}
 
# Méthode alternative pour un tableau en Perl
$pos=0;
foreach (@personnes) {
        print $_." travaille à ".$villes[$pos]."\n";
        $pos++;
}
 

Le code ci-dessus affichera :

Marie travaille à Lyon
Marc travaille à Grenoble
Antoine travaille à Paris
Jean travaille à Beauvais
Eric travaille à Bordeaux
Simone travaille à Valence
Pierre travaille à Nantes
Martine travaille à Auxerre

En anglais, switch signifie commutateur et c'est exactement le rôle de cette structure de contrôle. Elle permet d’exécuter des instructions dans des cas bien spécifiques que ce soit pour un ou plusieurs cas de figures différents, mais elle offre également la possibilité de définir des instructions à exécuter pour tous les cas de figure non traités.

Voici la représentation logique de cette structure

SWITCH ($valeur) {
	CAS '1' :
		// Instructions à exécuter lorsque $valeur est égal à 1
		// Sortie de la structure
		BREAK
	CAS '2' :
	CAS '3' :
	CAS '5' :
		// Instructions à exécuter lorsque $valeur est égal à 2, 3 ou 5
		// Sortie de la structure
		BREAK
	CAS '6' :
		// Instructions à exécuter si $valeur est égal à 6
		// On ne sort pas de la structure, donc on traite aussi le cas de figure suivant
	CASE '9' :
		// Instructions à exécuter si $valeur est égal à 6 ou 9
		// Sortie de la structure
		BREAK
	DEFAULT :
		// Instructions à exécuter pour tous les cas de figure qui n'ont pas été traités précédemment
}

Ce type de structure complexe peut être réalisée entièrement avec des structures de contrôle if else if et else, mais elle sera alors moins évidente à écrire et à lire. La structure switch est une facilité visuelle pour les développeurs dans le sens où elle permet de traiter de multiples cas de figures dans une seule structure et de manière assez évidente.

Voici un exemple en C

 
#define <stdio.h>
#define <stdlib.h>
 
#define PERSIL 0 
#define SALADE 1
#define TOMATE 2
#define CAROTTE 3
#define POIVRON 4
 
/* Définition de la fonction de traitement */
void couleur(int legume) {
  switch (legume) {
      case PERSIL :
      case SALADE :
        printf("Couleur : verte\n") ;
        break ;
      case TOMATE :
      case POIVRON :
        printf("Couleur : rouge\n") ;
        break ;
      default :
        printf("Cas de figure non traité\n") ;
    }
  }
}
 
int main(void) {
  couleur(PERSIL) ; /* Affichera : Couleur : verte */
  couleur(POIVRON) ; /* Affichera : Couleur : rouge */
  couleur(CAROTTE) ; /* Affichera : Cas de figure non traité */
 
}
 

La même structure en Javascript

 
// Définition de la fonction
function couleur(legume) {
  var ret ;
 
  switch (legume) {
    case 'persil' :
    case 'salade' :
      ret='vert' ;
      break ;
    case 'tomate' :
    case 'poivron' :
      ret='rouge' ;
      break ;
    default :
      ret='Cas de figure non traité' ;
  }
  // Retourne le résultat à la fonction appelante
  return ret ;
}
 
// Utilisation de la fonction
console.log(couleur('persil')) ;  // Affichera : vert
console.log(couleur('poivron')) ;  // Affichera : rouge
console.log(couleur('banane')) ;  // Affichera : Cas de figure non traité
 

En PHP

 
<?PHP
 
// Définition de la fonction
function couleur($legume) {
  $ret='' ;
  switch ($legume) {
    case 'salade' :
    case 'persil' :
      $ret='vert' ;
      break ;
    case 'tomate' :
    case 'poivron' :
      $ret='rouge' ;
      break ;
    default :
      $ret='Cas de figure non traité' ;
  }
}
 
// Utilisation de la fonction
echo "Le persil c'est : ".couleur('persil') ;  // Affichera : Le persil c'est : vert
echo "La tomate c'est : ".couleur('tomate') ;  // Affichera : La tomate c'est : rouge
echo "La banane c'est : ".couleur('banane') ;  // Affichera : La banane c'est : Cas de figure non traité
 
?&gt ;
 

En perl

En Perl les choses changent un peu. En effet, la structure de contrôle switch n'existe pas nativement en Perl et si on souhaite malgré tout pouvoir traiter des conditions de la même manière, il faut faire appel à un module spécifique qui devra être chargé au démarrage du script. Ce module se nomme 'Switch.pm'.

 
#!/usr/bin/perl
 
use strict;
# Chargement du module Switch.pm
use Switch;
 
# Définition de la fonction
sub couleur {
        my ($legume)=@_;
        my $ret;
 
        # Utilisation de la structure émulée
        switch ($legume) {
                # Syntaxe pour exécuter les mêmes instructions
                # pour 2 cas de figures différents
                case ['salade', 'persil'] {
                        $ret='vert';
                }
                # Syntaxe pour exécuter les mêmes instructions
                # pour 2 cas de figures différents
                case ['tomate', 'poivron'] {
                        $ret='rouge';
                }
                # Équivalent du mot clé default pour traiter tous les cas de figure qui n'ont pas été 
                # traité par les instructions au dessus
                else {
                        $ret='Cas de figure non traité';
                }
        }
        return $ret;
}
 
print "Une salade c'est: ".couleur('salade')."\n";  # Affichera : Une salade c'est : vert
print "Un poivron c'est: ".couleur('poivron')."\n";  # Affichera : Un poivron c'est : rouge
print "Une banane c'est: ".couleur('banane')."\n";  # Affichera : Une banane c'est : Cas de figure non traité
 

Voilà, c'est la fin de cette série d'articles consacrés au bases de la programmation. Après avoir lu et appréhendé ces différents articles (qui je le répète ne sont pas exhaustifs), vous ne serez certainement pas des développeurs de pointe, mais vous aurez suffisamment d'éléments pour commencer à apprendre ou renoncer si cela ne vous parle pas du tout.

Si vous souhaitez des compléments d'informations ou voir un sujet particulier être traité à la suite de ces articles, vous pouvez en faire la demande par mail ou via les commentaires.