Julia Control Flow

Control flow statements are implemented by setting one or more condition statements in a program. When the condition is true, the specified program code is executed; when the condition is false, other specified code is executed.

Julia provides a large number of control flow statements:

• Compound expressions：beginand;。

• Conditional expressions:if-elseif-elseand?:(ternary operator).

• Short-circuit evaluation:logical operators&&(and) and||(or), as well as chained comparisons.

• Loop statements:loops:whileandfor。

• Exception handling:try-catch、errorandthrow。

• Task (coroutine):yieldto。

Compound Expressions

begin ... endAn expression can sequentially evaluate several subexpressions and return the value of the last subexpression:

Because these are very short expressions, they can simply be placed on one line, which is the origin of the;chain:

In actual use, it is not required that the begin block be multi-line, or that the ; chain be single-line:

Conditional Expressions

A conditional expression can decide which block of code to execute based on the value of a Boolean expression.

if-elseif-else syntax:

Anifstatement can be followed by an optionalelse if...elsestatement, which can be used to test multiple conditions.

When using if...else if...else statements, the following points need to be noted:

• An if can be followed by zero or one else, and the else must come after all else ifs.
• An if can be followed by zero or more else ifs, and the else ifs must come before the else.
• Once an else if matches successfully, the other else ifs or else will not be tested.

Below is an analysis of the if-elseif-else conditional syntax:

If the expression x < y is true, the corresponding code block is executed; otherwise, the conditional expression x > y is evaluated. If it is true, the corresponding code block is executed; if no expression is true, the else code block is executed.

Ternary Operator

The ternary operator?:is similar to if-elseif-else syntax:

In?The previous expression a is a conditional expression. If condition a is true, the ternary operator evaluates expression b before the :; if condition a is false, it executes expression c after the :.

Note:?and:Spaces around are mandatory. An expression like a?b:c is not a valid ternary expression (but line breaks after ? and : are allowed).

If the expression x < y is true, the entire ternary operator executes the string "less than"; otherwise, it executes the string "not less than".

Chaining and nesting ternary operators:

To facilitate chained value passing, operators are connected from right to left.

Similar to if-elseif-else, the expressions before and after:are executed accordingly only when the conditional expression is true or false:

Short-Circuit Evaluation

In Julia, the&&and||operators correspond to logical"and"and"or"operations.

• In the expressiona && b, the subexpressionbis executed only whenaistrue; if a is false, false is returned directly.
• In the expressiona || b, the subexpressionbis executed only whenaisfalse; if a is true, a is returned directly.

Both && and || depend on the right side, but && has a higher precedence than ||. See the example:

Loop Statements

Loop statements usewhileandfortwo keywords to implement.

Below is an example of awhileloop:

The while loop evaluates the conditional expression (i <= 5). As long as it is true, it keeps executing the body of the while loop. When the conditional expression is false, that is, when i = 6, the loop ends.

The for loop is more convenient to use. The above example implemented with a for loop is as follows:

Here,1:5is a range object representing the sequence of numbers 1, 2, 3, 4, 5.

The for loop iterates over these values, assigning each variable i.

A very important difference between the for loop and the previous while loop is scope, that is, the visibility of variables. If variable i has not been introduced in another scope, inside the for loop it is only visible within the for loop, and is not visible outside or after it. You need a new interactive session instance or a new variable name to test this feature:

In general, for loop components can be used to iterate over any container. In this case, compared to =, the other (but completely identical) keywordinor∈is more commonly used because it makes the code clearer:

For convenience, we may terminate a while loop before the test condition becomes false, or stop a for loop before reaching the end of the iterated object. This can be done with the keywordbreak:

Without the break keyword, the while loop above would never end by itself, and the for loop would iterate up to 1000. These loops can all use break to terminate early.

In some scenarios, it is necessary to end the current iteration directly and immediately move to the next iteration. Thecontinuekeyword can be used to accomplish this:

This is a somewhat contrived example, because we could achieve the same functionality more concisely by negating the condition and placing the println call inside an if block. In practical applications, there is more code to run after continue, and there may be multiple places where continue is called.

Multiple nested for loops can be merged into one outer loop, which can be used to create the Cartesian product of their iterated objects:

With this syntax, iteration variables can still be used normally with loop variables for indexing. For example,for i = 1:n, j = 1:iis legal, but using a break statement inside one loop will break out of the entire nested loop, not just the inner loop. Each time the inner loop runs, the variables (i and j) are assigned their current iteration values. So assignments to i are not visible to subsequent iterations:

If this example is rewritten using a for keyword for each variable, the output will be different: the second and fourth variables contain 0.

You can use zip to iterate over multiple containers simultaneously in a single for loop:

Using zip creates an iterator that is a tuple of sub-iterators for the containers passed to it. The zip iterator iterates over all sub-iterators in order, selecting the ii-th element of each sub-iterator on the ii-th iteration of the for loop. As soon as any sub-iterator is exhausted, the for loop stops.

for statements can nest multiple loop conditions, using commas,to separate:

Comprehensions

The format is as follows:

We can also specify the type of elements we want to generate:

Traversing Arrays

Sometimes we want to iterate over each element of an array, including the index number of the element.

Julia provides theenumerate(iter)function; the parameteriteris an iterable object. This function will generate the index numbers as well as the value corresponding to each index.

Exception Handling

During program execution, if an unexpected condition occurs, a function may be unable to return a reasonable value to its caller. In such cases, it is best to let the unexpected condition terminate the program and print debug error information, which makes it easier for developers to handle their code.

Through thetry / catchstatement, exceptions can be handled conveniently.

For example, in the code below, the square root function sqrt raises an exception. Through try / catch, we can accurately output the exception information.

finally Clause

When programming with state changes or using resources such as files, it is often necessary to perform cleanup work (such as closing files) when the code ends. Because exceptions can cause some code blocks to exit before normal completion, this can complicate the above work. The finally keyword provides a way to run a certain piece of code when a code block exits, regardless of how it exits.

Here is an example that ensures an opened file is closed:

When control flow leaves the try block (for example, when return is encountered, or when it ends normally), close(f) will be executed. If the try block exits due to an exception, the exception continues to propagate. The catch block can be used together with try and finally. In this case, the finally block runs after catch handles the error.

throw Function

We can use throw to explicitly create exceptions.

For example, if a function is only defined for non-negative numbers, you can use throw to raise a DomainError when the input parameter is negative.

Note that DomainError without parentheses is not an exception, but an exception type. We need to call it to obtain an Exception object:

In addition, some exception types accept one or more arguments for error reporting:

We can easily implement this mechanism with a custom exception type, following the pattern of UndefVarError:

Task (Coroutine)

Task (coroutine) provides non-local flow control, which makes it possible to switch between temporarily suspended computational tasks. We will cover this in detail in the later chapter on asynchronous programming.