Goto (informatique)

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Pour les articles homonymes, voir Goto.

L’instruction goto (de l’anglais go to qui signifie 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, changeant ainsi le flot de contrôle naturel du programme qui consiste à aller exécuter l'instruction suivante. L’exécution est alors envoyée à une autre instruction repérée par une étiquette ou label, qui est soit un numéro de ligne, 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 conditionnelles (if .. then .. else ..) ou les boucles (for, whileetc.) 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 qui ont l'avantage de ne pas détourner le flot naturel de contrôle vers une instruction qui se trouve plus loin dans l'ordre textuel du programme, 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 en C, mais ce qui n'est pas le cas en BASIC (standard ANSI X3.113), Pascal (standard ISO 7185) ou en Fortran (toutes les versions du standard), qui ont des étiquettes numériques[2].

Langages[modifier | modifier le code]

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

En Java goto est un mot réservé. Or comme l'instruction goto n'existe pas, goto devient un mot interdit et cela a pour effet, entre autres, d’empêcher l’emploi de goto comme nom de variable.

Émulation[modifier | modifier le code]

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.

Goto malgré tout[modifier | modifier le code]

Dans des langages ne comportant pas de goto, certains programmeurs restent convaincus (à tort ou à raison) de l’intérêt de les employer, néanmoins. Il s’est alors développé une méthode d’émulation. Concrètement, il s’agit de placer le label dans une variable que le code recherche durant son exécution:

% 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
}

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

Cette construction a été employée par Knuth pour démontrer qu'il était possible d'écrire du code non structuré sans goto. Il s'agit alors d'un antipattern, c'est-à-dire d'un exemple de ce qu'il ne faut pas faire[7].

Exceptions[modifier | modifier le code]

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

Critique[modifier | modifier le code]

Bien que lors du meeting pré-ALGOL tenue en 1959, Heinz Zemanek a explicitement exprimé des doutes sur la nécessité du GOTO, à l'époque, personne n'a fait attention à sa remarque, y compris Edsger Dijkstra, qui deviendra plus tard un opposant emblématique de l'instruction GOTO.[8] Les années 1970 et 1980 ont connu une baisse de l'utilisation des GOTO en faveur de la « programmation structurée », en effet, l'instruction GOTO amenait à un « code spaghetti inmaintenable ». Certaines normes de style de programmation déconseillent l'utilisation des instructions GOTO[9]. Il a, cependant, suscité un débat important parmi les informaticiens, éducateurs, concepteurs de langage et les programmeurs d'applications qui ont vu un changement lent, mais régulier, de l'usage autrefois omniprésent du GOTO. La critique probablement la plus célèbre de l'instruction GOTO est une lettre 1968 de Edsger Dijkstra nommé Go To Statement Considered Harmful.[8] [10] Dans cette lettre, Dijkstra a fait valoir que les déclarations GOTO devraient être supprimés à partir des langages de niveau supérieur car ils ont compliqué la tâche d'analyse et de vérification des programmes (en particulier ceux impliquant des boucles). La lettre elle-même a suscité un débat, y compris une lettre "'GOTO Considered Harmful' Considered Harmful"[11],[12]Un autre point de vue est présenté par Donald Knuth dans Structured Programming with go to Statements, analyse de nombreuses tâches de programmation et constate que, dans certains d'entre eux, GOTO est la construction de la langue la plus optimale à utiliser[13]. Dans leur livre sur le langage de programmation C, Dennis Ritchie et Brian Kernighan avertissent que goto est « infiniment abusable »[14]. Ces configurations peuvent être trouvées dans de nombreux ouvrages portant sur C d'autres auteurs[15],[16],[17],[18]; un manuel d'introduction de 2007 note que le modèle de gestion des erreurs est un moyen de contourner le « le manque de gestion des exceptions intégré dans le langage C »[15]. D'autres programmeurs, comme créateur et codeur du noyau Linux Linus Torvalds, ou l'ingénieur logiciel et auteur Steve McConnell, désapprouvent également le point de vue de Dijkstra, indiquant que GOTO peut amener à une l'amélioration de la vitesse du programme, la taille et la clarté du code, mais seulement lorsqu'il est utilisé de manière raisonnable[19],[20]. Selon le professeur de sciences informatiques John Regehr, en 2013, il y avait environ 100 000 instruction GOTO dans le code du noyau Linux[21].

Voir aussi[modifier | modifier le code]

Liens externes[modifier | modifier le code]

Références[modifier | modifier le code]

  1. « Linux: Using goto In Kernel Code » (version du 28 novembre 2005 sur l'Internet Archive)
  2. Noter que les implémentations modernes de Pascal et BASIC permettent également des étiquettes alphanumériques.
  3. Ada 2012 Reference Manual - 5.8 Goto Statements
  4. Special Operator GO, Common Lisp HyperSpec
  5. goto sur le manuel de php.net
  6. The Joke Is On Us: How Ruby 1.9 Supports the Goto Statement
  7. Goto Perl, Philippe Bruhat et Jean Forget 2005
  8. a et b Dijkstra 1968.
  9. « GNU Pascal Coding Standards », sur www.gnu-pascal.de (consulté le 1er novembre 2016)
  10. EWD 215: A Case against the GO TO Statement
  11. (en) Frank Rubin, « "GOTO Considered Harmful" Considered Harmful », Communications of the ACM, vol. 30, no 3,‎ , p. 195–196 (DOI 10.1145/214748.315722, lire en ligne [PDF])
  12. On a Somewhat Disappointing Correspondence (May, 1987)
  13. (en) Donald Knuth, « Structured Programming with go to Statements », Computing Surveys, vol. 6, no 4,‎ , p. 261–301 (DOI 10.1145/356635.356640, lire en ligne)
  14. (en) Brian W. Kernighan et Dennis Ritchie, C Programming Language, Prentice Hall, , 60–61 p. (ISBN 978-0-13-308621-8)
  15. a et b (en) Michael A. Vine, C Programming for the Absolute Beginner, Cengage Learning, (ISBN 1-59863-634-0), p. 262
  16. (en) Sandra Geisler, C All-in-One Desk Reference For Dummies, John Wiley & Sons, , 217–220 p. (ISBN 978-1-118-05424-6)
  17. (en) Stephen Prata, C Primer Plus, Addison-Wesley, , 287–289 p. (ISBN 978-0-13-343238-1)
  18. (en) Sartaj Sahni, Robert F. Cmelik et Bob Cmelik, Software Development in C, Silicon Press, (ISBN 978-0-929306-16-2, lire en ligne), p. 135
  19. http://kerneltrap.org/node/553
  20. (en) « Code Complete, First Edition », Stevemcconnell.com (consulté le 22 juillet 2014)
  21. Use of Goto in Systems Code

Bibliographie[modifier | modifier le code]