当然，可以使用GOTO，但是有一件事比代码风格更重要，或者在使用它时，您必须考虑到代码是否可读:其中的代码可能不像您想象的那样健壮。

例如，看看下面的两个代码片段:

If A <> 0 Then A = 0 EndIf
Write("Value of A:" + A)

GOTO的等效代码

If A == 0 Then GOTO FINAL EndIf
   A = 0
FINAL:
Write("Value of A:" + A)

我们首先想到的是这两段代码的结果将是“Value of A: 0”(当然，我们假设执行没有并行性)

这是不正确的:在第一个示例中，A将始终为0，但在第二个示例中(使用GOTO语句)A可能不是0。为什么?

原因是，从程序的另一点，我可以插入一个GOTO FINAL而不控制a的值。

这个例子非常明显，但是随着程序变得越来越复杂，看到这些东西的难度也增加了。

相关材料可以在Dijkstra先生的著名文章“反对GO TO声明的案例”中找到

它有时在按字符进行字符串处理时很方便。

想象一下这样一个printf式的例子:

for cur_char, next_char in sliding_window(input_string) {
    if cur_char == '%' {
        if next_char == '%' {
            cur_char_index += 1
            goto handle_literal
        }
        # Some additional logic
        if chars_should_be_handled_literally() {
            goto handle_literal
        }
        # Handle the format
    }
    # some other control characters
    else {
      handle_literal:
        # Complicated logic here
        # Maybe it's writing to an array for some OpenGL calls later or something,
        # all while modifying a bunch of local variables declared outside the loop
    }
}

您可以将goto handle_literal重构为一个函数调用，但如果它修改了几个不同的局部变量，则必须将引用传递给每个局部变量，除非您的语言支持可变闭包。如果您的逻辑使else case不起作用，那么您仍然必须在调用之后使用continue语句(可以说是goto的一种形式)以获得相同的语义。

我还在lexer中明智地使用了gotos，通常用于类似的情况。大多数时候你不需要它们，但在一些奇怪的情况下有它们很好。

在c#中，switch语句不允许切换。因此，goto用于将控制转移到特定的开关箱标签或默认标签。

例如:

switch(value)
{
  case 0:
    Console.WriteLine("In case 0");
    goto case 1;
  case 1:
    Console.WriteLine("In case 1");
    goto case 2;
  case 2:
    Console.WriteLine("In case 2");
    goto default;
  default:
    Console.WriteLine("In default");
    break;
}

编辑:有一个例外的“不掉落”规则。如果case语句没有代码，则允许延迟执行。

看看在C语言中编程时何时使用Goto:

Although the use of goto is almost always bad programming practice (surely you can find a better way of doing XYZ), there are times when it really isn't a bad choice. Some might even argue that, when it is useful, it's the best choice. Most of what I have to say about goto really only applies to C. If you're using C++, there's no sound reason to use goto in place of exceptions. In C, however, you don't have the power of an exception handling mechanism, so if you want to separate out error handling from the rest of your program logic, and you want to avoid rewriting clean up code multiple times throughout your code, then goto can be a good choice.

我是什么意思?你可能会有这样的代码:

int big_function()
{
    /* do some work */
    if([error])
    {
        /* clean up*/
        return [error];
    }
    /* do some more work */
    if([error])
    {
        /* clean up*/
        return [error];
    }
    /* do some more work */
    if([error])
    {
        /* clean up*/
        return [error];
    }
    /* do some more work */
    if([error])
    {
        /* clean up*/
        return [error];
    }
    /* clean up*/
    return [success];
}

This is fine until you realize that you need to change your cleanup code. Then you have to go through and make 4 changes. Now, you might decide that you can just encapsulate all of the cleanup into a single function; that's not a bad idea. But it does mean that you'll need to be careful with pointers -- if you plan to free a pointer in your cleanup function, there's no way to set it to then point to NULL unless you pass in a pointer to a pointer. In a lot of cases, you won't be using that pointer again anyway, so that may not be a major concern. On the other hand, if you add in a new pointer, file handle, or other thing that needs cleanup, then you'll need to change your cleanup function again; and then you'll need to change the arguments to that function.

通过使用goto，它将是

int big_function()
{
    int ret_val = [success];
    /* do some work */
    if([error])
    {
        ret_val = [error];
        goto end;
    }
    /* do some more work */
    if([error])
    {
        ret_val = [error];
        goto end;
    }
    /* do some more work */
    if([error])
    {
        ret_val = [error];
        goto end;
    }
    /* do some more work */
    if([error])
    {
        ret_val = [error];
        goto end;
    }
end:
    /* clean up*/
    return ret_val;
}

这样做的好处是，您的代码可以访问执行清理所需的所有内容，并且您已经成功地减少了更改点的数量。另一个好处是你的函数从多个出口点变成了只有一个;不可能不小心从函数返回而不进行清理。

此外，由于goto仅用于跳转到单个点，因此并不是为了模拟函数调用而创建大量来回跳转的意大利面代码。相反，goto实际上有助于编写更结构化的代码。

总而言之，goto应该谨慎使用，并作为最后的手段——但它是有时间和地点的。问题不应该是“你是否必须使用它”，而应该是“它是使用它的最佳选择”。

goto不好的一个原因是，除了编码风格之外，你可以用它来创建重叠但非嵌套的循环:

loop1:
  a
loop2:
  b
  if(cond1) goto loop1
  c
  if(cond2) goto loop2

这将创建一个奇怪的，但可能是合法的流控制结构，其中可能有(a, b, c, b, a, b, a, b, b，…)这样的序列，这让编译器黑客不高兴。显然，有许多聪明的优化技巧依赖于这种类型的结构不发生。(我应该检查一下我的龙书……)这样做的结果(使用一些编译器)可能是对包含gotos的代码没有进行其他优化。

如果你知道它只是“哦，顺便说一下”，恰好说服编译器发出更快的代码，那么它可能会很有用。就我个人而言，我更喜欢在使用像goto这样的技巧之前尝试向编译器解释什么是可能的，什么是不可能的，但可以说，我也可能在破解汇编程序之前尝试goto。

在Perl模块中，有时希望动态地创建子例程或闭包。问题是，一旦你创建了子例程，你如何得到它。你可以直接调用它，但是如果子例程使用caller()，那么它就没有那么有用了。这就是goto &子例程变化可能有用的地方。

这里有一个简单的例子:

sub AUTOLOAD{
  my($self) = @_;
  my $name = $AUTOLOAD;
  $name =~ s/.*:://;

  *{$name} = my($sub) = sub{
    # the body of the closure
  }

  goto $sub;

  # nothing after the goto will ever be executed.
}

您还可以使用这种形式的goto来提供尾部调用优化的基本形式。

sub factorial($){
  my($n,$tally) = (@_,1);

  return $tally if $n <= 1;

  $tally *= $n--;
  @_ = ($n,$tally);
  goto &factorial;
}

(在Perl 5 version 16中，最好写成goto __SUB__;)

有一个模块会导入尾修饰符，如果你不喜欢使用这种形式的goto，还有一个模块会导入递归。

use Sub::Call::Tail;
sub AUTOLOAD {
  ...
  tail &$sub( @_ );
}

use Sub::Call::Recur;
sub factorial($){
  my($n,$tally) = (@_,1);

  return $tally if $n <= 1;
  recur( $n-1, $tally * $n );
}

使用goto的大多数其他原因都可以用其他关键字更好地完成。

比如重写一段代码:

LABEL: ;
...
goto LABEL if $x;

{
  ...
  redo if $x;
}

或者从多个地方找到最后一段代码:

goto LABEL if $x;
...
goto LABEL if $y;
...
LABEL: ;

{
  last if $x;
  ...
  last if $y
  ...
}