Vamos para - Goto

GoTo ( goto , GOTO , GO TO ou outras combinações de maiúsculas e minúsculas, dependendo da linguagem de programação) é uma instrução encontrada em muitas linguagens de programação de computador . Ele executa uma transferência unilateral de controle para outra linha de código; em contraste, uma chamada de função normalmente retorna o controle. Os locais saltados geralmente são identificados por meio de rótulos , embora alguns idiomas usem números de linha . No nível do código de máquina , a gotoé uma forma de instrução de desvio ou salto , em alguns casos combinada com um ajuste de pilha. Muitos idiomas suportam a gotodeclaração e muitos não (consulte § suporte a idiomas ).

O teorema do programa estruturado provou que o gotoenunciado não é necessário para escrever programas que podem ser expressos como fluxogramas ; alguma combinação das três construções de programação de sequência, seleção / escolha e repetição / iteração são suficientes para qualquer cálculo que possa ser realizado por uma máquina de Turing , com a ressalva de que a duplicação de código e variáveis ​​adicionais podem precisar ser introduzidas.

No passado, havia um debate considerável na academia e na indústria sobre os méritos do uso de gotodeclarações. O uso de goto era comum anteriormente, mas desde o advento da programação estruturada nas décadas de 1960 e 1970, seu uso diminuiu significativamente. A principal crítica é que o código que usa instruções goto é mais difícil de entender do que as construções alternativas. Goto permanece em uso em certos padrões de uso comuns , mas geralmente são usadas alternativas, se disponíveis. Os debates sobre seus (mais limitados) usos continuam nos círculos acadêmicos e da indústria de software.

Uso

goto label

A gotoinstrução é freqüentemente combinada com a instrução if para causar uma transferência condicional de controle.

IF condition THEN goto label

As linguagens de programação impõem restrições diferentes com relação ao destino de uma gotoinstrução. Por exemplo, a linguagem de programação C não permite um salto para um rótulo contido em outra função, no entanto, saltos dentro de uma única cadeia de chamadas são possíveis usando as funções setjmp / longjmp .

Crítica

Na reunião pré-ALGOL realizada em 1959, Heinz Zemanek expressamente lançou dúvidas sobre a necessidade de declarações GOTO; na época, ninguém prestou atenção ao seu comentário, incluindo Edsger W. Dijkstra , que mais tarde se tornou o adversário icônico do GOTO. As décadas de 1970 e 1980 viram um declínio no uso de instruções GOTO em favor do paradigma de " programação estruturada " , com goto criticado por levar a " código espaguete impossível de manter " (veja abaixo). Alguns padrões de codificação de estilo de programação , por exemplo, os GNU Pascal Coding Standards, não recomendam o uso de instruções GOTO. A prova de Böhm – Jacopini (1966) não resolveu a questão de se adotar ou não a programação estruturada para o desenvolvimento de software, em parte porque a construção provavelmente obscureceria um programa do que melhorá-lo, pois sua aplicação requer a introdução de variáveis ​​locais adicionais. Isso, no entanto, gerou um debate proeminente entre cientistas da computação, educadores, designers de linguagem e programadores de aplicativos que viram uma mudança lenta, mas constante, do uso outrora onipresente do GOTO. Provavelmente, a crítica mais famosa do GOTO é uma carta de 1968 de Edsger Dijkstra chamada " Go To Statement Considered Harmful ". Nessa carta, Dijkstra argumentou que as instruções irrestritas do GOTO deveriam ser abolidas das linguagens de nível superior porque complicavam a tarefa de analisar e verificar a correção dos programas (particularmente aqueles que envolvem loops). A carta em si gerou um debate, incluindo uma carta "'GOTO Considered Harmful' Considered Harmful" enviada para Communications of the ACM (CACM) em março de 1987, bem como outras respostas de outras pessoas, incluindo Dijkstra em uma correspondência um tanto decepcionante .

Um ponto de vista alternativo é apresentado em Donald Knuth 's Programação Estruturada com movimento de Demonstrações , que analisa muitas tarefas comuns de programação e descobre que em alguns deles GOTO é o melhor construtor de linguagem para uso. Em The C Programming Language , Brian Kernighan e Dennis Ritchie avisam que gotoé "infinitamente abusável", mas também sugerem que pode ser usado para manipuladores de erro de fim de função e para quebras de loops de vários níveis. Esses dois padrões podem ser encontrados em vários livros subsequentes sobre C de outros autores; um livro introdutório de 2007 observa que o padrão de tratamento de erros é uma maneira de contornar a "falta de tratamento de exceções embutido na linguagem C". Outros programadores, incluindo o designer e codificador do kernel Linux Linus Torvalds ou o engenheiro de software e autor do livro Steve McConnell , também se opõem ao ponto de vista de Dijkstra, afirmando que os GOTOs podem ser um recurso de linguagem útil, melhorando a velocidade, o tamanho e a clareza do código do programa, mas apenas quando usado de maneira sensata por um programador sensato. De acordo com o professor de ciência da computação John Regehr , em 2013, havia cerca de 100.000 instâncias de goto no código do kernel do Linux.

Outros acadêmicos assumiram um ponto de vista mais extremo e argumentaram que mesmo as instruções como breake returndo meio dos loops são práticas inadequadas, pois não são necessárias no resultado de Böhm-Jacopini, e, portanto, defenderam que os loops deveriam ter um único ponto de saída. Por exemplo, Bertrand Meyer escreveu em seu livro de 2009 que instruções como breake continue"são apenas as velhas gotoem pele de cordeiro". Uma forma ligeiramente modificada do resultado de Böhm – Jacopini permite, no entanto, evitar variáveis ​​adicionais na programação estruturada, desde que as quebras de vários níveis de loops sejam permitidas. Como algumas linguagens como C não permitem quebras de vários níveis por meio de suas breakpalavras-chave, alguns livros aconselham o programador a usar gotoem tais circunstâncias. Os MISRA C 2004 proibições padrão goto, continuebem como múltiplos returne breakdeclarações. A edição de 2012 do padrão MISRA C rebaixou a proibição gotode status "obrigatório" para "consultivo"; a edição de 2012 tem uma regra adicional obrigatória que proíbe apenas os saltos para trás, mas não para a frente goto.

O FORTRAN introduziu construções de programação estruturada em 1978 e, em revisões sucessivas, as regras semânticas relativamente frouxas que governam o uso permitido de goto foram reforçadas; o "intervalo estendido" em que um programador poderia usar um GOTO para entrar e sair de um loop DO ainda em execução foi removido da linguagem em 1978 e, em 1995, várias formas de Fortran GOTO, incluindo o GOTO Computado e o GOTO atribuído, tinham foi excluído. Alguns amplamente utilizados modernas linguagens de programação como Java e Python falta a instrução GOTO - ver o suporte ao idioma - embora a maioria fornecer alguns meios de sair de uma seleção, ou seja quebra de ou movendo-se para a próxima etapa de uma iteração. O ponto de vista de que perturbar o fluxo de controle no código é indesejável pode ser visto no design de algumas linguagens de programação, por exemplo, Ada enfatiza visualmente as definições de rótulos usando colchetes angulares .

A entrada 17.10 na lista de FAQ do comp.lang.c aborda a questão do uso de GOTO diretamente, declarando

O estilo de programação, como o estilo de escrita, é uma espécie de arte e não pode ser codificado por regras inflexíveis, embora as discussões sobre estilo pareçam centrar-se exclusivamente em torno dessas regras. No caso da instrução goto, há muito tempo foi observado que o uso irrestrito de goto leva rapidamente a um código espaguete impossível de manter. No entanto, uma proibição simples e irrefletida da instrução goto não leva necessariamente de imediato a uma programação bonita: um programador não estruturado é igualmente capaz de construir um emaranhado bizantino sem usar nenhum goto (talvez substituindo loops aninhados de forma estranha e variáveis ​​de controle booleanas) . Muitos programadores adotam uma postura moderada: goto's geralmente devem ser evitados, mas são aceitáveis ​​em algumas situações bem restritas, se necessário: como instruções break de vários níveis, para aglutinar ações comuns dentro de uma instrução switch ou para centralizar tarefas de limpeza em uma função com vários retornos de erro. (...) Evitar cegamente certas construções ou seguir regras sem entendê-las pode levar a tantos problemas quanto as regras deveriam evitar. Além disso, muitas opiniões sobre o estilo de programação são apenas isso: opiniões. Elas podem ser fortemente argumentadas e fortemente sentidas, podem ser apoiadas por evidências e argumentos aparentemente sólidos, mas as opiniões opostas podem ser fortemente sentidas, apoiadas e argumentadas. Geralmente é fútil ser arrastado para "guerras de estilo", porque em certas questões, os oponentes nunca parecem concordar, concordar em discordar ou parar de discutir.

Padrões de uso comuns

Embora o uso geral de gotos esteja diminuindo, ainda existem situações em algumas linguagens onde um goto fornece a maneira mais curta e direta de expressar a lógica de um programa (embora seja possível expressar a mesma lógica sem gotos, o código equivalente será mais longo e muitas vezes mais difíceis de entender). Em outras linguagens, existem alternativas estruturadas, notavelmente exceções e chamadas finais.

As situações em que goto costuma ser útil incluem:

• Para tornar o código mais legível e fácil de seguir
• Para fazer programas menores e se livrar da duplicação de código
• Implemente uma máquina de estado finito , usando uma tabela de transição de estado e goto para alternar entre os estados (na ausência de eliminação de chamada final ), particularmente em código C gerado automaticamente. Por exemplo, vá para o analisador LR canônico .
• Implementar quebra de vários níveis e continuar se não houver suporte direto no idioma; este é um idioma comum em C. Embora Java reserve a palavra-chave goto, na verdade não a implementa. Em vez disso, o Java implementa instruções break e continue rotuladas. De acordo com a documentação Java, o uso de gotos para quebras de vários níveis foi o uso mais comum (90%) de gotos em C. Java não foi a primeira linguagem a adotar essa abordagem - proibindo goto, mas fornecendo quebras de vários níveis - a linguagem de programação BLISS (mais precisamente a versão BLISS-11 da mesma) a precedeu neste aspecto.
• Substitutos para instruções break ou continue (repy) de nível único quando a introdução potencial de loops adicionais poderia afetar incorretamente o fluxo de controle. Essa prática foi observada no código Netbsd .
• Tratamento de erros (na ausência de exceções), principalmente código de limpeza, como desalocação de recursos. C ++ oferece uma alternativa à instrução goto para este caso de uso, que é: Resource Acquisition Is Initialization (RAII) por meio do uso de destruidores ou do uso de exceções try e catch usadas no tratamento de Exceções . setjmp e longjmp são outra alternativa e têm a vantagem de poder desenrolar parte da pilha de chamadas .
• popping a pilha, por exemplo, Algol, PL / I.

Esses usos são relativamente comuns em C, mas muito menos comuns em C ++ ou outras linguagens com recursos de nível superior. No entanto, lançar e capturar uma exceção dentro de uma função pode ser extraordinariamente ineficiente em algumas linguagens; um bom exemplo é Objective-C , onde ir para é uma alternativa muito mais rápida.

Outro uso das instruções goto é modificar o código legado mal fatorado , onde evitar um goto exigiria refatoração extensa ou duplicação de código . Por exemplo, dada uma função grande em que apenas determinado código é de interesse, uma instrução goto permite pular de ou para apenas o código relevante, sem modificar a função de outra forma. Esse uso é considerado cheiro de código , mas encontra uso ocasional.

Alternativas

Programação estruturada

A noção moderna de sub-rotina foi inventada por David Wheeler ao programar o EDSAC . Para implementar uma chamada e retornar em uma máquina sem uma instrução de chamada de sub-rotina, ele usou um padrão especial de código de automodificação, conhecido como salto de Wheeler . Isso resultou na capacidade de estruturar programas usando execuções bem aninhadas de rotinas extraídas de uma biblioteca. Isso não teria sido possível usando only goto, uma vez que o código-alvo, sendo retirado da biblioteca, não saberia para onde voltar.

Mais tarde, linguagens de alto nível, como Pascal, foram projetadas em torno do suporte para programação estruturada , que generalizou a partir de sub - rotinas (também conhecidas como procedimentos ou funções) para outras estruturas de controle , como:

• Loops usando instruções while, repeat untiloudo , efor
• switchaka casedeclarações, uma forma de ramificação multiway

Esses novos mecanismos de linguagem substituíram fluxos equivalentes que anteriormente seriam escritos usando gotos e ifs. A ramificação multi-way substitui o "goto computado" no qual a instrução para a qual saltar é determinada dinamicamente (condicionalmente).

Exceções

Na prática, uma adesão estrita ao modelo básico de três estruturas de programação estruturada produz código altamente aninhado, devido à incapacidade de sair de uma unidade estruturada prematuramente e uma explosão combinatória com dados de estado de programa bastante complexos para lidar com todas as condições possíveis.

Duas soluções foram geralmente adotado: uma maneira de sair de uma unidade estruturada prematuramente, e mais geralmente exceções - em ambos os casos estes vão até a estrutura, retornando o controle para anexando blocos ou funções, mas não saltar para locais de código arbitrário. São análogos ao uso de uma instrução de retorno em posição não terminal - não estritamente estruturada, devido à saída antecipada, mas um leve relaxamento das restrições da programação estruturada. Em C, breake continuepermite terminar um loop ou continuar para a próxima iteração , sem exigir uma instrução extra whileou if. Em alguns idiomas, quebras de vários níveis também são possíveis. Para lidar com situações excepcionais, foram adicionadas construções especializadas de manipulação de exceções , como try/ catch/ finallyem Java.

Os mecanismos de tratamento de exceções throw-catch também podem ser facilmente abusados ​​para criar estruturas de controle não transparentes, assim como goto pode ser abusado.

Chamadas de cauda

Em um artigo entregue na conferência ACM em Seattle em 1977, Guy L. Steele resumiu o debate sobre o GOTO e a programação estruturada, e observou que as chamadas de procedimento na posição final de um procedimento podem ser tratadas de forma otimizada como uma transferência direta de controle para o procedimento chamado, normalmente eliminando operações desnecessárias de manipulação de pilha. Como essas "chamadas finais" são muito comuns no Lisp , uma linguagem onde as chamadas de procedimento são onipresentes, essa forma de otimização reduz consideravelmente o custo de uma chamada de procedimento em comparação com o GOTO usado em outras linguagens. Steele argumentou que chamadas de procedimento mal implementadas levaram a uma percepção artificial de que o GOTO era barato em comparação com a chamada de procedimento. Steele argumentou ainda que "em chamadas de procedimento geral podem ser utilmente pensadas como instruções GOTO que também passam parâmetros e podem ser codificadas uniformemente como instruções JUMP de código de máquina ", com as instruções de manipulação de pilha de código de máquina "consideradas uma otimização (em vez de vice-versa !) ". Steele citou evidências de que algoritmos numéricos bem otimizados em Lisp podiam executar mais rápido do que o código produzido por compiladores Fortran comerciais então disponíveis porque o custo de uma chamada de procedimento em Lisp era muito menor. Em Scheme , um dialeto Lisp desenvolvido por Steele com Gerald Jay Sussman , a otimização da chamada de cauda é obrigatória.

Embora o artigo de Steele não tenha introduzido muito do que era novo na ciência da computação, pelo menos como era praticado no MIT, ele trouxe à luz o escopo para a otimização de chamada de procedimento, o que tornou as qualidades de promoção da modularidade dos procedimentos em uma alternativa mais confiável para o hábitos de codificação então comuns de grandes procedimentos monolíticos com estruturas de controle interno complexas e dados de estado extensos. Em particular, as otimizações de cauda discutidas por Steele transformaram o procedimento em uma maneira confiável de implementar iteração por meio de recursão de cauda única (recursão de cauda chamando a mesma função). Além disso, a otimização da chamada final permite a recursão mútua de profundidade ilimitada, assumindo chamadas finais - isso permite a transferência de controle, como em máquinas de estado finito , o que de outra forma geralmente é realizado com instruções goto.

Corrotinas

As co-rotinas são um relaxamento mais radical da programação estruturada, permitindo não apenas vários pontos de saída (como em retornos na posição não cauda), mas também vários pontos de entrada, semelhantes às instruções goto. As corrotinas são mais restritas do que goto, já que só podem retomar uma corrotina em execução em pontos especificados - continuando após um rendimento - em vez de pular para um ponto arbitrário no código. Uma forma limitada de co-rotinas são geradores , que são suficientes para alguns fins. Ainda mais limitados são os fechamentos - sub-rotinas que mantêm o estado (por meio de variáveis ​​estáticas ), mas não a posição de execução. Uma combinação de variáveis ​​de estado e controle estruturado, notavelmente uma instrução switch geral, pode permitir que uma sub-rotina retome a execução em um ponto arbitrário nas chamadas subsequentes e é uma alternativa estruturada para instruções goto na ausência de corrotinas; este é um idioma comum em C, por exemplo.

Continuações

Uma continuação é semelhante a um GOTO no sentido de que transfere o controle de um ponto arbitrário no programa para um ponto previamente marcado. Uma continuação é mais flexível do que GOTO nas linguagens que a suportam, porque pode transferir o controle da função atual, algo que um GOTO não pode fazer na maioria das linguagens de programação estruturadas. Naquelas implementações de linguagem que mantêm os quadros de pilha para armazenamento de variáveis ​​locais e argumentos de função, a execução de uma continuação envolve o ajuste da pilha de chamadas do programa, além de um salto. A função longjmp da linguagem de programação C é um exemplo de uma continuação de escape que pode ser usada para escapar do contexto atual para um contexto circundante. O operador Common Lisp GO também tem essa propriedade de desenrolamento de pilha, apesar da construção ter um escopo lexical , já que o rótulo a ser pulado pode ser referenciado a partir de um encerramento .

No Scheme , as continuações podem até mesmo mover o controle de um contexto externo para um interno, se desejado. Esse controle quase ilimitado sobre o código a ser executado em seguida torna as estruturas de controle complexas, como corrotinas e multitarefa cooperativa, relativamente fáceis de escrever.

Passagem de mensagem

Em paradigmas não procedimentais, goto é menos relevante ou completamente ausente. Uma das principais alternativas é a passagem de mensagens , que é de particular importância em computação concorrente , comunicação entre processos e programação orientada a objetos . Nesses casos, os componentes individuais não têm transferência arbitrária de controle, mas o controle geral pode ser programado de maneiras complexas, como por meio de preempção . As influentes linguagens Simula e Smalltalk estiveram entre as primeiras a introduzir os conceitos de mensagens e objetos. Ao encapsular dados de estado, a programação orientada a objetos reduziu a complexidade do software para interações (mensagens) entre objetos.

Variações

Existem várias construções de linguagem diferentes na classe das instruções goto .

GOTO computado eGOTO atribuído

No Fortran , um calculadoGOTO salta para um dos vários rótulos em uma lista, com base no valor de uma expressão. Um exemplo é goto (20,30,40) i. A construção equivalente em C é a instrução switch e no Fortran mais recente, uma CASEinstrução é a alternativa sintática recomendada. BASIC tem a ON ... GOTOconstrução que atinge o mesmo objetivo.

Em versões anteriores ao Fortran 95, o Fortran também tinha uma variante goto atribuída que transfere o controle para um rótulo de instrução (número de linha) que é armazenado em (atribuído a) uma variável inteira. Pular para uma variável inteira que não tinha sido ATRIBUÍDA era infelizmente possível e era a maior fonte de bugs envolvendo gotos atribuídos. A assigninstrução Fortran permite apenas que um número de linha constante (existente) seja atribuído à variável inteira. No entanto, era possível tratar acidentalmente essa variável como um inteiro depois disso, por exemplo incrementá-la, resultando em um comportamento não especificado no gotomomento. O código a seguir demonstra o comportamento de goto iquando a linha i não é especificada:

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

Vários compiladores C implementam duas extensões C / C ++ não padrão relacionadas aos gotos originalmente introduzidos pelo gcc . A extensão GNU permite que o endereço de um rótulo dentro da função atual seja obtido como um operador de valor de rótulo devoid* prefixo unário . A instrução goto também é estendida para permitir o salto para uma expressão arbitrária . Essa extensão C é conhecida como goto computado na documentação dos compiladores C que a suportam; sua semântica é um superconjunto do goto atribuído de Fortran, porque permite expressões de ponteiro arbitrárias como destino de goto, enquanto o goto atribuído de Fortran não permite expressões arbitrárias como destino de salto. Tal como acontece com o goto padrão em C, a extensão GNU C permite que o destino do goto calculado resida apenas na função atual. A tentativa de pular para fora da função atual resulta em um comportamento não especificado. &&void*

Algumas variantes do BASIC também suportam um GOTO computado no sentido usado no GNU C, ou seja, em que o destino pode ser qualquer número de linha, não apenas um de uma lista. Por exemplo, no MTS BASIC, pode-se escrever GOTO i*1000para saltar para a linha numerada 1000 vezes o valor de uma variável i (que pode representar uma opção de menu selecionada, por exemplo).

Variáveis ​​de rótulo PL / I alcançam o efeito de GOTOs computados ou atribuídos .

ALTERAR

Até o padrão ANSI COBOL de 1985 tinha o verbo ALTER que podia ser usado para alterar o destino de um GO TO existente, que deveria estar em um parágrafo por si só. O recurso, que permitia polimorfismo , era frequentemente condenado e raramente usado.

Perl GOTO

Em Perl , há uma variante da gotoinstrução que não é uma instrução GOTO tradicional. Ele recebe um nome de função e transfere o controle substituindo efetivamente uma chamada de função por outra (uma chamada final ): a nova função não retornará ao GOTO, mas ao lugar de onde a função original foi chamada.

GOTO emulado

Existem várias linguagens de programação que não suportam GOTO por padrão. Ao usar a emulação GOTO, ainda é possível usar GOTO nessas linguagens de programação, embora com algumas restrições. Pode-se emular GOTO em Java, JavaScript e Python.

Variáveis ​​de rótulo PL / I

PL / I tem o tipo de dados LABEL , que pode ser usado para implementar o "goto atribuído" e o "goto calculado". PL / I permite ramificações fora do bloco atual. Um procedimento de chamada pode passar um rótulo como um argumento para um procedimento chamado que pode então sair com uma ramificação. O valor de uma variável de rótulo inclui o endereço de um quadro de pilha, e ir para fora do bloco abre a pilha.

 /* 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 */ ;
   ...

Uma maneira mais simples de obter um resultado equivalente é usar uma matriz de constante de rótulo que nem mesmo precisa de uma declaração explícita de uma variável do tipo 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 direciona a execução para um rótulo que começa com dois pontos. O alvo do Goto pode ser uma variável.

@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

Suporte de linguas

Muitos idiomas suportam a gotodeclaração, e muitos não. Em Java , gotoé uma palavra reservada , mas não pode ser usada , embora o file.class compilado gere GOTOs e LABELs. Python não tem suporte para goto, embora existam vários módulos de piadas que o fornecem. Não há instrução goto no Seed7 e comandos ocultos como instruções break- e continue-também são omitidos. No PHP não havia suporte nativo para gotoaté a versão 5.3 (bibliotecas estavam disponíveis para emular sua funcionalidade).

A linguagem de programação C # tem goto. No entanto, ele não permite pular para um rótulo fora do escopo atual, tornando-o significativamente menos poderoso e perigoso do que a gotopalavra - chave em outras linguagens de programação. Ele também cria rótulos de instruções case e default , cujo escopo é a instrução switch envolvente ; goto case ou goto default são frequentemente usados ​​como uma substituição explícita para fallthrough implícito, que o C # não permite.

A linguagem de programação PL / I tem uma instrução GOTO que desenrola a pilha para uma transferência fora do bloco e não permite uma transferência para um bloco de fora dele.

Outros idiomas podem ter suas próprias palavras-chave separadas para falhas explícitas, que podem ser consideradas uma versão de gotorestrita a esse propósito específico. Por exemplo, Go usa a fallthroughpalavra - chave e não permite nenhum fallthrough implícito, enquanto o Perl 5 usa nextpara fallthrough explícito por padrão, mas também permite definir o fallthrough implícito como comportamento padrão para um módulo.

A maioria das linguagens que possuem instruções goto o chamam, mas nos primeiros dias da computação, outros nomes eram usados. Por exemplo, em MAD, a instrução TRANSFER TO foi usada. APL usa uma seta apontando para a direita, →para goto.

C tem goto e é comumente usado em vários idiomas, conforme discutido acima.

Também existe uma gotofunção em Perl . (Veja acima)

Linguagens de programação funcional, como Scheme, geralmente não têm goto, em vez de usar continuações.

Veja também

• VEM DE ONDE
• Controle de fluxo
• GOSUB
• Instrução Switch - um branch multiway (ou goto condicional)
• Programação não estruturada
• Considerado prejudicial

Referências

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