# Programmation/Contrôles

* Historique
* Abstraction

## Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

## Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

## Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

## Annexes

* Structure et style
* Règles de programmation
* Langages
* Historique
* Abstraction

## Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

## Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

## Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

## Annexes

* Structure et style
* Règles de programmation
* Langages
[ Modifier le sommaire ]
Généralement, le code source d'un programme décrit l'exécution en une suite d'instructions. Par défaut, ces instructions sont exécutées dans l'ordre séquentiel, suivant l'ordre d'écriture du code source (de gauche à droite, de haut en bas).
Exemple :
L'ordre d'exécution est alors le suivant :
* A ← 3 On affecte la valeur 3 à la variable A.
* B ← A + 1 On affecte la valeur 4 (A+1 = 3+1) à la variable B.
Il peut être nécessaire de changer cet ordre pour diverses raisons :
* N'exécuter certaines instructions que si une condition est remplie (instructions conditionnelles),
* Répéter en boucle le même traitement plusieurs fois (boucle).
Le changement d'ordre d'exécution est effectué par les instructions de contrôle d'exécution.

## Regroupement d'instructions

Les sections qui suivent parle d'une instruction, mais il est possible d'utiliser plusieurs instructions en les regroupant dans un bloc. Ce bloc est alors utilisable là où le terme « une instruction » est employé.
Un bloc est délimité par des caractères spéciaux ou des mots réservés du langage.
Beaucoup de langages de programmation utilisent les accolades pour délimiter un bloc (C, C++, Java, C#, Javascript, PHP, ...) :
D'autres utilisent des mots réservés :
En Pascal, Delphi et Ada :
En Visual Basic, les mots utilisés dépendent de l'instruction :

## Instruction conditionnelle

Une instruction conditionnelle n'est exécutée que si une condition est vraie. Elle peut être conditionnée par l'existence d'un fichier, la valeur d'une variable ou expression, l'absence d'erreur retournée par une fonction, ...
Beaucoup de langage de programmation possède une instruction if (mot anglais signifiant si) pour tester une condition. La syntaxe générale est la suivante :
Une autre syntaxe autorise également l'exécution d'une instruction quand la condition est fausse.
Chacun des mots est à remplacer par celui utilisé par le langage, utilisant souvent leur équivalent anglais (SI → IF, ALORS → THEN, SINON → ELSE, FINSI → ENDIF). Le mot ALORS peut être absent dans certains langages, car implicite.
| En C, C++, Java, C#, Javascript, PHP : if (condition) instruction_si_condition_vraie else instruction_si_condition_fausse | Exemple en Java : if (a < b) System.out.println("A est plus petit que B"); else System.out.println("A égale ou est plus grand que B"); |
En Pascal, Delphi :
En Visual Basic :

## Boucle

Une boucle permet de répéter une instruction un nombre de fois déterminé ou non. La boucle générale exécute l'instruction à répéter tant qu'une condition est vraie. La condition peut être évaluée avant l'instruction ou après. Certains langages autorisent aussi une forme de boucle qui se termine quand une condition devient vraie.
Une itération est une exécution particulière de l'instruction dans une boucle. Voir les sections ci-dessous qui détaillent les types de boucle.

### Boucle conditionnelle

La boucle conditionnelle exécute une instruction (ou bloc d'instructions) tant qu'une condition est vraie ou fausse.

#### Condition testée avant

La boucle « tant que » exécute instruction tant qu'une condition est vraie, c'est-à-dire jusqu'à ce que la condition soit fausse. Tant que la condition est vraie, une nouvelle itération a lieu.
Elle a en général la forme suivante :
La condition est testée avant, ce qui signifie que l'instruction peut ne pas être exécutée si la condition est fausse initialement.
Exemple en Java :
Avec un bloc d'instruction :

#### Condition testée après

La boucle peut avoir également cette forme :
La condition est testée après, ce qui signifie que l'instruction est exécutée au moins une fois même si la condition est fausse initialement.

#### Répéter jusqu'à

Une autre forme de la boucle répète une instruction jusqu'à ce que la condition soit vraie, c'est-à-dire tant que la condition est fausse. Tant que la condition est fausse, une nouvelle itération a lieu.
La forme la plus courante est celle où la condition est testée après l'instruction :
Il existe aussi une forme où la condition est testée avant l'exécution de l'instruction :

### Boucle d'itération d'un ensemble

Ce type de boucle effectue une itération pour chacun des éléments d'un ensemble. Une variable associée prend les différentes valeurs successives des éléments de l'ensemble.

#### Entiers

On trouve cette forme dans les premiers langages de programmation (Fortran, Basic, Pascal). Les langages de programmation plus récents utilisent en général une autre forme de la boucle.
Cet ensemble peut être celui des entiers en spécifiant les bornes minimales et maximales :
Le pas par défaut est de un, certains langages permettent de spécifier un autre pas :
Un pas de -1 permettant de parcourir en sens inverse. D'autres langages supporte un sens automatique de parcours inversé quand la borne min est plus grande que max.

#### Itération par condition explicite

La plupart des langages supporte cette forme de boucle générale. Elle est composée de trois parties contrôlant l'exécution en plus de l'instruction à exécuter :
* l'initialisation d'une ou plusieurs variables,
* l'expression définissant la condition d'itération (testée avant exécution),
* l'instruction d'incrémentation permettant de passer à l'élément suivant.
Exemple en Java :

#### Ensemble générique

D'autres langages (Python, C Sharp, Java) permettent de spécifier un ensemble générique (éléments d'un tableaux, d'une liste...).
Exemple pour afficher tous les éléments d'un tableau en Java :