Goto

Un article de Wikipédia, l'encyclopédie libre.
Aller à : Navigation, rechercher

L’instruction goto (de l’anglais go to, en français aller à) est une instruction présente dans de nombreux langages de programmation. Elle est utilisée pour réaliser des sauts inconditionnels dans un programme. L’exécution est renvoyée vers une étiquette ou label, qui est soit un numéro de ligne donné, soit une étiquette déclarée, selon le langage.

L’instruction goto, directement héritée des instructions de saut des langages machines, était nécessaire dans les langages primitifs (Fortran pré-90, BASIC) comme instruction de base permettant de réaliser des boucles et autres structures de contrôles.

Depuis la révolution de la programmation structurée des années 1970, l’instruction goto n’est plus guère appréciée des programmeurs modernes, car elle rend souvent les programmes plus difficiles à comprendre et à maintenir (on parle dans ce cas de programmation spaghetti). On utilise plus généralement des structures comme les sauts conditionnels (if .. then .. else ..) ou les boucles (for, while, etc.) qui font partie intégrante de tous les langages de programmation impératifs modernes.

Dans certains langages, d’autres instructions effectuent des sauts inconditionnels et remplacent quelques usages de l’instruction goto. C’est le cas des instructions comme continue ou break, que l’on trouve dans les langages dérivés du C, et des exceptions. On peut obtenir un comportement similaire avec le call/cc de Scheme, ou catch...throw en Ruby et Common Lisp (sans rapport avec les exceptions dans ces deux langages).

Edsger Dijkstra et Niklaus Wirth ont défendu l'idée selon laquelle l'instruction goto ne peut que mener à du code illisible. D'autres, comme Linus Torvalds ou Robert Love (en), ont fait remarquer que même si elle incite à produire du code spaghetti, l'instruction goto peut être appréciable et rendre au contraire le code plus lisible, lorsqu'elle est employée à bon escient[1]. D'ailleurs, dans leur livre The Elements of Programming Style (en), Kernighan et Plauger (en) indiquent comment écrire du code structuré en Fortran et en PL/I, tout en faisant intensivement appel à l'instruction goto. Par ailleurs, l'usage de goto peut être rendu plus clair avec des étiquettes suffisamment descriptives, ce qui est possible lorsque les étiquettes sont alphanumériques, comme par exemple en C. En revanche, elles sont purement numériques en BASIC (standard ANSI X3.113), Pascal (standard ISO 7185) ou en Fortran 77. Les versions modernes de Pascal et BASIC permettent également des étiquettes alphanumériques.

Sommaire

Langages [modifier]

L’instruction goto (ou équivalent) apparaît notamment dans les langages suivants :

L’instruction goto est un mot réservé en Java mais il est interdit de l’utiliser (cela a pour effet, par exemple, d’empêcher l’emploi de goto comme nom de variable).

Émulation [modifier]

En 1966, le théorème de Böhm-Jacopini (en) a démontré que tout programme comportant des goto pouvait être transformé en programme n’utilisant que des branchements conditionnels (if, then, else) ou des boucles (while condition do instructions), éventuellement en dupliquant des portions de codes et/ou en utilisant des variables intermédiaires. Plus tard les deux auteurs ont montré que les branchements conditionnels pouvaient eux mêmes être remplacés par des boucles.

Méthode de Jacopini [modifier]

Bien que des langages ne comportent pas de goto, certains programmeurs sont convaincus (à tort ou à raison) de l’intérêt de les employer. Il s’est alors développé une méthode d’émulation. Concrètement, il s’agit de placer le label dans une variable et de la chercher durant tout le code. Ainsi, on a :

% Début de programme
goto = -1  % pas de saut
while (goto < 0) {
  % zone sans libellé
}

if (goto == 0) {
  % Toute la partie de libellé 0
}
else if (goto == 1) {
  % Toute la partie de libellé 1
}
% ...
else if (goto == n) {
  % Toute la partie de libellé n
}

On voit d’abord que les libellés peuvent être des chaînes ou des nombres, y compris des expressions. Il est possible d’aller plus loin et de ne pas se restreindre à un ensemble de points pour représenter les libellés. On peut ainsi les représenter par des ensembles d’intervalles, de plans et d’hyperplans. L’inconvénient de cette méthode est qu’il faut attendre que toutes les instructions de la boucles while soient terminées pour que le saut inconditionnel soit réalisé.

Exceptions [modifier]

Les fonctions setjmp et longjmp, disponibles sur certains systèmes d’exploitation, permettent aussi d’émuler l’instruction goto. Mais ces instructions de saut inconditionnel sont surtout utilisées pour implémenter un système de gestion des exceptions.

L’utilisation d’exception est par exemple un pattern courant en Python pour sortir d’une double boucle :

try :
    for i in range(10) :
        for j in range(10) :
            if TABLE[i][j] == 1:
                raise StopIteration
except StopIteration :
    pass

Anecdotes [modifier]
Les sections « Anecdotes », « Autres détails », « Le saviez-vous ? », « Citations », etc., peuvent être inopportunes dans les articles.
Pour améliorer cet article il convient, si ces faits présentent un intérêt encyclopédique et sont correctement sourcés, de les intégrer dans d’autres sections.

Les premières versions d’Algol 60 réalisées en France avaient traduit tous les mots clés du langage et tout naturellement l’instruction goto s’appelait allera (« aller à »).

Goto est un authentique patronyme japonais et Donald Knuth plaisantait sur ce pauvre Monsieur Goto que tout le monde rejetait.

Il existe également un langage de programmation exotique parodique, le GOTO++, qui se déclare orienté GOTO[5].

Voir aussi [modifier]

Liens externes [modifier]

Références [modifier]

  1. ↑ Linux: Using goto In Kernel Code
  2. ↑ Special Operator GO, Common Lisp HyperSpec
  3. ↑ goto sur le manuel de php.net
  4. ↑ The Joke Is On Us: How Ruby 1.9 Supports the Goto Statement
  5. ↑ Présentation du GOTO++.
v · d · m
Éléments de programmation informatique
Bibliothèque logicielle Bibliothèque standard • Espace de nom • Framework • Gabarit (template) • Interface • Interface de programmation (API)
Vocabulaire
Algorithme • Définition d'opérateur  • Expression • Indentation • Ligne de code • Opérateur • Pseudo-code
Autour des fonctions Convention de nommage • Dispatch multiple  • Factorisation • Fonction imbriquée • Fonction de rappel • Fonction récursive • Généricité • Opérande • Paramètre • Polymorphisme • Procédure • Signature de type  • Surcharge
Autour de l'objet Classe • Constructeur • Destructeur • Encapsulation • Héritage • Héritage multiple • Instance • Méthode • Ramasse-miettes (garbage collector) • Référence
Dans le code source
Structures de données Arbre • Attribut • Caractère • Enregistrement • File • First in, first out (fifo) • Last in, first out (lifo) • Liste • Liste chaînée • Pile • Propriété • Table de symboles • Tableau • Tas • Type abstrait • Sémaphore
Déclarations : types et variables Affectation • Pointeur • Portée • Tableau associatif • Type énuméré • Type récursif • Typage statique • Variable • Variable globale • Variable locale
Structures de contrôle case • do • else • eval • if • for • goto • loop • switch • while
Fonctions usuelles Concaténation • Incrémentation • malloc • printf
Outil de développement logiciel Environnement de développement  • Générateur de documentation • Gestion de versions • Modèle • Patch • Spécification
Folklore Hello world • Keep it Simple, Stupid • Langage de programmation exotique
Ce document provient de « http://fr.wikipedia.org/w/index.php?title=Goto&oldid=92596345 ».