Aller à - Goto

GoTo ( goto , GOTO , GO TO ou d'autres combinaisons de cas, selon le langage de programmation) est une instruction trouvée dans de nombreux langages de programmation informatique . Il effectue un transfert de contrôle à sens unique vers une autre ligne de code ; en revanche, un appel de fonction renvoie normalement le contrôle. Les emplacements de saut sont généralement identifiés à l'aide d' étiquettes , bien que certaines langues utilisent des numéros de ligne . Au niveau du code machine , a gotoest une forme d' instruction de branchement ou de saut , dans certains cas combinée à un ajustement de pile. De nombreuses langues prennent en charge la gotodéclaration, et beaucoup ne le font pas (voir § prise en charge des langues ).

Le théorème du programme structuré a prouvé que l' gotoénoncé n'est pas nécessaire pour écrire des programmes pouvant être exprimés sous forme d' organigrammes ; une combinaison des trois constructions de programmation séquence, sélection/choix et répétition/itération est suffisante pour tout calcul pouvant être effectué par une machine de Turing , avec la mise en garde que la duplication de code et des variables supplémentaires peuvent devoir être introduites.

Dans le passé, il y avait un débat considérable dans les universités et l'industrie sur les mérites de l'utilisation des gotodéclarations. L'utilisation de goto était autrefois courante, mais depuis l'avènement de la programmation structurée dans les années 1960 et 1970, son utilisation a considérablement diminué. La principale critique est que le code qui utilise des instructions goto est plus difficile à comprendre que les constructions alternatives. Goto reste utilisé dans certains modèles d'utilisation courants , mais des alternatives sont généralement utilisées si elles sont disponibles. Les débats sur ses utilisations (plus limitées) se poursuivent dans les milieux universitaires et industriels du logiciel.

Usage

goto label

L' gotoinstruction est souvent combinée avec l' instruction if pour provoquer un transfert de contrôle conditionnel.

IF condition THEN goto label

Les langages de programmation imposent différentes restrictions en ce qui concerne la destination d'une gotoinstruction. Par exemple, le langage de programmation C ne permet pas un saut vers une étiquette contenue dans une autre fonction, cependant des sauts dans une seule chaîne d'appel sont possibles en utilisant les fonctions setjmp/longjmp .

Critique

Lors de la réunion pré-ALGOL tenue en 1959, Heinz Zemanek a explicitement mis en doute la nécessité des déclarations de GOTO ; à l'époque personne n'a prêté attention à sa remarque, y compris Edsger W. Dijkstra , qui est devenu plus tard l'adversaire emblématique de GOTO. Les années 1970 et 1980 ont vu un déclin de l'utilisation des instructions GOTO en faveur du paradigme de la « programmation structurée » , goto étant critiqué comme conduisant à un « code spaghetti non maintenable » (voir ci-dessous). Certaines normes de codage de style de programmation , par exemple les normes de codage GNU Pascal, déconseillent l'utilisation des instructions GOTO. La preuve de Böhm-Jacopini (1966) n'a pas résolu la question de savoir s'il fallait adopter une programmation structurée pour le développement de logiciels, en partie parce que la construction était plus susceptible d'obscurcir un programme que de l'améliorer car son application nécessite l'introduction de variables locales supplémentaires. Il a cependant suscité un débat de premier plan parmi les informaticiens, les éducateurs, les concepteurs de langages et les programmeurs d'applications qui ont vu un changement lent mais constant s'éloigner de l'utilisation autrefois omniprésente du GOTO. La critique la plus célèbre de GOTO est probablement une lettre de 1968 d'Edsger Dijkstra intitulée « Go To Statement Considered Harmful ». Dans cette lettre, Dijkstra a fait valoir que les instructions GOTO sans restriction devraient être supprimées des langages de niveau supérieur, car elles compliquaient la tâche d'analyser et de vérifier l'exactitude des programmes (en particulier ceux impliquant des boucles). La lettre elle-même a suscité un débat, y compris une lettre « 'GOTO considérée comme nuisible' considérée comme nuisible » envoyée aux Communications de l' ACM (CACM) en mars 1987, ainsi que d'autres réponses d'autres personnes, y compris Dijkstra sur une correspondance quelque peu décevante .

Un autre point de vue est présenté dans Donald Knuth de programmation structuré au rendez - vous aux états , qui analyse de nombreuses tâches de programmation commune et trouve que , dans certains d'entre eux GOTO est la meilleure méthode construction linguistique à l' utilisation. Dans The C Programming Language , Brian Kernighan et Dennis Ritchie avertissent que gotoc'est « infiniment abusable », mais suggèrent également qu'il pourrait être utilisé pour les gestionnaires d'erreurs de fin de fonction et pour les ruptures à plusieurs niveaux des boucles. Ces deux modèles peuvent être trouvés dans de nombreux livres ultérieurs sur C par d'autres auteurs; un manuel d'introduction de 2007 note que le modèle de gestion des erreurs est un moyen de contourner le "manque de gestion des exceptions intégrée dans le langage C". D'autres programmeurs, y compris le concepteur et codeur du noyau Linux Linus Torvalds ou l'ingénieur logiciel et auteur de livres Steve McConnell , s'opposent également au point de vue de Dijkstra, déclarant que les GOTO peuvent être une fonctionnalité de langage utile, améliorant la vitesse, la taille et la clarté du code du programme, mais seulement lorsque utilisé de manière sensée par un programmeur tout aussi sensé. Selon le professeur d'informatique John Regehr , en 2013, il y avait environ 100 000 instances de goto dans le code du noyau Linux.

D'autres universitaires ont adopté un point de vue plus extrême et ont fait valoir que même les instructions comme breaket returnau milieu des boucles sont une mauvaise pratique car elles ne sont pas nécessaires dans le résultat de Böhm-Jacopini, et ont donc préconisé que les boucles devraient avoir un seul point de sortie. Par exemple, Bertrand Meyer a écrit dans son manuel de 2009 que des instructions telles que breaket continue« ne sont que les vieux gotodéguisés en mouton ». Une forme légèrement modifiée du résultat de Böhm-Jacopini permet cependant d'éviter des variables supplémentaires dans la programmation structurée, tant que les ruptures à plusieurs niveaux des boucles sont autorisées. Parce que certains langages comme le C n'autorisent pas les coupures à plusieurs niveaux via leur breakmot-clé, certains manuels conseillent au programmeur de l'utiliser gotodans de telles circonstances. La norme MISRA C 2004 interdit goto, continue, ainsi que les instructions multiples returnet break. L'édition 2012 de la norme MISRA C a abaissé l'interdiction gotodu statut « requis » à « consultatif » ; l'édition 2012 a une règle obligatoire supplémentaire qui interdit uniquement les sauts en arrière, mais pas en avant avec goto.

FORTRAN a introduit des constructions de programmation structurées en 1978, et lors de révisions successives, les règles sémantiques relativement lâches régissant l'utilisation autorisée de goto ont été renforcées ; la "plage étendue" dans laquelle un programmeur pouvait utiliser un GOTO pour entrer et sortir d'une boucle DO toujours en cours d'exécution a été supprimée du langage en 1978, et en 1995, plusieurs formes de Fortran GOTO, y compris le GOTO calculé et le GOTO assigné, avaient été supprimé. Certains langages de programmation modernes largement utilisés tels que Java et Python manque l'instruction goto - voir le soutien linguistique - bien que la plupart fournissent un moyen de sortir d'une sélection, ou l' une rupture de ou passer à l'étape suivante d'une itération. Le point de vue selon lequel perturber le flux de contrôle dans le code est indésirable peut être vu dans la conception de certains langages de programmation, par exemple Ada met l'accent visuellement sur les définitions d'étiquettes à l'aide de crochets angulaires .

L'entrée 17.10 dans la liste FAQ comp.lang.c aborde le problème de l'utilisation de GOTO directement, indiquant

Le style de programmation, comme le style d'écriture, est en quelque sorte un art et ne peut pas être codifié par des règles inflexibles, bien que les discussions sur le style semblent souvent se concentrer exclusivement sur ces règles. Dans le cas de l'instruction goto, il a longtemps été observé que l'utilisation sans entrave de goto conduit rapidement à un code spaghetti non maintenable. Cependant, une interdiction simple et irréfléchie de l'instruction goto ne conduit pas nécessairement immédiatement à une belle programmation : un programmeur non structuré est tout aussi capable de construire un enchevêtrement byzantin sans utiliser de goto (peut-être en remplaçant des boucles étrangement imbriquées et des variables de contrôle booléennes) . De nombreux programmeurs adoptent une position modérée : les goto sont généralement à éviter, mais sont acceptables dans quelques situations bien limitées, si nécessaire : en tant qu'instructions break à plusieurs niveaux, pour regrouper des actions communes dans une instruction switch, ou pour centraliser une fonction avec plusieurs retours d'erreur. (...) Éviter aveuglément certaines constructions ou suivre des règles sans les comprendre peut conduire à autant de problèmes que les règles étaient censées en éviter. De plus, de nombreuses opinions sur le style de programmation ne sont que cela : des opinions. Elles peuvent être fortement argumentées et fortement ressenties, elles peuvent être étayées par des preuves et des arguments d'apparence solide, mais les opinions opposées peuvent être tout aussi fortement ressenties, soutenues et argumentées. Il est généralement vain de se laisser entraîner dans des « guerres de style », car sur certaines questions, les opposants ne peuvent jamais sembler être d'accord, ou accepter d'être en désaccord, ou arrêter de se disputer.

Modèles d'utilisation courants

Bien que l'utilisation globale de gotos ait diminué, il existe encore des situations dans certains langages où un goto fournit le moyen le plus court et le plus simple d'exprimer la logique d'un programme (bien qu'il soit possible d'exprimer la même logique sans gotos, le code équivalent sera plus long et souvent plus difficile à comprendre). Dans d'autres langages, il existe des alternatives structurées, notamment des exceptions et des appels de queue.

Les situations dans lesquelles goto est souvent utile incluent :

• Pour rendre le code plus lisible et plus facile à suivre
• Pour créer des programmes plus petits et se débarrasser de la duplication de code
• Implémentez une machine à états finis , en utilisant une table de transition d'état et goto pour basculer entre les états (en l'absence d' élimination des appels de queue ), en particulier dans le code C généré automatiquement. Par exemple, goto dans l'analyseur LR canonique .
• Implémentation d'une pause à plusieurs niveaux et continue si elle n'est pas directement prise en charge dans la langue ; c'est un idiome courant en C. Bien que Java réserve le mot-clé goto, il ne l'implémente pas réellement. Au lieu de cela, Java implémente des instructions break et continue étiquetées. Selon la documentation Java, l'utilisation de gotos pour les pauses à plusieurs niveaux était l'utilisation la plus courante (90 %) de gotos en C. Java n'était pas le premier langage à adopter cette approche—interdisant goto, mais fournissant des pauses à plusieurs niveaux— le langage de programmation BLISS (plus précisément sa version BLISS-11) l'a précédé à cet égard.
• Substituts pour les instructions break ou continue (réessayer) à un seul niveau lorsque l'introduction potentielle de boucles supplémentaires pourrait affecter de manière incorrecte le flux de contrôle. Cette pratique a été observée dans le code Netbsd .
• Traitement des erreurs (en l'absence d'exceptions), en particulier le code de nettoyage tel que la désallocation de ressources. C++ offre une alternative à l'instruction goto pour ce cas d'utilisation, à savoir : l' acquisition de ressources est l'initialisation (RAII) via l'utilisation de destructeurs ou l'utilisation d'exceptions try and catch utilisées dans la gestion des exceptions . setjmp et longjmp sont une autre alternative, et ont l'avantage de pouvoir dérouler une partie de la pile d'appels .
• insérer la pile, par exemple, Algol, PL/I.

Ces utilisations sont relativement courantes en C, mais beaucoup moins courantes en C++ ou dans d'autres langages dotés de fonctionnalités de niveau supérieur. Cependant, lancer et intercepter une exception à l'intérieur d'une fonction peut être extrêmement inefficace dans certains langages ; un excellent exemple est Objective-C , où un goto est une alternative beaucoup plus rapide.

Une autre utilisation des instructions goto est de modifier du code hérité mal factorisé , où éviter un goto nécessiterait une refactorisation importante ou une duplication de code . Par exemple, étant donné une fonction volumineuse où seul un certain code présente un intérêt, une instruction goto permet de sauter uniquement vers ou à partir du code pertinent, sans modifier autrement la fonction. Cette utilisation est considérée comme une odeur de code , mais trouve une utilisation occasionnelle.

Alternatives

Programmation structurée

La notion moderne de sous - programme a été inventée par David Wheeler lors de la programmation de l' EDSAC . Pour implémenter un appel et un retour sur une machine sans instruction d'appel de sous-programme, il a utilisé un modèle spécial de code auto-modifiant, connu sous le nom de saut de Wheeler . Cela a permis de structurer des programmes en utilisant des exécutions bien imbriquées de routines tirées d'une bibliothèque. Cela n'aurait pas été possible en utilisant uniquement goto, car le code cible, étant tiré de la bibliothèque, ne saurait pas où revenir.

Plus tard, des langages de haut niveau tels que Pascal ont été conçus autour de la prise en charge de la programmation structurée , qui s'est généralisée à partir de sous-routines (également appelées procédures ou fonctions) vers d'autres structures de contrôle telles que :

• Boucles utilisant les instructions while, repeat untiloudo , etfor
• switchaka casedéclarations, une forme de branchement multidirectionnel

Ces nouveaux mécanismes de langage ont remplacé des flux équivalents qui auparavant auraient été écrits en utilisant gotos et ifs. Le branchement multidirectionnel remplace le "goto calculé" dans lequel l'instruction vers laquelle sauter est déterminée dynamiquement (conditionnellement).

Exceptions

En pratique, une stricte adhésion au modèle de base à trois structures de la programmation structurée produit un code hautement imbriqué, en raison de l'incapacité de quitter prématurément une unité structurée, et une explosion combinatoire avec des données d'état de programme assez complexes pour gérer toutes les conditions possibles.

Deux solutions ont été généralement adoptées: un moyen de sortir d' une unité structurée prématurément, et plus généralement des exceptions - dans les deux cas , ces aller jusqu'à la structure, de rendre le contrôle à enfermer des blocs ou des fonctions, mais ne pas sauter à des emplacements de code arbitraire. Celles-ci sont analogues à l'utilisation d'une instruction return en position non terminale - pas strictement structurée, en raison d'une sortie anticipée, mais un léger assouplissement des restrictions de la programmation structurée. En C, breaket continuepermettez à quelqu'un de terminer une boucle ou de passer à l'itération suivante , sans nécessiter une instruction supplémentaire whileou if. Dans certaines langues, des ruptures à plusieurs niveaux sont également possibles. Pour gérer les situations exceptionnelles, des constructions spécialisées dans la gestion des exceptions ont été ajoutées, telles que try/ catch/ finallyen Java.

Les mécanismes de gestion des exceptions throw-catch peuvent également être facilement abusés pour créer des structures de contrôle non transparentes, tout comme goto peut être abusé.

Appels de queue

Dans un article présenté à la conférence de l'ACM à Seattle en 1977, Guy L. Steele a résumé le débat sur le GOTO et la programmation structurée, et a observé que les appels de procédure en position de queue d'une procédure peuvent être traités de manière optimale comme un transfert direct de contrôle. à la procédure appelée, éliminant généralement les opérations de manipulation de pile inutiles. Étant donné que de tels "appels de queue" sont très courants en Lisp , un langage où les appels de procédure sont omniprésents, cette forme d'optimisation réduit considérablement le coût d'un appel de procédure par rapport au GOTO utilisé dans d'autres langages. Steele a fait valoir que des appels de procédure mal mis en œuvre avaient conduit à une perception artificielle selon laquelle le GOTO était bon marché par rapport à l'appel de procédure. Steele a en outre fait valoir que « en général, les appels de procédure peuvent être considérés comme des instructions GOTO qui transmettent également des paramètres et peuvent être codés uniformément comme des instructions JUMP de code machine », les instructions de manipulation de la pile de code machine « étant considérées comme une optimisation (plutôt que l'inverse). !)". Steele a cité des preuves que des algorithmes numériques bien optimisés dans Lisp pouvaient s'exécuter plus rapidement que le code produit par les compilateurs Fortran commerciaux alors disponibles, car le coût d'un appel de procédure dans Lisp était beaucoup plus faible. Dans Scheme , un dialecte Lisp développé par Steele avec Gerald Jay Sussman , l'optimisation des appels de queue est obligatoire.

Bien que l'article de Steele n'ait pas introduit grand-chose de nouveau dans l'informatique, du moins telle qu'elle était pratiquée au MIT, il a mis en lumière les possibilités d'optimisation des appels de procédure, ce qui a fait des qualités de promotion de la modularité des procédures une alternative plus crédible à la les habitudes de codage alors courantes des grandes procédures monolithiques avec des structures de contrôle interne complexes et des données d'état étendues. En particulier, les optimisations d'appel de queue discutées par Steele ont transformé la procédure en un moyen crédible d'implémenter l'itération via une récursion de queue unique (récursion de queue appelant la même fonction). De plus, l'optimisation des appels de queue permet une récursivité mutuelle de profondeur illimitée, en supposant des appels de queue - cela permet le transfert de contrôle, comme dans les machines à états finis , ce qui est généralement accompli avec des instructions goto.

Coroutines

Les coroutines sont une relaxation plus radicale de la programmation structurée, permettant non seulement plusieurs points de sortie (comme dans les retours en position non-queue), mais également plusieurs points d'entrée, similaires aux instructions goto. Les coroutines sont plus restreintes que goto, car elles ne peuvent reprendre une coroutine en cours d'exécution qu'à des points spécifiés - en continuant après un rendement - plutôt que de sauter à un point arbitraire du code. Une forme limitée de coroutines sont les générateurs , qui sont suffisants pour certains usages. Encore plus limitées sont les fermetures - sous-routines qui maintiennent l'état (via des variables statiques ), mais pas la position d'exécution. Une combinaison de variables d'état et de contrôle structuré, notamment une instruction switch globale, peut permettre à un sous-programme de reprendre l'exécution à un moment arbitraire lors des appels suivants, et constitue une alternative structurée aux instructions goto en l'absence de coroutines ; c'est un idiome courant en C, par exemple.

Suite

Une continuation est similaire à un GOTO en ce sens qu'elle transfère le contrôle d'un point arbitraire du programme à un point précédemment marqué. Une continuation est plus flexible que GOTO dans les langages qui la prennent en charge, car elle peut transférer le contrôle hors de la fonction actuelle, ce qu'un GOTO ne peut pas faire dans la plupart des langages de programmation structurés. Dans les implémentations de langage qui maintiennent des cadres de pile pour le stockage des variables locales et des arguments de fonction, l'exécution d'une continuation implique l'ajustement de la pile d'appels du programme en plus d'un saut. La fonction longjmp du langage de programmation C est un exemple de continuation d'échappement qui peut être utilisée pour échapper le contexte actuel à celui qui l'entoure. L' opérateur Common Lisp GO a également cette propriété de déroulement de la pile, bien que la construction ait une portée lexicale , car l'étiquette à laquelle il faut sauter peut être référencée à partir d'une fermeture .

Dans Scheme , les continuations peuvent même déplacer le contrôle d'un contexte externe vers un contexte interne si vous le souhaitez. Ce contrôle presque illimité sur le code à exécuter ensuite rend les structures de contrôle complexes telles que les coroutines et le multitâche coopératif relativement faciles à écrire.

Passage de message

Dans les paradigmes non procéduraux, goto est moins pertinent ou complètement absent. L'une des principales alternatives est la transmission de messages , qui est particulièrement importante dans l'informatique concurrente , la communication interprocessus et la programmation orientée objet . Dans ces cas, les composants individuels n'ont pas de transfert de contrôle arbitraire, mais le contrôle global peut être programmé de manière complexe, par exemple via la préemption . Les langages influents Simula et Smalltalk ont été parmi les premiers à introduire les concepts de messages et d'objets. En encapsulant les données d'état, la programmation orientée objet a réduit la complexité logicielle aux interactions (messages) entre les objets.

Variantes

Il existe un certain nombre de constructions de langage différentes dans la classe des instructions goto .

GOTO calculé etAttribué GOTO

En Fortran , un calculGOTO saute à l'une des nombreuses étiquettes d'une liste, en fonction de la valeur d'une expression. Un exemple est goto (20,30,40) i. La construction équivalente en C est l' instruction switch et dans le Fortran plus récent, une CASEinstruction est l'alternative syntaxique recommandée. BASIC a la ON ... GOTOconstruction qui atteint le même objectif.

Dans les versions antérieures à Fortran 95, Fortran avait également une variante goto assignée qui transfère le contrôle à une étiquette d'instruction (numéro de ligne) qui est stockée dans (assignée à) une variable entière. Sauter à une variable entière qui n'avait pas été ASSIGNÉE était malheureusement possible, et était une source majeure de bogues impliquant des gotos assignés. L' assigninstruction Fortran permet uniquement d'affecter un numéro de ligne constant (existant) à la variable entière. Cependant, il était possible de traiter accidentellement cette variable comme un entier par la suite, par exemple l'incrémenter, entraînant un comportement indéterminé à la gotofois. Le code suivant illustre le comportement de la goto iligne when i n'est pas spécifiée :

    assign 200 to i
    i = i+1
    goto i ! unspecified behavior
200 write(*,*) "this is valid line number"

Plusieurs compilateurs C implémentent deux extensions C/C++ non standard relatives aux gotos initialement introduits par gcc . L'extension GNU permet d'obtenir l'adresse d'une étiquette à l'intérieur de la fonction actuelle en void*utilisant l' opérateur de valeur d'étiquette préfixe unaire &&. L'instruction goto est également étendue pour permettre de sauter à une void*expression arbitraire . Cette extension C est appelée goto calculé dans la documentation des compilateurs C qui la prennent en charge ; sa sémantique est un sur-ensemble du goto assigné à Fortran, car il autorise des expressions de pointeur arbitraires comme cible goto, tandis que le goto assigné à Fortran n'autorise pas les expressions arbitraires comme cible de saut. Comme avec le goto standard en C, l'extension GNU C permet à la cible du goto calculé de résider uniquement dans la fonction courante. Tenter de sauter en dehors de la fonction actuelle entraîne un comportement non spécifié.

Certaines variantes de BASIC prennent également en charge un GOTO calculé au sens utilisé dans GNU C, c'est-à-dire dans lequel la cible peut être n'importe quel numéro de ligne, pas seulement un numéro d'une liste. Par exemple, dans MTS BASIC, on pourrait écrire GOTO i*1000pour sauter à la ligne numérotée 1000 fois la valeur d'une variable i (qui pourrait représenter une option de menu sélectionnée, par exemple).

Les variables d'étiquette PL/I ont l'effet de s calculés ou affectés GOTO.

MODIFIER

Jusqu'à la norme ANSI COBOL de 1985 , il y avait le verbe ALTER qui pouvait être utilisé pour changer la destination d'un GO TO existant, qui devait être dans un paragraphe par lui-même. La caractéristique, qui permettait le polymorphisme , était fréquemment condamnée et rarement utilisée.

Perl GOTO

En Perl , il existe une variante de l' gotoinstruction qui n'est pas du tout une instruction GOTO traditionnelle. Il prend un nom de fonction et transfère le contrôle en substituant efficacement un appel de fonction à un autre (un appel de queue ): la nouvelle fonction ne retournera pas au GOTO, mais à l'endroit à partir duquel la fonction d'origine a été appelée.

GOTO émulé

Il existe plusieurs langages de programmation qui ne prennent pas en charge GOTO par défaut. En utilisant l'émulation GOTO, il est toujours possible d'utiliser GOTO dans ces langages de programmation, bien qu'avec certaines restrictions. On peut émuler GOTO en Java, JavaScript et Python.

Variables d'étiquette PL/I

PL/I a le type de données LABEL , qui peut être utilisé pour implémenter à la fois le "goto affecté" et le "goto calculé". PL/I autorise les branchements hors du bloc courant. Une procédure appelante peut passer une étiquette comme argument à une procédure appelée qui peut alors se terminer avec une branche. La valeur d'une variable d'étiquette inclut l'adresse d'un cadre de pile, et un goto hors du bloc fait apparaître la pile.

 /* This implements the equivalent of */
 /* the assigned goto                 */
   declare where label;
   where = somewhere;
   goto where;
   ...
 somewhere: /* statement */ ;
   ...

 /* This implements the equivalent of */
 /* the computed goto                 */
   declare where (5) label;
   declare inx fixed;
   where(1) = abc;
   where(2) = xyz;
   ...
   goto where(inx);
   ...
 abc: /* statement */ ;
   ...
 xyz: /* statement */ ;
   ...

Un moyen plus simple d'obtenir un résultat équivalent consiste à utiliser un tableau de constantes label qui n'a même pas besoin d'une déclaration explicite d'une variable de type LABEL :

 /* This implements the equivalent of */
 /* the computed goto                 */
   declare inx fixed;
   ...
   goto where(inx);
   ...
 where(1): /* statement */ ;
   ...
 where(2): /* statement */ ;
   ...

MS/DOS GOTO

Goto dirige l'exécution vers une étiquette qui commence par deux points. La cible du Goto peut être une variable.

@echo off
SET D8str=%date%
SET D8dow=%D8str:~0,3%

FOR %%D in (Mon Wed Fri) do if "%%D" == "%D8dow%" goto SHOP%%D
echo Today, %D8dow%, is not a shopping day.
goto end

:SHOPMon
echo buy pizza for lunch - Monday is Pizza day.
goto end

:SHOPWed
echo buy Calzone to take home - today is Wednesday.
goto end

:SHOPFri
echo buy Seltzer in case somebody wants a zero calorie drink.
:end

Support linguistique

De nombreuses langues soutiennent la gotodéclaration, et beaucoup ne le font pas. En Java , gotoest un mot réservé , mais inutilisable, bien que le fichier.class compilé génère des GOTO et des LABELs. Python ne prend pas en charge goto, bien qu'il existe plusieurs modules blague qui le fournissent. Il n'y a pas d'instruction goto dans Seed7 et les gotos cachés comme les instructions break et continue sont également omis. En PHP, il n'y avait pas de support natif gotojusqu'à la version 5.3 (des bibliothèques étaient disponibles pour émuler ses fonctionnalités).

Le langage de programmation C# a goto. Cependant, il ne permet pas de sauter à une étiquette en dehors de la portée actuelle, ce qui le rend nettement moins puissant et dangereux que le gotomot - clé dans d'autres langages de programmation. Il crée également des étiquettes d'instructions case et default , dont la portée est l' instruction switch englobante ; goto case ou goto default est souvent utilisé pour remplacer explicitement le fallthrough implicite, ce que C# interdit.

Le langage de programmation PL/I a une instruction GOTO qui déroule la pile pour un transfert hors bloc et ne permet pas un transfert dans un bloc depuis l'extérieur de celui-ci.

D'autres langages peuvent avoir leurs propres mots-clés séparés pour les fallthroughs explicites, qui peuvent être considérés comme une version gotorestreinte à cet objectif spécifique. Par exemple, Go utilise le fallthroughmot - clé et n'autorise pas du tout le basculement implicite, tandis que Perl 5 utilise nextle basculement explicite par défaut, mais permet également de définir le basculement implicite comme comportement par défaut pour un module.

La plupart des langages qui ont des instructions goto l'appellent ainsi, mais au début de l'informatique, d'autres noms étaient utilisés. Par exemple, dans MAD, l'instruction TRANSFER TO a été utilisée. APL utilise une flèche pointant vers la droite, →pour goto.

C a goto, et il est couramment utilisé dans divers idiomes, comme indiqué ci-dessus.

Il y a aussi une gotofonction en Perl . (voir au dessus)

Les langages de programmation fonctionnels tels que Scheme n'ont généralement pas goto, mais utilisent plutôt des continuations.

Voir également

• VIENS DE
• Flux de contrôle
• GOSUB
• Instruction Switch - une branche multidirectionnelle (ou goto conditionnel)
• Programmation non structurée
• Considéré comme nocif

Les références

• http://web.engr.uky.edu/~elias/tutorials/perldoc-html/Switch.html#Allowing-fall-through