Déclaration (informatique)

• Algol 60 :begin <sequence> end
• Pascal:begin <sequence> end
• C, PHP, Java :{ <sequence> }

D'autres langages de programmation possèdent un terminateur spécial différent pour chaque type d'instruction composée, de sorte qu'une ou plusieurs instructions sont automatiquement traitées comme un groupe :

• Ada :iftestthen<sequence>endif;

De nombreuses instructions composées sont des boucles ou des instructions de choix. En théorie, une seule instruction de chaque type est nécessaire. En pratique, il existe divers cas particuliers assez fréquents ; ceux-ci peuvent simplifier la compréhension et la programmation d'un programme, et souvent permettre une implémentation bien plus efficace. De nombreuses subtilités ne sont pas abordées ici ; consultez les articles associés pour plus de détails.

• boucle contrôlée par comptage :
  • Algol 60 :for index:= 1 step 1 until limit do <statement>;
  • Pascal:forindex:=1tolimitdo<statement>;
  • C, Java :for(index=1;index<=limit;index+=1)<statement>;
  • Ada :forindexin1..limitloop<sequence>endloop
  • Fortran 90 :
    DO index = 1 , limit < séquence > END DO
• boucle conditionnelle avec test au début de la boucle :
  • Algol 60 :for index:= expression while test do <statement>;
  • Pascal:whiletestdo<statement>;
  • C, Java :while(test)<statement>;
  • Ada :whiletestloop<sequence>endloop
  • Fortran 90 :
    FAIRE TANT QUE ( test ) < séquence > FIN FAIRE
• boucle conditionnelle avec test à la fin de la boucle :
  • Pascal:repeat<sequence>untiltest;{ note reversed test }
  • C, Java :do{<sequence>}while(test);
  • Ada :loop<sequence>exitwhentest;endloop;
• boucle conditionnelle avec test au milieu de la boucle :
  • C:do{<sequence>if(test)break;<sequence>}while(true);
  • Ada :loop<sequence>exitwhentest;<sequence>endloop;
• situation simple avec instruction if :
  • Algol 60 :if test then <unconditional statement>;
  • Pascal:iftestthen<statement>;
  • C, Java :if(test)<statement>;
  • Ada :iftestthen<sequence>endif;
  • Fortran 77+ :
    SI ( test ) ALORS < séquence > FIN SI
• instruction if à choix binaire :
  • Algol 60 :if test then <unconditional statement> else <statement>;
  • Pascal:iftestthen<statement>else<statement>;
  • C, Java :if(test)<statement>else<statement>;
  • Ada :iftestthen<sequence>else<sequence>endif;
  • Fortran 77+ :
    SI ( test ) ALORS < séquence > SINON < séquence > FIN SI
• instruction case/switch à choix multiple :
  • Pascal:casecof'a':alert();'q':quit();end;
  • Ada :caseciswhen'a'=>alert();when'q'=>quit();endcase;
  • C, Java :switch(c){case'a':alert();break;case'q':quit();break;}
• Gestion des exceptions :
  • Ada :begin protected code except when exception specification => exception handler
  • Java:try { protected code } catch (exception specification) { exception handler } finally { cleanup }
  • Python: try: protected code except exception specification: exception handler else: no exceptions finally: cleanup

Dans Algol 60 et Algol 68, des jetons spéciaux étaient explicitement distingués : pour la publication, en gras (ex. : « [i] » )begin ; pour la programmation, avec un marquage spécial, par exemple un drapeau († 'begin), des guillemets ( 'begin'†) ou un soulignement ( beginsur l’ Elliott 503 ). On appelle cela le « stropping ».

Les jetons qui font partie de la syntaxe du langage ne sont donc pas en conflit avec les noms définis par le programmeur.

La sémantique s'intéresse à la signification d'un programme. Les documents de normalisation de nombreux langages de programmation utilisent la BNF ou un équivalent pour exprimer la syntaxe/grammaire de manière relativement formelle et précise, mais la sémantique/signification du programme est généralement décrite à l'aide d'exemples et de prose anglaise. Cela peut engendrer des ambiguïtés. Dans certaines descriptions de langages, la signification des instructions composées est définie par l'utilisation de constructions « plus simples », par exemple une boucle while peut être définie par une combinaison de tests, de sauts et d'étiquettes , en utilisant ifet goto.

L' article sur la sémantique décrit plusieurs formalismes mathématiques et logiques utilisés pour spécifier la sémantique avec précision ; ces formalismes sont généralement plus complexes que la BNF, et aucune approche ne fait l'unanimité. Certaines approches définissent un interpréteur pour le langage, d'autres utilisent la logique formelle pour raisonner sur un programme, d'autres encore ajoutent des affixes aux entités syntaxiques pour garantir la cohérence, etc.

On distingue souvent les instructions, qui sont exécutées, des expressions , qui sont évaluées. Les expressions produisent toujours une valeur, contrairement aux instructions. Cependant, les expressions sont souvent utilisées au sein d'instructions plus complexes.

Dans la plupart des langages de programmation, une instruction peut se limiter à une simple expression, généralement suivie d'un point-virgule. Dans ce cas, bien que l'expression soit évaluée, l'instruction elle-même n'est pas exécutée (la valeur de l'expression est ignorée). Par exemple, en C, C++, C# et dans de nombreux langages similaires, x = y + 1l'expression `x = y + 1` affecte à `x` la valeur de `y + 1`, et l'expression entière est évaluée à la même valeur que celle de `x`. En revanche, x = y + 1;l'instruction `x = y + 1` (notez le point-virgule à la fin) affectera également à `x` la valeur de `y + 1`, car l'expression qu'elle contient est évaluée, mais son résultat est ignoré et l'instruction elle-même n'est pas évaluée.

Les expressions peuvent également être contenues dans d'autres expressions. Par exemple, l'expression x = y + 1contient l'expression y + 1, qui à son tour contient les valeurs yet 1, qui sont également, techniquement parlant, des expressions.

Bien que les exemples précédents présentent des expressions d'affectation, certains langages n'implémentent pas l'affectation comme une expression, mais plutôt comme une instruction. Python en est un exemple notable : le signe « = » n'y est pas un opérateur, mais simplement un séparateur dans l'instruction d'affectation. Bien que Python autorise plusieurs affectations, chacune étant considérée comme une expression, il s'agit en réalité d'un cas particulier de l'instruction d'affectation inhérente à la grammaire du langage, et non d'une véritable expression.

La plupart des langages possèdent un ensemble fixe d'instructions définies par le langage, mais des expériences ont été menées avec des langages extensibles qui permettent au programmeur de définir de nouvelles instructions.