Flujo de control

A jump command unconditionally branches control to another point in the code, and is the most basic form of controlling the flow of code.

In a high-level language, this is often provided as a goto statement. Although the keyword may be upper or lower case or one or two words depending on the language, it is like: goto label. When control reaches a goto statement, control then jumps to the statement that follows the indicated label. The goto statement has been considered harmful by many computer scientists, including Dijkstra.

A conditional statement jumps control based on the value of a Boolean expression. Common variations include:

if-goto

Jumps to a label based on a condition; a high-level programming statement that closely mimics a similar used machine code instruction

if-then

Rather than being restricted to a jump, a statement or block is executed if the expression is true. In a language that does not include the then keyword, this can be called an if statement.

if-then-else

Like if-then, but with a second action to be performed if the condition is false. In a language that does not include the then keyword, this can be called an if-else statement.

Nested

Conditional statements are often nested inside other conditional statements.

Arithmetic if

Early Fortran, had an arithmetic if (a.k.a. three-way if) that tests whether a numeric value is negative, zero, or positive. This statement was deemed obsolete in Fortran-90, and deleted as of Fortran 2018.

Operator

Some languages have an operator form, such as the ternary conditional operator.

When and unless

Perl supplements a C-style if with when and unless.

Messages

Smalltalk uses ifTrue and ifFalse messages to implement conditionals, rather than a language construct.

The following Pascal code shows a simple if-then-else. The syntax is similar in Ada:

ifa>0thenwriteln("yes")elsewriteln("no");

In C:

if(a>0){puts("yes");}else{puts("no");}

In bash:

if[$a-gt0];thenecho"yes"elseecho"no"fi

In Python:

ifa>0:print("yes")else:print("no")

In Lisp:

(princ(if(pluspa)"yes""no"))

A multiway branch jumps control based on matching values. There is usually a provision for a default action if no match is found. A switch statement can allow compiler optimizations, such as lookup tables. In dynamic languages, the cases may not be limited to constant expressions, and might extend to pattern matching, as in the shell script example on the right, where the *) implements the default case as a glob matching any string. Case logic can also be implemented in functional form, as in SQL's decode statement.

The following Pascal code shows a relatively simple switch statement. Pascal uses the case keyword instead of switch.

casesomeCharof'a':actionOnA;'x':actionOnX;'y','z':actionOnYandZ;elseactionOnNoMatch;end;

In Ada:

casesomeChariswhen'a'=>actionOnA;when'x'=>actionOnX;when'y'|'z'=>actionOnYandZ;whenothers=>actionOnNoMatch;end;

In C:

switch(someChar){case'a':actionOnA;break;case'x':actionOnX;break;case'y':case'z':actionOnYandZ;break;default:actionOnNoMatch;}

In Bash:

case$someCharina)actionOnA;;x)actionOnX;;[yz])actionOnYandZ;;*)actionOnNoMatch;;esac

In Lisp:

(casesome-char((#\a)action-on-a)((#\x)action-on-x)((#\y#\z)action-on-y-and-z)(elseaction-on-no-match))

In Fortran:

select case(someChar)case('a')actionOnAcase('x')actionOnXcase('y','z')actionOnYandZcase defaultactionOnNoMatchend select

A relatively simple yet useful loop iterates over a range of numeric values. A simple form starts at an integer value, ends at a larger integer value and iterates for each integer value between. Often, the increment can be any integer value (even negative, to loop from a larger to a smaller value).

Example in BASIC:

FORI=1TONxxxNEXTI

Example in Pascal:

forI:=1toNdobeginxxxend;

Example in Fortran:

DO I=1,NxxxEND DO

In many programming languages, only integers can be used at all or reliably. As a floating-point number is represented imprecisely due to hardware constraints, the following loop might iterate 9 or 10 times, depending on various factors such as rounding error, hardware, compiler. Furthermore, if the increment of X occurs by repeated addition, accumulated rounding errors may mean that the value of X in each iteration can differ quite significantly from the commonly expected sequence of 0.1, 0.2, 0.3, ..., 1.0.

for X := 0.1 step 0.1 to 1.0 do

Some loop constructs iterate until a condition is true. Some variations test the condition at the start of the loop; others test at the end. If the test is at the start, the body may be skipped completely. At the end, the body is always executed at least once.

Example in Visual Basic:

DOWHILE(test)xxxLOOP

Example in Pascal:

repeatxxxuntiltest;

Example in C family of pre-test:

while(test){xxx}

Example in C family of post-test:

doxxxwhile(test);

Although using the for keyword, the three-part C-style loop is a condition-based construct, not a numeric-based one. The second part, the condition, is evaluated before each loop, so the loop is pre-test. The first part is a place to initialize state, and the third part is for incrementing for the next iteration, but both aspects can be performed elsewhere. The following C code implements the logic of a numeric loop that iterates for i from 0 to n-1.

for(inti=0;i<n;++i){xxx}

Some loop constructs enumerate the items of a collection; iterating for each item.

Example in Smalltalk:

someCollectiondo: [:eachElement|xxx].

Example in Pascal:

forIteminCollectiondobeginxxxend;

Example in Raku:

foreach (item; myCollection) { xxx } 

Example in TCL:

foreachsomeArray{xxx}

Example in PHP:

foreach($someArrayas$k=>$v){xxx}

Example in Java:

Collection<String>coll;for(Strings:coll){}

Example in C#:

foreach(stringsinmyStringCollection){xxx}

Example in PowerShell where 'foreach' is an alias of 'ForEach-Object':

someCollection|foreach{$_}

Example in Fortran:

forall(index=first:last:step...)

Scala has for-expressions, which generalise collection-controlled loops, and also support other uses, such as asynchronous programming. Haskell has do-expressions and comprehensions, which together provide similar function to for-expressions in Scala.

Common loop structures sometimes result in duplicated code, either repeated statements or repeated conditions. This arises for various reasons and has various proposed solutions to eliminate or minimize code duplication.^[11] Other than the traditional unstructured solution of a goto statement,^[12] general structured solutions include having a conditional (if statement) inside the loop (possibly duplicating the condition but not the statements) or wrapping repeated logic in a function (so there is a duplicated function call, but the statements are not duplicated).^[11]

A common case is where the start of the loop is always executed, but the end may be skipped on the last iteration.^[12] This was dubbed by Dijkstra a loop which is performed "n and a half times",^[13] and is now called the loop-and-a-half problem.^[8] Common cases include reading data in the first part, checking for end of data, and then processing the data in the second part; or processing, checking for end, and then preparing for the next iteration.^[12][8] In these cases, the first part of the loop is executed ⁠${\displaystyle n}$⁠ times, but the second part is only executed ⁠${\displaystyle n-1}$⁠ times.

This problem has been recognized at least since 1967 by Knuth, with Wirth suggesting solving it via early loop exit.^[14] Since the 1990s this has been the most commonly taught solution, using a break statement, as in:^[8]

loopstatementsifconditionbreakstatementsrepeat

A subtlety of this solution is that the condition is the opposite of a usual while condition: rewriting whilecondition ... repeat with an exit in the middle requires reversing the condition: loop ... if notconditionexit ... repeat. The loop with test in the middle control structure explicitly supports the loop-an-a-half use case, without reversing the condition.^[14]

Una estructura de bucle proporciona criterios de finalización estructurados que dan como resultado otra iteración o la continuación de la ejecución después de la instrucción del bucle. Sin embargo, muchos lenguajes admiten diversas estructuras de control de flujo no estructuradas.

Próxima iteración temprana

Algunos lenguajes proporcionan una construcción que salta el control al principio del cuerpo del bucle para la siguiente iteración; por ejemplo, continue(el más común), skip, ^{[ 15 ]}cycle (Fortran), o next(Perl y Ruby).

Rehacer iteración

Algunos lenguajes, como Perl ^{[ 16 ]} y Ruby, ^{[ 17 ]} tienen una redoinstrucción que salta al inicio del cuerpo para la misma iteración.

Reanudar

Ruby tiene una retryinstrucción que reinicia todo el bucle desde la primera iteración. ^{[ 18 ]}

bucle Obtener ( X ); si X = 0 entonces salir ; fin si ; HacerAlgo ( X ); fin bucle ;

bucle Obtener ( X ); salir cuando X = 0 ; HacerAlgo ( X ); fin del bucle ;

for n in set_of_numbers : if isprime ( n ): print ( "El conjunto contiene un número primo" ) break else : print ( "El conjunto no contenía ningún número primo" )

looploop xxx1 read(char); while test; whilenot atEndOfFile; xxx2 write(char); repeat; repeat;

mientras la instrucción-1 instrucción-2 ... condición hacer instrucción-a instrucción-b ... hecho

mientras se ejecutan los comandos de prueba ; hacer los comandos consecuentes ; hecho

mientras ( declaración_1 , declaración_2 , condición ) { declaración_a ; declaración_b ; }

while ( read_string ( s ), strlen ( s ) > 0 ) { // ... }

Las variantes e invariantes de bucle se utilizan para expresar la corrección de los bucles. ^{[ 36 ]}

En términos prácticos, una variante de bucle es una expresión entera con un valor inicial no negativo. El valor de la variante debe disminuir durante cada iteración del bucle, pero nunca debe volverse negativo durante su correcta ejecución. Las variantes de bucle se utilizan para garantizar que los bucles finalicen.

Un invariante de bucle es una aserción que debe ser verdadera antes de la primera iteración y permanecer verdadera después de cada iteración. Esto implica que, cuando un bucle finaliza correctamente, tanto la condición de salida como el invariante de bucle se cumplen. Los invariantes de bucle se utilizan para supervisar propiedades específicas de un bucle durante iteraciones sucesivas.

Algunos lenguajes de programación, como Eiffel, incluyen soporte nativo para variantes e invariantes de bucles. En otros casos, el soporte es un complemento, como la especificación del lenguaje de modelado de Java para las sentencias de bucle en Java .

Some Lisp dialects provide an extensive sublanguage for describing Loops. An early example can be found in Conversional Lisp of Interlisp. Common Lisp^[37] provides a Loop macro which implements such a sublanguage.

1. ^awhile (true) does not count as an infinite loop for this purpose, because it is not a dedicated language structure.
2. ^abcdefgh C's for (init; test; increment) loop is a general loop construct, not specifically a counting one, although it is often used for that.
3. ^abc Deep breaks may be accomplished in APL, C, C++ and C# through the use of labels and gotos.
4. ^a Iteration over objects was added in PHP 5.
5. ^abcdef A counting loop can be simulated by iterating over an incrementing list or generator, for instance, Python's range().
6. ^abcde Deep breaks may be accomplished through the use of exception handling.
7. ^a There is no special construct, since the while function can be used for this.
8. ^a There is no special construct, but users can define general loop functions.
9. ^a The C++11 standard introduced the range-based for. In the STL, there is a std::for_eachtemplate function which can iterate on STL containers and call a unary function for each element.^[38] The functionality also can be constructed as macro on these containers.^[39]
10. ^a Numeric looping is effected by iteration across an integer interval; early exit by including an additional condition for exit.
11. ^a Eiffel supports a reserved word retry, however it is used in exception handling, not loop control.
12. ^a Requires Java Modeling Language (JML) behavioral interface specification language.
13. ^a Requires loop variants to be integers; transfinite variants are not supported. Eiffel: Why loop variants are integers
14. ^a D supports infinite collections, and the ability to iterate over those collections. This does not require any special construct.
15. ^a Deep breaks can be achieved using GO TO and procedures.
16. ^a Common Lisp predates the concept of generic collection type.
17. ^ab Odin's general for loop supports syntax shortcuts for conditional loop and infinite loop.

The earliest Fortran compilers supported statements for handling exceptional conditions including IF ACCUMULATOR OVERFLOW, IF QUOTIENT OVERFLOW, and IF DIVIDE CHECK. In the interest of machine independence, they were not included in FORTRAN IV and the Fortran 66 Standard. However, since Fortran 2003 it is possible to test for numerical issues via calls to functions in the IEEE_EXCEPTIONS module.

PL/I has some 22 standard conditions (e.g., ZERODIVIDE SUBSCRIPTRANGE ENDFILE) which can be raised and which can be intercepted by: ON condition action; Programmers can also define and use their own named conditions.

Like the unstructured if, only one statement can be specified so in many cases a GOTO is needed to decide where flow of control should resume.

Unfortunately, some implementations had a substantial overhead in both space and time (especially SUBSCRIPTRANGE), so many programmers tried to avoid using conditions.

A typical example of syntax:

ONconditionGOTOlabel

Many modern languages natively support exception handling. Generally, exceptional control flow starts with an exception object being thrown (a.k.a. raised). Control then proceeds to the inner-most exception handler for the call stack. If the handler handles the exception, then flow control reverts to normal. Otherwise, control proceeds outward to containing handlers until one handles the exception or the program reaches the outermost scope and exits. As control flows to progressively outer handlers, aspects that would normally occur such as popping the call stack are handled automatically.

The following C++ code demonstrates structured exception handling. If an exception propagates from the execution of doSomething() and the exception object type matches one of the types specified in a catch clause, then that clause is executed. For example, if an exception of type SomeException is propagated by doSomething(), then control jumps from line 2 to 4 and the message "Caught SomeException" is printed and then control jumps to after the try statement, line 8. If an exception of any other type is propagated, then control jumps from line 2 to 6. If no exception, then control jumps from 2 to 8.

try{doSomething();}catch(constSomeException&e)std::println("Caught SomeException: {}",e.what());}catch(...){std::println("Unknown error");}doNextThing();

Many languages use the C++ keywords (throw, try and catch), but some languages use other keywords. For example, Ada uses exception to introduce an exception handler and when instead of catch. AppleScript incorporates placeholders in the syntax to extract information about the exception as shown in the following AppleScript code.

trysetmyNumbertomyNumber/0onerrorenumbernfromftotpartialresultprif(e="Can't divide by zero")thendisplay dialog"You must not do that"endtry

In many languages (including Object Pascal, D, Java, C#, and Python) a finally clause at the end of a try statement is executed at the end of the try statement, whether an exception propagates from the rest of the try or not. The following C# code ensures that the stream stream is closed.

FileStreamstream=null;try{stream=newFileStream("logfile.txt",FileMode.Create);returnProcessStuff(stream);}finally{if(stream!=null){stream.Close();}}

Since this pattern is common, C# provides the using statement to ensure cleanup. In the following code, even if ProcessStuff() propagates an exception, the stream object is released. Python's with statement and Ruby's block argument to File.open are used to similar effect.

using(FileStreamstream=new("logfile.txt",FileMode.Create)){returnProcessStuff(stream);}

Zahn's construct was proposed in 1974,^[48] and discussed in Knuth (1974). A modified version is presented here.

exitwhen EventA or EventB or EventC; xxx exits EventA: actionA EventB: actionB EventC: actionC endexit;

exitwhen is used to specify the events which may occur within xxx, their occurrence is indicated by using the name of the event as a statement. When some event does occur, the relevant action is carried out, and then control passes just after endexit. This construction provides a very clear separation between determining that some situation applies, and the action to be taken for that situation.

exitwhen is conceptually similar to exception handling, and exceptions or similar constructs are used for this purpose in many languages.

The following simple example involves searching a two-dimensional table for a particular item.

exitwhen found or missing; for I := 1 to N dofor J := 1 to M doif table[I,J] = target then found; missing; exits found: print ("item is in table"); missing: print ("item is not in table"); endexit;