Skip to content

Iterations

for

Description

The for loop allows the repetitive execution of a statement or a block of statements for a predefined number of times. This loop is most useful to

  • iterate through arrays or any other sequences of a fixed/known length
  • repeat the execution of a statement for as many times as you decide, beforehand.

You can opt for an early exit from a for, by using the break statement. As soon as the break statement is executed, the loop stops and the Application continues to the next statements.

You can ignore statements from a for loop's body, by using the continue statement. When the continue statement is encountered:

  • All next statements are ignored (in the loop's context)
  • The Application continues to the next loop (if exists)

Syntax

A for statement can be written as:

for(initialization; condition; iteration;){
    run_this;
}
//or without parentheses

for initialization; condition; iteration;{
    run_this;
}

initialization

The initialization section of the for loop defines a loop parameter and gives it an initial value, like so:

data_type identifier = initial_value; 

Warning

Note that the definition of the loop variable in the for loop means that the variable is accessible only by the loop's context. Other contexts, outside of the loop, cannot access it. Mamba does not allow the use of an external variable as a for iterator; only local iterators (thus, defined and initialized in the for statement) can be used.

Warning

Unlike other programming languages, the initialization part expects one, and only one, statement. So that the following will throw a Validation exception: for(int i = 0, y = 1; i < 5; i + 1, y + 2)

condition

The condition section is any boolean expression that is evaluated to determine whether the loop should be ran or not. If the condition expression is evaluated as true, the loop's statement will be executed until the next condition is evaluated again. Otherwise, the loop will finish and the Application will proceed to the next statement.

iteration

The iteration part defines what should happen every time that a loop finishes its execution.

Warning

Unlike other programming languages, the iteration part expects one, and only one, statement. So that the following will throw a Validation exception: for(int i = 0, y = 1; i < 5; i + 1, y + 2)

Example

//Simple loop, running for 4 (0-3) times
for int i = 0; i < 3; i + 1 {
    DebugLib.Logger.WriteInfoLine(i);
}

/*
Output:
    0
    1
    2
*/
//Loop with a "continue" statement
DebugLib.Logger.WriteInfoLine("The odd numbers in [0, 99] are: ");
for int i = 0; i < 100; i + 1 {
    if(i % 2 == 0){ //Do not output i if i is an even number
        continue;
    }
    //The next line will not be executed if the "continue" is executed
    DebugLib.Logger.WriteInfoLine(i);
}
/*
Output:
    The odd numbers in [0, 99] are: 
    1
    3
    5
    ...
    97
    99
*/
//Loop with a "continue" and "break" statement
DebugLib.Logger.WriteInfoLine("The odd numbers in [0, 10] are: ");
for int i = 0; i < 100; i + 1 {
    //Stop the loop when you reach to 10 (even though it would loop for 100 times)
    if(i > 10){
        break; 
    }

    //Do not output i if i is an even number. Will be ran only if the "break" never executed
    if(i % 2 == 0){ 
        continue;
    }

    //The next line will not be executed if the "continue" is executed
    DebugLib.Logger.WriteInfoLine(i);
}

/*
Output:
    The odd numbers in [0, 10] are: 
    1
    3
    5
    7
    9
*/

foreach

Description

The foreach loop is used when an iteration through a Collection or an Array is required. It allows a repetitive execution of a statement (or block of statements) for a X number of times, where X is the size of a Collection or an Array.

You can opt for an early exit from a for, by using the break statement. As soon as the break statement is executed, the loop stops and the Application continues to the next statements.

You can ignore statements from a for loop's body, by using the continue statement. When the continue statement is encountered:

  • All next statements are ignored (in the loop's context)
  • The Application continues to the next loop (if exists)

Syntax

A foreach statement can be written as:

foreach (iterator in collection){
    run_this;
}
//Alternatively, without parentheses
foreach iterator in collection{
    run_this;
}

collection

The collection section contains an identifier of an Array, Collection or Dictionary type. Basically, it represents a collection of similar (same type) objects.

iterator

The iterator section of the foreach loop defines the current object in the collection, as it is being traversed. You can either define it in a strict mode, for example:

foreach int i in collection{} //strongly typed 

foreach var item in collection{} //loosely typed, using variable
or omit it altogether, since Mamba knows exactly what the type is, from the collection used:
foreach item in collection{}

**Important: ** The iterator is accessible only by the foreach loop. Other scopes, external to the loop, cannot access it.

Example

Array[int] numbers = {1, 2, 3, 4, 5};
foreach number in numbers {  //Notice that we did not define the type of the number
    DebugLib.Logger.WriteInfoLine(number);
}
/*
Output:
    1
    2
    3
    4
    5
*/
Collection[string] strings;
strings.Add("A");
strings.Add("B");
strings.Add("C");

foreach string aString in strings { //More strict iterator definition
    DebugLib.Logger.WriteInfoLine(aString);
}
foreach user in Domain.ApplicationUser.GetAll() {
    //Do not iterate any further if you found a user with more than 3 failed logins
    if(user.AccessFailedCount > 3){
        break;
    }

    //Go to the next user if his E-Mail has been confirmed
    if(user.EmailConfirmed){
        continue;
    }

    user.ConfirmEmail();
}

Caution

Be very careful when you alter the collection you are iterating through. This might cause unexpected behavior and application errors. Example: imagine you have a collection of 10 numbers. While iterating through that, using the foreach loop, you delete the current item. The next time that the next item will be fetched, the collection will be changed, having 9 items. That will confuse the processor and might result into Exceptions

while

Description

The while statement runs a statement (or a block of statements) until the specified condition is evaluated as false (or a break statement is executed).

You can opt for an early exit from a for, by using the break statement. As soon as the break statement is executed, the loop stops and the Application continues to the next statements.

You can ignore statements from a for loop's body, by using the continue statement. When the continue statement is encountered:

Syntax

A while statement can be written as:

while (condition){
    execute_this;
}

//alternatively, without parentheses

while condition{
    execute_this;
}

Example

//A never ending loop, running till the end of time
while (true) {
    DebugLib.Logger.Write("Never ending loop.");
}
int i = 0;
while(i < 5){
    DebugLib.Logger.WriteInfoLine(i);
    i = i + 1;
}
/*
Output:
    0
    1
    2
    3
    4
*/
int i = 0;
while(i < 1000){
    //Stop at 10, even though the loop iterates for 1000 times
    if(i >= 10){
        break;
    }

    //Do nothing if the number is even
    if(i % 2 == 0){
        i = i + 1;
        continue;
    }

    DebugLib.Logger.WriteInfoLine(i);
    i = i + 1;
}

/*
Output:
    1
    3
    5
    7
    9
*/