do while and foreach loops

do loop . . while

do...while loop in C# this is a version of while with a post-condition check. This means that the loop condition is checked after the loop body is executed. Therefore, do...while loops are useful in situations where a block of statements must be executed at least once. The following is the general form of a do-while loop statement:

do (operators; ) while (condition);

If there is only one operator, curly braces in this form of notation are optional. However, they are often used to make the do-while construct more readable and not to be confused with the while loop construct. The do-while loop runs as long as the conditional expression is true. An example of using a do-while loop is the following program, which calculates the factorial of a number:

Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( try ( // Calculate the factorial of a number int i, result = 1, num = 1; Console.WriteLine("Enter a number:"); i = int.Parse(Console .ReadLine()); Console.Write("\n\nFactorial (0) = ", i); do ( result *= num; num++; ) while (num

foreach loop

foreach loop serves for cyclic access to elements of a collection, which is a group of objects. C# defines several types of collections, each of which is an array. The following is the general form of the foreach loop statement:

foreach (type loop_variable_name in collection) statement;

Here type loop_variable_name denotes the type and name of the loop control variable that receives the value of the next element of the collection at each step of the foreach loop. And collection denotes a cyclically queried collection, which hereinafter represents an array. Therefore, the type of the loop variable must match the type of the array element. Additionally, a type can be denoted by the var keyword. In this case, the compiler determines the type of the loop variable based on the type of the array element. This may be useful for working with certain types of queries. But, as a rule, the type is specified explicitly.

The foreach loop statement works as follows. When the loop starts, the first element of the array is selected and assigned to the loop variable. At each subsequent iteration step, the next array element is selected and stored in a loop variable. The loop ends when all elements of the array are selected.

A foreach loop allows you to iterate through each element of a collection (an object that represents a list of other objects). Technically, for something to be considered a collection, it must support the IEnumerable interface. Examples of collections include C# arrays, collection classes from the System.Collection namespace, and custom collection classes.

The For Each...Next loop in VBA Excel, its syntax and description of individual components. Examples of using the For Each...Next loop.

The For Each... Next loop in VBA Excel is designed to execute a block of statements in relation to each element from a group of elements (range, array, collection). This wonderful loop is used when the number of elements in a group and their indexing are unknown, otherwise it is preferable to use .

For Each...Next Loop Syntax

The square brackets indicate optional attributes of the For Each...Next loop.

Components of a For Each...Next Loop

*If a For Each...Next loop is used in VBA Excel to iterate through the elements of a collection (Collection object) or array, then the variable element must be declared with a data type Variant, otherwise the loop will not work.

**If you don't use your own code in a loop, the meaning of using a loop is lost.

Examples of For Each...Next loops

Loop over a range of cells

On the active sheet of the Excel workbook, select a range of cells and run the following procedure:

Sub test1() Dim element As Range, a As String a = "Data obtained by For Each... Next:" For Each element In Selection a = a & vbNewLine & "Cell " & element.Address & _ " contains the value: " & CStr(element.Value) Next MsgBox a End Sub

The MsgBox information window will display the addresses of the selected cells and their contents, if any. If many cells are selected, then complete information on all cells will not be displayed, since the maximum length of the parameter Prompt is approximately 1024 characters.

Loop for a collection of sheets

Copy the following VBA procedure into Excel workbooks:

Sub test2() Dim element As Worksheet, a As String a = "List of sheets contained in this worksheet:" For Each element In Worksheets a = a & vbNewLine & element.Index _ & ") " & element.Name Next MsgBox a End Sub

The MsgBox information window will display a list of the names of all sheets in the Excel workbook by the serial number of their labels corresponding to their indexes.

Loop for an array

Let's assign a list of animal names to the array and write them into a variable in the For Each... Next loop a. The MsgBox information window will display a list of animal names from the variable a.

Sub test3() Dim element As Variant, a As String, group As Variant group = Array("hippopotamus", "elephant", "kangaroo", "tiger", "mouse") "or you can assign the values ​​of the range of cells of the "worker" to the array sheet, for example, selected: group = Selection a = "The array contains the following values:" & vbNewLine For Each element In group a = a & vbNewLine & element Next MsgBox a End Sub

Let's repeat the same VBA procedure, but assign the value "Parrot" to all elements of the array in the For Each...Next loop. The MsgBox information window will display a list of animal names, consisting only of parrots, which proves that it is possible to edit the values ​​of array elements in the For Each...Next loop.

Sub test4() Dim element As Variant, a As String, group As Variant group = Array("hippopotamus", "elephant", "kangaroo", "tiger", "mouse") "or you can assign the values ​​of the range of cells of the "worker" to the array sheet, for example, the selected one: group = Selection a = "The array contains the following values:" & vbNewLine For Each element In group element = "Parrot" a = a & vbNewLine & element Next MsgBox a End Sub

This code, like all others in this article, was tested in Excel 2016.

Loop through a collection of subdirectories and exit the loop

In this example we will add to the variable a names of subdirectories on the disk C your computer. When the loop reaches the folder Program Files, it will add to the variable a its title and message: “Enough, I won’t read any further! Sincerely, your For Each...Next cycle."

Sub test5() Dim FSO As Object, myFolders As Object, myFolder As Object, a As String "Create a new FileSystemObject and assign it to the variable "FSO" Set FSO = CreateObject("Scripting.FileSystemObject") "Retrieve the list of subdirectories on drive "C" " and assign "it to the variable "myFolders" Set myFolders = FSO.GetFolder("C:\") a = "Folders on drive C:" & vbNewLine "We loop through the list of subdirectories and add their names to the variable "a" Having reached the "Program Files" folder, we exit the cycle For Each myFolder In myFolders.SubFolders a = a & vbNewLine & myFolder.Name If myFolder.Name = "Program Files" Then a = a & vbNewLine & vbNewLine & "That's enough, read on I won't!" _ & vbNewLine & vbNewLine & "Regards," & vbNewLine & _ "Your loop is For Each... Next." Exit For End If Next Set FSO = Nothing MsgBox a End Sub

The MsgBox information window will display a list of subdirectory names on the disk C your computer to the folder Program Files inclusive and a message from the cycle about the termination of its work.

As a result of the program's operation, not only the names of subdirectories visible when navigating to the disk in Explorer will be displayed C, but also hidden and service folders. To view a list of all subdirectories on a disk C, comment out the section of code from If before End If inclusive and run the procedure in the VBA Excel editor.

Often you need to iterate through all the elements of a PHP array and perform some operation on each element. For example, you can output each value to an HTML table or give each element a new value.

In this lesson we will look at the foreach construct when organizing a loop over indexed and associated arrays.

Loop through element values

The simplest use case for foreach is to loop through values ​​in an indexed array. Basic syntax:

Foreach ($array as $value) ( ​​// Do something with $value ) // Here the code is executed after the loop completes

For example, the following script iterates through the list of directors in an indexed array and prints out the name of each:

$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); foreach ($directors as $director) ( echo $director . "
"; }

The above code will output:

Alfred Hitchcock Stanley Kubrick Martin Scorsese Fritz Lang

Key-Value Loop

What about associated arrays? When using this type of array, you often need to have access to the key of each element as well as its value. The foreach construct has a way to solve the problem:

Foreach ($array as $key => $value) ( ​​// Do something with $key and/or $value ) // Here the code is executed after the loop completes

An example of organizing a loop through an associated array with information about movies, displaying the key of each element and its value in the HTML list of definitions:

$movie = array("title" => "Rear Window", "director" => "Alfred Hitchcock", "year" => 1954, "minutes" => 112); echo "

"; foreach ($movie as $key => $value) ( ​​echo "

$key:

"; echo "

$value

"; ) echo "

When executed, this script will output:

Title: Rear Window director: Alfred Hitchcock year: 1954 minutes: 112

Changing the value of an element

What about changing the value of an element as the loop goes through? You can try this code:

Foreach ($myArray as $value) ( ​​$value = 123; )

However, if you run it, you will find that the values ​​in the array do not change. The reason is that foreach works with a copy array values, not with the original. This way the original array remains intact.

To change array values ​​you need link to the meaning. To do this, you need to put an & sign in front of the value variable in the foreach construct:

Foreach ($myArray as &$value) ( ​​$value = 123; )

For example, the following script loops through each element (the director's name) in the $directors array, and uses the PHP explode() function and the list construct to swap the first and last names:

$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); // Change the name format for each element foreach ($directors as &$director) ( list($firstName, $lastName) = explode(" ", $director); $director = "$lastName, $firstName"; ) unset( $director); // Print the final result foreach ($directors as $director) ( echo $director . "
"; }

The script will output:

Hitchcock, Alfred Kubrick, Stanley Scorsese, Martin Lang, Fritz

Note that the script calls the unset() function to remove the $director variable after the first loop completes. This is a good practice if you plan to use the variable later in the script in a different context.

If you don't remove the reference, you run the risk of further executing code accidentally referencing the last element in the array ("Lang, Fritz") if you continue to use the $director variable, which will lead to unintended consequences!

Summary

In this tutorial, we looked at how to use the PHP foreach construct to loop through the elements of an array. The following issues were considered:

• How to loop through array elements
• How to access the key and value of each element
• How to use a reference to change values ​​as you go through a loop

In a recent digest of interesting links about PHP, I found a link to a comment by Nikita Popov on StackOverflow, where he talks in detail about the mechanism “under the hood” of the foreach control construct.
Since foreach does sometimes work in more than a little strange ways, I found it useful to translate this answer.

Attention: this text assumes a basic knowledge of the functionality of zvals in PHP, in particular you should know what refcount and is_ref are.
foreach works with entities of different types: with arrays, with simple objects (where available properties are listed) and with Traversable objects (or rather, objects that have an internal get_iterator handler defined). We're mostly talking about arrays here, but I'll talk about the rest at the very end.

Before we begin, a few words about arrays and their traversal, important for understanding the context.

How does array traversal work?

Arrays in PHP are ordered hash tables (hash elements are combined into a doubly linked list) and foreach traverses the array following the specified order.

PHP includes two ways to traverse an array:

• The first way is an internal array pointer. This pointer is part of the HashTable structure and is simply a pointer to the current hash table element. The internal array pointer can be changed with impunity, that is, if the current element is deleted, the internal array pointer will be moved to the next one.
• The second iteration mechanism is an external array pointer called HashPosition. This is essentially the same as an internal array pointer, but it is not part of the HashTable. This external way of iteration is not change-safe. If you remove the element pointed to by HashPosition, you will be left with a dangling pointer, which will result in a segmentation fault.

Thus, external array pointers should only be used when you are absolutely sure that no user code will be executed during the traversal. And such code may end up in the most unexpected places, such as an error handler or a destructor. This is why in most cases PHP has to use an internal pointer instead of an external one. If it were otherwise, PHP might crash with a segmentation fault as soon as the user starts doing anything unusual.

The problem with the internal pointer is that it is part of the HashTable. So when you change it, the HashTable changes with it. And since arrays in PHP are accessed by value (and not by reference), you are forced to copy the array in order to loop through its elements.

A simple example showing the importance of copying (not that uncommon, by the way) is nested iteration:

Foreach ($array as $a) ( foreach ($array as $b) ( // ... ) )

Here you want both loops to be independent, and not cleverly thrown around with one pointer.

So we come to foreach.

Traversing an array in foreach

Now you know why foreach has to create a copy of the array before traversing it. But this is clearly not the whole story. Whether PHP makes a copy or not depends on several factors:

• If the iterable array is a reference, no copying will occur, instead addref will be executed:

  $ref =& $array; // $array has is_ref=1 now foreach ($array as $val) ( // ... )
  Why? Because any change to the array must be propagated by reference, including the internal pointer. If foreach made a copy in this case, it would break the semantics of the link.

• If the array has refcount=1, the copying will again not be performed. refcount=1 means the array is not used elsewhere and foreach can use it directly. If refcount is greater than one, then the array is shared with other variables and to avoid modification, foreach must copy it (regardless of the reference case described above).
• If the array is reference-traversed (foreach ($array as &$ref)), then - regardless of the copy or non-copy function - the array will become a reference.

So this is the first part of the mystery: the copy function. The second part is how the current iteration is executed, and it is also quite strange. The "normal" iteration pattern that you already know (and which is often used in PHP - separate from foreach) looks something like this (pseudocode):

Reset(); while (get_current_data(&data) == SUCCESS) ( code(); move_forward(); )
the foreach iteration looks a little different:

Reset(); while (get_current_data(&data) == SUCCESS) ( move_forward(); code(); )

The difference is that move_forward() is executed at the beginning rather than at the end of the loop. Thus, when user code uses element $i, the internal array pointer already points to element $i+1.

This mode of operation of foreach is also the reason why the internal array pointer moves to the next element if the current one is deleted, rather than to the previous one (as you might expect). Everything is designed to work great with foreach (but obviously won't work as well with everything else, skipping elements).

Code implications

The first consequence of the above behavior is that foreach copies the iterable array in many cases (slowly). But fear not: I tried removing the copy requirement and couldn't see any speedup anywhere except in the artificial benchmarks (which iterated at twice the speed). It seems like people just don't iterate enough.

The second consequence is that there should usually be no other consequences. The behavior of foreach is generally quite understandable to the user and just works as it should. You should not care how the copying occurs (or whether it occurs at all), or at what specific point in time the pointer is moved.

And the third consequence - and this is where we come to your problem - is that sometimes we see very strange behavior that is difficult to understand. This happens specifically when you try to modify the array itself, which you are traversing in a loop.

A large collection of edge case behavior that occurs when you modify an array during iteration can be found in PHP tests. You can start with this test, then change 012 to 013 in the address, and so on. You will see how foreach behavior will manifest itself in different situations (all sorts of combinations of links, etc.).

Now let's go back to your examples:

Foreach ($array as $item) ( echo "$item\n"; $array = $item; ) print_r($array); /* Output in loop: 1 2 3 4 5 $array after loop: 1 2 3 4 5 1 2 3 4 5 */

Here $array has refcount=1 before the loop so it won't be copied but will get addref. Once you assign a value to $array, the zval will be split, so that the array you are adding elements to and the array you are iterating on will be two different arrays.

Foreach ($array as $key => $item) ( $array[$key + 1] = $item + 2; echo "$item\n"; ) print_r($array); /* Output in loop: 1 2 3 4 5 $array after loop: 1 3 4 5 6 7 */

The same situation as in the first test.

// Shift the pointer by one to make sure it doesn't affect foreach var_dump(each($array)); foreach ($array as $item) ( echo "$item\n"; ) var_dump(each($array)); /* Output array(4) ( => int(1) ["value"]=> int(1) => int(0) ["key"]=> int(0) ) 1 2 3 4 5 bool( false) */

Same story again. During the foreach loop, you have refcount=1 and you only get addref, the internal $array pointer will be modified. At the end of the loop, the pointer becomes NULL (this means that the iteration is completed). each demonstrates this by returning false.

Foreach ($array as $key => $item) ( echo "$item\n"; each($array); ) /* Output: 1 2 3 4 5 */

Foreach ($array as $key => $item) ( echo "$item\n"; reset($array); ) /* Output: 1 2 3 4 5 */

But these examples are not convincing enough. The behavior starts to get really unpredictable when you use current in a loop:

Foreach ($array as $val) ( var_dump(current($array)); ) /* Output: 2 2 2 2 2 */

Here you should keep in mind that current is also accessed by reference, despite not modifying the array. This is needed to work consistently with all the other functions, like next, that access by reference (current is actually a preferable ref function; it can get a value, but uses a reference if it can). A reference means that the array must be separated, so $array and the copy of $array that foreach uses will be independent. Why you get 2 and not 1 is also mentioned above: foreach increments array pointer before the start of the user code, not after. So even if the code is still working on the first element, foreach has already moved the pointer to the second.

Now let's try a small change:

$ref = &$array; foreach ($array as $val) ( var_dump(current($array)); ) /* Output: 2 3 4 5 false */

Here we have is_ref=1, so the array is not copied (same as above). But now that there is is_ref, the array no longer needs to be split, passing by reference to current. Now current and foreach work with the same array. You see the array shifted by one precisely because of the way foreach treats the pointer.

You'll see the same thing when you traverse an array by reference:

Foreach ($array as &$val) ( var_dump(current($array)); ) /* Output: 2 3 4 5 false */

The important thing here is that foreach will assign our $array is_ref=1 when it loops over it by reference, so it will end up the same as above.

Another small variation, here we will assign our array to another variable:

$foo = $array; foreach ($array as $val) ( var_dump(current($array)); ) /* Output: 1 1 1 1 1 */

Here the refcount of $array is set to 2 when the loop started, so a copy needs to be made before starting. So $array and the array used by foreach will be different from the start. That's why you get the position of the internal array pointer that was relevant before the loop started (in this case it was in the first position).

Iteration of objects

When iterating objects, it makes sense to consider two cases:

The object is not Traversable (or rather, the internal get_iterator handler is not defined)

In this case, iteration occurs almost the same as with arrays. The same semantics of copying. The only difference is that foreach will run some extra code to skip properties that are not available in the current scope. A couple more interesting facts:

• For declared properties, PHP reoptimizes the property hash table. If you do iterate the object, it must reconstruct that hash table (which increases memory usage). Not that you should worry about it, just be aware.
• At each iteration, the property hash table will be re-obtained, meaning PHP will call get_properties again and again and again. For “regular” properties this is not so important, but if properties are created dynamically (this is often done by built-in classes) then the property table will be recalculated every time.

Traversable object

In this case, everything said above will not apply in any way. Also, PHP won't copy and won't use any tricks like pointer increments before looping. I think that the mode of passing through a Traversable object is much more predictable and does not require further description.

Replacing an iterable during a loop

Another unusual case that I didn't mention is that PHP allows the ability to replace an iterable during a loop. You can start with one array and continue by replacing it with another one halfway through. Or start with an array, then replace it with an object:

$arr = ; $obj = (object) ; $ref =& $arr; foreach ($ref as $val) ( echo "$val\n"; if ($val == 3) ( $ref = $obj; ) ) /* Output: 1 2 3 6 7 8 9 10 */

As you can see, PHP simply started traversing the other entity as soon as the replacement occurred.

Changing the internal array pointer during iteration

One last detail of foreach behavior that I didn't mention (because it can be used to get really strange behavior): what can happen if you try to change the internal array pointer during a loop.

Here you may not get what you expected: if you call next or prev in the body of the loop (in the case of passing by reference), you will see that the internal pointer has moved, but this has no effect on the behavior of the iterator. The reason is that foreach makes a backup of the current position and hash of the current element in the HashPointer after each pass of the loop. On the next pass, foreach will check to see if the position of the internal pointer has changed and try to restore it using this hash.

Let's see what "will try" means. The first example shows how changing the internal pointer does not change the foreach mode:

$array = ; $ref =& $array; foreach ($array as $value) ( ​​var_dump($value); reset($array); ) // output: 1, 2, 3, 4, 5

Now let's try to unset the element that foreach will access on the first pass (key 1):

$array = ; $ref =& $array; foreach ($array as $value) ( ​​var_dump($value); unset($array); reset($array); ) // output: 1, 1, 3, 4, 5

Here you will see that the counter has been reset because an element with a matching hash could not be found.

Keep in mind, a hash is just a hash. Collisions happen. Let's try this now:

$array = ["EzEz" => 1, "EzFY" => 2, "FYEz" => 3]; $ref =& $array; foreach ($array as $value) ( ​​unset($array["EzFY"]); $array["FYFZ"] = 4; reset($array); var_dump($value); ) // output: 1 1 3 4

Works as we expected. We removed the EzFY key (the one where foreach was located), so a reset was made. We also added an extra key, so we see 4 at the end.

And here comes the unknown. What happens if you replace the FYFY key with FYFZ? Let's try:

$array = ["EzEz" => 1, "EzFY" => 2, "FYEz" => 3]; $ref =& $array; foreach ($array as $value) ( ​​unset($array["EzFY"]); $array["FYFY"] = 4; reset($array); var_dump($value); ) // output: 1 4

Now the loop has moved directly to the new element, skipping everything else. This is because the FYFY key has a collision with EzFY (actually, all the keys from this array too). Moreover, the FYFY element is located at the same memory address as the EzFY element that was just deleted. So for PHP it will be the same position with the same hash. The position is “restored” and the transition to the end of the array occurs.

The foreach construct is a variation of for that is included in the language to make iterating over the elements of an array easier. There are two versions of the foreach command, designed for different types of arrays:

foreach (array as $element) (

foreach (array as $key => $element) (

For example, when executing the following snippet:

$menu = аrrау("pasta", "steak", "potatoes", "fish", "fries");

foreach ($menu as $item) (

print "$item
";

the following result will be output:

There are two things to note in this example. First, the foreach construct automatically returns to the beginning of the array (this does not happen in other looping constructs). Secondly, there is no need to explicitly increment the counter or otherwise move to the next element of the array - this happens automatically with each iteration of the foreach.

The second option is used when working with associative arrays:

$wine_inventory = array (

"merlot" => 15,

"zinfandel" => 17,

"sauvignon" => 32

foreach ($wine_inventory as $i => $item_count) (

print "$item_count bottles of $i remaining
";

In this case the result looks like this:

15 bottles of merlot remaining

17 bottles of zinfandel remaining

32 bottles of sauvignon remaining

As you can see from the examples above, the foreach construct significantly simplifies working with arrays.

The principle of operation of the switch construct is somewhat reminiscent of if - the result obtained from evaluating the expression is checked against a list of potential matches.

This is especially useful when checking multiple values, since using a switch makes the program more visual and compact. The general format of the switch command is:

switch (expression) (

case (condition):

case (condition):

The condition being tested is indicated in parentheses after the switch keyword. The result of its calculation is sequentially compared with the conditions in the case sections. If a match is found, the block of the corresponding section is executed. If no match is found, the optional default section block is executed.

As you'll see in later chapters, one of PHP's greatest strengths is its handling of user input. Let's say a program displays a drop-down list with several options, and each line in the list corresponds to a command that is executed in a separate case construct. It is very convenient to build the implementation using the switch command:

$user_input = "recipes"; // User-selected command

switch ($user_input) :

case("search") :

print "Let"s perform a search!";

case("dictionary") :

print "What word would you like to look up?";

case("recipes") :

print "Here is a list of recipes...";

print "Here is the menu...";

As you can see from the above fragment, the switch command provides a clear and visual organization of the code. The variable specified in the switch condition (in this example, $user_input) is compared with the conditions of all subsequent case sections. If the value specified in the case section matches the value of the variable being compared, the block of this section is executed. The break command prevents further case sections from being checked and ends the execution of the switch construct. If none of the checked conditions are met, the optional default section is activated. If there is no default section and none of the conditions are true, the switch command simply ends and program execution continues with the next command.

You must remember that if there is no break command in the case section (see the next section), execution of the switch continues with the next command until a break command is encountered or the end of the switch statement is reached. The following example demonstrates the consequences of missing a break command: $value = 0.4;

switch($value) :

print "value is 0.4
";

print "value is 0.6
";

print "value is 0.3
";

print "You didn't choose a value!";

The result looks like this:

The absence of a break command resulted in the execution of not only the print command in the section where the match was found, but also the print command in the next section. Then the commands in the switch statement were interrupted by a switch command following the second print command.

The choice between the switch and if commands has virtually no effect on the performance of the program. The decision to use one design or another is rather a personal matter for the programmer.

The break command immediately breaks the execution of the while, for, or switch statement in which it is found. This command was already mentioned in the previous section, but interrupting the current loop does not exhaust the capabilities of the break command. In general, the break syntax looks like this:

The optional parameter n specifies the number of levels of control constructs terminated by the break command. For example, if a break command is nested within two while commands and the break is followed by the number 2, both loops exit immediately. The default value for n is 1; exit to one level can be indicated either by explicitly specifying 1 or by specifying the break command without a parameter. Note that the i f command is not one of the control constructs that can be interrupted by the break command.