我只记得用过一次goto。我有一系列五个嵌套计数循环，我需要能够根据某些条件从内部打破整个结构:

    for{
      for{
        for{
          for{
            for{
              if(stuff){
                GOTO ENDOFLOOPS;
              }
            }
          }
        }
      }
    }
    
    ENDOFLOOPS:

我可以很容易地声明一个布尔中断变量，并将其用作每个循环的条件的一部分，但在这种情况下，我认为GOTO是一样实用和一样可读的。

没有迅猛龙攻击我。

许多现代编程语言使用它们的编译器来强制限制GOTO的使用——这减少了潜在的风险。例如，c#不允许您使用GOTO从循环体外部跳转到循环体。文档中提到了限制。

这是GOTO有时比过去更安全的一个例子。

在某些情况下，GOTO的使用与提前从函数返回相同(即提前跳出循环)。然而，良好的形式是有争议的。

如果GOTO本身是邪恶的，那么编译器也是邪恶的，因为它们生成jmp。如果跳转到代码块，特别是跟随一个指针，在本质上是邪恶的，那么RETurn指令就是邪恶的。相反，邪恶在于滥用的可能性。

有时我不得不编写应用程序，必须跟踪许多对象，其中每个对象必须遵循复杂的状态序列来响应事件，但整个事情绝对是单线程的。一个典型的状态序列，如果用伪代码表示，将是:

request something
wait for it to be done
while some condition
    request something
    wait for it
    if one response
        while another condition
            request something
            wait for it
            do something
        endwhile
        request one more thing
        wait for it
    else if some other response
        ... some other similar sequence ...
    ... etc, etc.
endwhile

我相信这不是新的，但我在C(++)中处理它的方式是定义一些宏:

#define WAIT(n) do{state=(n); enque(this); return; L##n:;}while(0)
#define DONE state = -1

#define DISPATCH0 if state < 0) return;
#define DISPATCH1 if(state==1) goto L1; DISPATCH0
#define DISPATCH2 if(state==2) goto L2; DISPATCH1
#define DISPATCH3 if(state==3) goto L3; DISPATCH2
#define DISPATCH4 if(state==4) goto L4; DISPATCH3
... as needed ...

然后(假设初始状态为0)上面的结构化状态机转换为结构化代码:

{
    DISPATCH4; // or as high a number as needed
    request something;
    WAIT(1); // each WAIT has a different number
    while (some condition){
        request something;
        WAIT(2);
        if (one response){
            while (another condition){
                request something;
                WAIT(3);
                do something;
            }
            request one more thing;
            WAIT(4);
        }
        else if (some other response){
            ... some other similar sequence ...
        }
        ... etc, etc.
    }
    DONE;
}

在此基础上，可以有CALL和RETURN，因此一些状态机可以像其他状态机的子例程一样工作。

不寻常吗?是的。维护者是否需要学习一些知识?是的。这种学习有回报吗?我想是的。如果没有跳转到方块中的goto，游戏还能完成吗?不。

跳跃的例子在Java字符串类源代码:

int firstUpper;

/* Now check if there are any characters that need to be changed. */
scan: {
    for (firstUpper = 0 ; firstUpper < count; ) {
         char c = value[offset+firstUpper];
         if ((c >= Character.MIN_HIGH_SURROGATE) &&
                 (c <= Character.MAX_HIGH_SURROGATE)) {
             int supplChar = codePointAt(firstUpper);
             if (supplChar != Character.toLowerCase(supplChar)) {
                  break scan;
             }
             firstUpper += Character.charCount(supplChar);
         } else {
             if (c != Character.toLowerCase(c)) {
                  break scan;
             }
             firstUpper++;
         }
     }
     return this;
}
[... subsequent use of firstUpper ...]

这可以用很少的开销重写，例如:

 int firstUpper = indexOfFirstUpper();
 if (firstUpper < 0) return this; 

即使在现代语言中，即使我实际上不喜欢使用gotos，但我认为它们在许多情况下是可以接受的，在像这样的低级情况下，我看起来更好(它不仅仅是退出循环)。

没有激起宗教战争的意图。

我的一个同事说，使用GOTO的唯一原因是，如果你把自己逼到了绝境，这是唯一的出路。换句话说，提前进行适当的设计，以后就不需要使用GOTO了。

我认为这幅漫画很好地说明了“我可以重构程序的流程，或者用一个小的‘GOTO’来代替。”当你的设计不完善时，GOTO是一种不完善的方法。迅猛龙捕食弱者。

后藤认为他很有帮助。

我从1975年开始编程。对于20世纪70年代的程序员来说，“goto被认为是有害的”这个词或多或少地表明，具有现代控制结构的新编程语言值得一试。我们确实尝试了新的语言。我们很快就皈依了。我们再也没有回去过。

我们再也没有回去过，但是，如果你更年轻，那么你就从来没有去过那里。

现在，拥有古老编程语言的背景可能并没有太大用处，除非它能显示程序员的年龄。尽管如此，年轻的程序员缺乏这方面的背景，所以他们不再理解口号“goto被认为是有害的”在引入时向目标受众传达的信息。

一个人不理解的口号是不太有启发性的。也许最好忘记这些口号。这样的口号无济于事。

然而，这个特别的口号，“后藤有害”，已经有了它自己的不死生命。

能去不被虐待吗?回答:当然，但那又怎样?实际上，每一个编程元素都可能被滥用。例如，普通bool被滥用的次数比我们中的一些人愿意相信的要多。

相比之下，自1990年以来，我不记得遇到过一次真正的goto滥用案例。

goto最大的问题可能不是技术问题，而是社交问题。不太懂的程序员有时似乎觉得不赞成goto会让他们听起来很聪明。您可能需要不时地满足这样的程序员。生活就是这样。

今天goto最糟糕的事情是它没有被充分使用。