PC SOFT

ONLINE HELP
 WINDEVWEBDEV AND WINDEV MOBILE

Home | Sign in | English EN
New WINDEV 26 feature!
  • In this lesson you will learn the following concepts
  • Overview
  • Practical example
  • The FOR statement
  • The LOOP statement
  • The WHILE statement
  • Conclusion
Lesson 2.5. Loops
In this lesson you will learn the following concepts
  • The FOR statement.
  • The LOOP statement.
  • The WHILE statement.
Lesson duration

Estimated time: 15 mn
Previous LessonTable of contentsNext Lesson
Overview
Loop statements make it possible to execute a process multiple times. A specific loop statement is used according to the number of iterations. Several statements can be used for loops:
  • FOR...
  • LOOP...
  • WHILE...

Practical example

To complete the exercises in this lesson, we will work on the "WLanguage" project that we used in the previous lesson. The principle remains the same: the example code will be entered directly in the "Initializing" event of the project.

  • To view WLanguage events of the project:
    1. Right-click the "P" button next to the open element tabs. The context menu appears.
    2. Select "Element code".
    3. The code editor displays the different events associated with the project.
The FOR statement
The FOR statement is used when the number of iterations is known. This statement uses a variable to control the iterations of a loop.
The syntax of the FOR statement is as follows:
FOR Index = Start value TO End value
Process to run
END

  • To try this statement, we will enter a WLanguage code to fill an array of integers with even numbers between 1 and 10. We will then list the contents of the array. We will write this code in several steps.
    1. If necessary, clear the "Initializing" event of the project.
    2. First of all, we will fill an array of integers with values from 1 to 10. Copy the following code:
      garrNumbers is array of int
       
      FOR nIndex = 1 TO 10
      // Display the index
      Trace("Loop | Index value: [%nIndex%]")
      garrNumbers.Add(nIndex)
      Trace("[%nIndex%] was added to the array")
      END
      This code executes the process 10 times and at each pass through the loop, the value of the index is stored in an array via the <Array>.Add function.
    3. Let's test this code : click Test project in the quick access buttons.
    4. If necessary, open the "Debugger trace" pane to see the result: On the "Home" tab, in the "Environment" group, expand "Panes" and select "Debugger trace".
    5. The "Debugger trace" pane will contain the messages of the execution of the loop and the addition of the numbers in the array for the 10 indices.
      Loop | Index value: 1
      1 was added to the array
      Loop | Index value: 2
      2 was added to the array
      Loop | Index value: 3
      3 was added to the array
      Loop | Index value: 4
      4 was added to the array
      Loop | Index value: 5
      5 was added to the array
      Loop | Index value: 6
      6 was added to the array
      Loop | Index value: 7
      7 was added to the array
      Loop | Index value: 8
      8 was added to the array
      Loop | Index value: 9
      9 was added to the array
      Loop | Index value: 10
      10 was added to the array
  • We will modify this code to exit the loop if the index is 5. In this case, we will check the value of the index and if it is 5, we can simply use the BREAK keyword to terminate the loop.
    1. The code becomes:

      garrNumbers is array of int
       
      FOR nIndex = 1 TO 10
      // Display the index
      Trace("Loop | Index value: [%nIndex%]")
       
      IF nIndex = 5 THEN
      Trace("Break condition")
      BREAK
      END
      garrNumbers.Add(nIndex)
      Trace("[%nIndex%] was added to the array")
      END
    2. Let's test this code : click Test project in the quick access buttons.
    3. The "Debugger trace" pane will contain the messages of the execution of the loop and the addition of the numbers in the array for the first 5 indices.
      Loop | Index value: 1
      1 was added to the array
      Loop | Index value: 2
      2 was added to the array
      Loop | Index value: 3
      3 was added to the array
      Loop | Index value: 4
      4 was added to the array
      Loop | Index value: 5
      Break condition
  • Now, we will modify this code to add only even indices to the array. If the index is odd, the loop must skip on to the next iteration without adding a value to the array. We will use the CONTINUE keyword.
    1. The code becomes:
      garrNumbers is array of int
       
      FOR nIndex = 1 TO 10
       
      Trace("Loop | Index value: [%nIndex%]")
       
      IF nIndex = 5 THEN
      Trace("Break condition")
      BREAK
      END
       
      IF IsOdd(nIndex) = True THEN
      Trace("Odd index: go to next iteration")
      CONTINUE
      END
      garrNumbers.Add(nIndex)
      Trace("[%nIndex%] was added to the array")
      END
    2. Let's test this code : click Test project in the quick access buttons.
    3. The "Debugger trace" pane will contain the messages of the execution of the loop for the first 5 indices. For the odd numbers, a message indicates that the code is not executed. The addition message will only be displayed for the even numbers.
      Loop | Index value: 1
      Odd index: go to next iteration
      Loop | Index value: 2
      2 was added to the array
      Loop | Index value: 3
      Odd index: go to next iteration
      Loop | Index value: 4
      4 was added to the array
      Loop | Index value: 5
      Break condition
  • Now we will add the code to loop through the array in order to list the indices that have been added. We will use a FOR loop. The beginning and the end of the loop will be:
    • the first element of the array. This element corresponds to 1 (seen in lesson 2.3),
    • the last element of the array. Since we don't know it, we will use the Count property. This property returns the number of elements in the array (and thus the index of the last element).
    1. Add the following code:
      FOR nIndex = 1 TO garrNumbers.Count
      // Display the index and the corresponding value in the array
      Trace("Index: " + nIndex + " | Value: " + garrNumbers[nIndex])
      END
    2. This code can be optimized. With this syntax, the number of elements in the array is re-evaluated at each execution of the loop. If the number of elements in the array changes (e.g. some elements are deleted), the final value of the control variable will be adjusted. In our example, the array is not modified during the loop: it is possible to use the _TO_ keyword which avoids having to recalculate the number of iterations at each loop. The code becomes:
      FOR nIndex = 1 _TO_ garrNumbers.Count
      // Display the index and the corresponding value in the array
      Trace("Index: " + nIndex + " | Value: " + garrNumbers[nIndex])
      END
    3. Let's test this code : click Test project in the quick access buttons.
    4. The "Debugger trace" pane will contain the messages displayed for the first 5 indices. For the odd numbers, a message indicates that the code is not executed. The contents of the array are then listed.
      Loop | Index value: 1
      Odd index: go to next iteration
      Loop | Index value: 2
      2 was added to the array
      Loop | Index value: 3
      Odd index: go to next iteration
      Loop | Index value: 4
      4 was added to the array
      Loop | Index value: 5
      Break condition
      Index: 1 | Value: 2
      Index: 2 | Value: 4
Remark: You can define the step (index increment) value using the STEP keyword. For example, the following code runs the process 2000 times and the nIndex variable decreases by 10:
// FOR loop from 2000 to 1, in steps of 10
FOR nIndex = 2000 TO 1 STEP -10
// Display the index
Trace(nIndex)
END
For more details, see FOR statement.
The LOOP statement
The LOOP statement is used when the number of iterations is unknown. In this case, a condition must be evaluated to exit the loop.
The syntax of the LOOP statement is as follows:
LOOP
Process to run
IF <Condition to evaluate> THEN BREAK
END


  • We will write some WLanguage code to try this statement:
    1. If necessary, clear the "Initializing" event of the project and copy the following code.
      This code subtracts 1 from an integer until the value is zero:
      gnCounter is int
      gnCounter = 10
      LOOP
      Trace("Loop | Value: [%gnCounter%]")
      gnCounter--
      IF gnCounter = 0 THEN BREAK
      END
      Trace("End of loop")
    2. Let's test this code : click Test project in the quick access buttons.
    3. The "Debugger trace" pane contains the message displayed for the 10 executions of the loop.
      Loop | Value: 10
      Loop | Value: 9
      Loop | Value: 8
      Loop | Value: 7
      Loop | Value: 6
      Loop | Value: 5
      Loop | Value: 4
      Loop | Value: 3
      Loop | Value: 2
      Loop | Value: 1
      End of loop
  • The WHILE keyword can also be used in loops. In this case, the syntax of the LOOP statement is as follows:
    gnCounter = 10
    LOOP
    Trace("Loop | Value: [%gnCounter%]")
    gnCounter = gnCounter - 1
    DO WHILE gnCounter > 0
    Trace("End of loop")

Tip

The LOOP statement and the FOR statement can have the same behavior: all you have to do is use the syntax with exit according to the number of iterations:
LOOP (<Number of iterations>)
...
END
In our example, the code can become:
gnCounter is int
gnCounter = 10
LOOP(10)
Trace("Loop | Value: [%gnCounter%]")
gnCounter --
END
Trace("End of loop")
For more details, see LOOP statement.
The WHILE statement
The WHILE and LOOP statements follow the same principle. The difference is that the break condition is evaluated BEFORE the loop code is executed. This evaluation compares a variable to a given value. This variable starts at a starting value and is modified in the loop until it reaches the exit-condition.
The syntax of the WHILE statement is as follows:
<Initialize the variable to its start value>
WHILE <Compare the variable to its end value>
Process to run
<Modify the variable>
END

  • We will write some WLanguage code to try this statement:
    1. If necessary, clear the "Initializing" event of the project and copy the following code.
      This code adds 1 to an integer as long as the integer is less than 10.
      gnCounter is int = 1
      WHILE gnCounter <= 10
      Trace("Loop | Value: [%gnCounter%]")
      // Process to run
      gnCounter ++
      END
      Trace("End of loop")
    2. Let's test this code : click Test project in the quick access buttons.
    3. The "Debugger trace" pane contains the message displayed for the 10 executions of the loop.
      Loop | Value: 1
      Loop | Value: 2
      Loop | Value: 3
      Loop | Value: 4
      Loop | Value: 5
      Loop | Value: 6
      Loop | Value: 7
      Loop | Value: 8
      Loop | Value: 9
      Loop | Value: 10
      End of loop
For more details, see WHILE statement.
Conclusion
In this lesson, you have discovered some of the conditional statements available in WLanguage:
  • The FOR statement.
  • The LOOP statement.
  • The WHILE statement.
In the next lesson, we will see how to create and use WLanguage procedures.
Previous LessonTable of contentsNext Lesson
Minimum version required
  • Version 26
Comments
Click [Add] to post a comment