Goto (command)
|
|
- This page is about the programming command. For information about the Japanese city, see Goto, Nagasaki.
GOTO is a command found in many programming languages which instructs the computer to jump to another point in the computer program, specified by a label or line number. It is the fundamental operation which can be used for transfer of control from one part of a program to another, and most compilers will translate other flow control statements into GOTOs.
GOTO is found in FORTRAN, Algol, COBOL, SNOBOL, BASIC, Common Lisp, C, C++, D, Pascal, Perl and many other languages, particularly assembly languages. In the assembly languages, the GOTO command is usually called BRA (from "branch"), JMP or JUMP, and is often the only way of organizing program flow. However GOTO is not found in all programming languages. In certain languages, such as Java, "goto" is a reserved word. In the parody programming language INTERCAL, COME FROM is used instead.
Unlike a function call, a GOTO does not demand any preparation or restructuring of the code. As a result, it becomes very easy to produce inconsistent, incomplete and generally unmaintainable spaghetti code. Consequently, as structured programming became more prominent in the 1960s and 1970s, numerous computer scientists came to the conclusion that programs should always use the structured flow commands (loops, if-then statements, etc.) in place of GOTO. However, others believed that even though the use of GOTO is often bad practice, there are some tasks that cannot be straightforwardly accomplished in many programming languages without the use of GOTO statements, such as exception handling.
Another criticism of using GOTO is that it can easily lead to an infinite loop. For example, the following code in BASIC will output an endless list of "Hello, world!".
10 PRINT "Hello, world!" 20 GOTO 10
One famous criticism of GOTO is a letter by Edsger Dijkstra called Go To Statement Considered Harmful. In that letter Dijkstra argued that unrestricted GOTO statements should be abolished from higher-level languages because they complicated the task of analyzing and verifying the correctness of programs (particularly those involving loops). Donald Knuth's Structured Programming with goto Statements considers some of the places where GOTO may be the appropriate tool. Generally these are in situations where a particular programming structure is not available. In these cases, GOTO can generally be used to emulate the desired structure, since it is one of the fundamental building blocks of programming. Another solution to this problem is writing the desired control structure as macro as one can do in almost all Lisp dialects.
There have been several variations on the GOTO statement. In BASIC, the ON GOTO statement selects from a list of different places to jump. It can be thought of as a primitive "switch" statement. The computed GOTO found in Fortran and some BASICs causes a jump to a line number computed by an arithmetic expression. Computed GOTO is often avoided even by programmers who use GOTO, since it makes code even more difficult to read: to determine even the possible destinations of the jump requires evaluating the arithmetic expression that controls it.
See also
- Jump instruction
- Control structure#Goto
- Structured programming
- Functional programming
- Navigational database
- Macro
References
- Dijkstra, Edsger (1968) Go To Statement Considered Harmful, Communications of the ACM 11(3):147-148
- Knuth, Donald (1974) Structured Programming with Goto Statements, Computing Surveys 6(4):261-301
External links
- Go To Statement Considered Harmful (http://www.acm.org/classics/oct95/)
- Structured Programming with goto Statements (http://pplab.snu.ac.kr/courses/adv_pl04/papers/p261-knuth.pdf)
- A Structured Discipline of Programming (http://www.geek-central.gen.nz/peeves/programming_discipline.html)