Imprimer

Les structures de contrôle - partie 1

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

Introduction

Les structures de contrôle permettent comme leur nom l'indique de contrôler des conditions durant l’exécution de votre code. Cela peut varier de la valeur d'une variable en passant par le retour d'une fonction. Les structures de contrôle permettent également de traiter les éléments d'un tableau ou des listes de valeurs déterminées (par exemple : de 0 à 31).

Sans ces structures logiques, la programmation serait un véritable enfer où le choix des portion de code à exécuter reviendrai à la décision d'un humain et où il faudrait réécrire x fois la même portion de code pour traiter les x valeurs d'un tableau.

Dans les structures de contrôle et pour les langages que nous allons étudier, la condition à tester est un booléen, soit une valeur comprise entre 0 (FAUX) et 1 (VRAI). Une condition sera toujours déclenchée par un état VRAI. Si on souhaite faire le contraire, c'est à dire déclencher lorsque la vérification est fausse, il faut faire précéder son expression par un point d'exclamation !. Enfin, les conditions doivent être entourées par des parenthèses.

Les opérateurs de contrôle

Voici une liste non exhaustive des principaux symboles utilisés pour tester des conditions.

Opérateur Signification
==égal
!=différent
>strictement supérieur
<strictement inférieur
>=supérieur ou égal
<=inférieur ou égal

Voici quelques exemples de conditions et leur retour booléen:

  • (12==13) FAUX
  • (13==13) VRAI
  • (12==(12+1)) FAUX
  • (12==(13-1)) VRAI
  • (13 > 12) VRAI
  • (12 < 13) VRAI
  • (12 > 13) FAUX
  • (13 >= 13) VRAI
  • (12!=13) VRAI

SI ou SINON et SINON-SI

La première structure de contrôle et aussi la plus simple consiste à vérifier une condition et à exécuter des instructions en fonction qu'elle soit vrai ou fausse. Il est également possible de tester plusieurs conditions dans une structure SI avec SINON-SI.

Voici comment se présente cette structure

SI (CONDITION VRAI)
	ALORS
	// Instructions à exécuter si la condition est vrai
SINON
	// Instructions à exécuter si la condition est fausse

Simple n'est-ce pas? Si la condition est vrai, on exécute les instructions définies en haut, sinon les autres. On peut même ne pas spécifier d'instruction pour SINON si ce n'est pas utile.

Pour illustrer l'exemple ci-dessous avec une valeur

SI (12 < 13)
	ALORS
	AFFICHER '12 est inférieur à 13'

Ici pas de sinon, 12 sera toujours inférieur à 13 et ce n'est pas la crise ni les attaques terroristes qui pourront y changer quelque chose...

Voici comment s'utilise cette structure en C

 
#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int a=13;
  int b=12;
 
  /* SI */
  if (a > b) {
    printf("La valeur de a est supérieure à la valeur de b\n") ;
  }
  /* SINON */
  else {
    printf("La valeur de a est inférieure à la valeur de b\n") ;
  }
  /* Affichera :  La valeur de a est supérieure à la valeur de b */
 
  a=12 ; b=13 :
  /* SI */
  if (a > b) {
    printf("La valeur de a est supérieure à la valeur de b\n") ;
  }
  /* SINON */
  else {
    printf("La valeur de a est inférieure à la valeur de b\n") ;
  }
  /* Affichera :  La valeur de a est inférieure à la valeur de b */
}
 

en Perl à présent

 
# !/usr/bin/perl
 
use strict ;
 
my $a=13 ;
my $b=12 ;
 
# SI
if ($a > $b) {
  # Instructions
  print "La valeur de a est supérieure à la valeur de b\n" ;
}
# SINON
else {
  # Instructions
  print "La valeur de a est inférieure à la valeur de b\n" ;
}
# Affichera :  La valeur de a est supérieure à la valeur de b
 
$a=12 ; $b=13 ;
# SI
if ($a > $b) {
  # Instructions
  print "La valeur de a est supérieure à la valeur de b\n" ;
}
# SINON
else {
  # Instructions
  print "La valeur de a est inférieure à la valeur de b\n" ;
}
# Affichera :  La valeur de a est inférieure à la valeur de b
 

Au tour de PHP

 
<?php
 
$a=13 ; $b=12 ;
// SI
if ($a > $b) {
  // Instructions
  echo "La valeur de a est supérieure à la valeur de b<br/>" ;
}
// SINON
else {
  // Instructions
  echo "La valeur de a est inférieure à la valeur de b<br/>" ;
}
// Affichera :  La valeur de a est supérieure à la valeur de b
 
$a=12 ; $b=13 ;
// SI
if ($a > $b) {
  // Instructions
  echo "La valeur de a est supérieure à la valeur de b<br/>" ;
}
// SINON
else {
  // Instructions
  echo "La valeur de a est inférieure à la valeur de b<br/>" ;
}
// Affichera :  La valeur de a est inférieure à la valeur de b
?>
 

Et finalement en Javascript

 
var a=13 ;
var b=12 ;
 
// SI
if (a > b) {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// SINON
else {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// Affichera :  La valeur de a est supérieure à la valeur de b
 
a=12 ; b=13 ;
// SI
if (a > b) {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// SINON
else {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// Affichera :  La valeur de a est inférieure à la valeur de b
 

La structure de contrôle SI-SINON existe dans la majorité des langages de programmation et est indispensable pour prendre des décisions dans un programme. On ne peut s'en passer et vous verrez par la suite que ceraines structures de contrôles plus complexes reposent sur celle-ci.

TANT QUE

Cette structure de contrôle fait partie des boucles. Parce que, tant que la condition est vrai, nous allons exécuter les mêmes instructions. Attention toutefois à réaliser les bons contrôles pour sortir de la boucle sans quoi votre programme peut boucler à l'infini (jusqu'à interruption manuelle).

Elle se présente comme suit

TANT-QUE (CONDITION VRAI) {
	// Instructions à exécuter à chaque passage dans la boucle
}

Voici ce que ça donne en C

 
#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int position=12 ;
  int max=24 ;
 
  /* Tant que position est inférieur à max */
  while (position < max) {
    /* Instructions à exécuter tant que position est inférieur à max */
    printf("Valeur de position : %d\n", position) ; /* Affiche la valeur de position */
    position++ /* On augmente position de 1 à chaque passage */
  }
  /* La boucle affichera les valeurs de 12 à 23 puisque 24 étant == à max on sort de la boucle avant de l'afficher */
}
 

En perl

 
# !/usr/bin/perl
 
use strict ;
 
my $pos=12 ;
my $max=24 ;
 
# Tant que pos est inférieur à max
while ($pos <= $max) {
  # Affiche la valeur de pos à chaque passage
  print "Valeur de pos : $pos\n" ;
  # Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
# La boucle affichera les valeurs de 12 à 24 puisque nous avons utilisé l'opérateur <= (inférieur ou égal)
 

En PHP

 
<?php
$pos=12 ; $max=24 ;
// Tant que pos est inférieur à max
while ($pos < $max) {
  // Affiche la valeur de pos à chaque passage
  echo "Valeur de pos : $pos<br/>" ;
  // Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
/* La boucle affichera les valeurs de 12 à 23 puisque 24 étant == à max on sort de la boucle avant de l'afficher */
?>
 

En Javascript

 
var pos=12 ;
var max=24 ;
 
while (pos <= max) {
  // Affiche la valeur de pos à chaque passage (dans la console)
  console.log('Valeur de pos : ' + pos) ;
  // Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
/* La boucle affichera les valeurs de 12 à 24 puisque nous avons utilisé l'opérateur <= (inférieur ou égal) */
 

Dans les articles à venir nous allons étudier d'autres structures de contrôle plus complexes ou plus spécifiques à certains langages. Ces structures sont là pour faciliter le travail du développeur, aider à prendre des décision dans un programme mais aussi à parcourir des tableaux de donnée ou encore à traiter des ensembles de cas de figures spécifiques.