10 years ago
Just a note about using the continue statement to forego the remainder of a loop - be SURE you "re not issuing the continue statement from within a SWITCH case - doing so will not continue the while loop, but rather the switch statement itself.
While that may seem obvious to some, it took a little bit of testing for me, so hopefully this helps someone else.
5 years ago
Is strange that the manual states ...
"Sometimes, if the while expression evaluates to FALSE from the very beginning, the nested statement (s) won" t even be run once. "
Because it can "t be SOMETIMES
If it behaves that way, then it is a bug, because it ALWAYS must not run the nested statement (s) even once if the WHILE expression evaluates to FALSE from the very beginning.
Another way to exit the while loop is by using the BREAK statement .. see it in the manual.
And if expression evaluates to NULL is the same as FALSE
while (expression evals to NULL) ()
14 years ago
Just a note to stuart - the reason for this behavior is because using the while (value = each (array)) construct increments the internal counter of the array as its looped through. Therefore if you intend to repeat the loop, you need to reset the counter. eg:
$ one = array ("10", "20", "30", "40");
$ two = array ("a", "b", "c", "d");
$ i = 0;
while ($ i< count($one)) {
reset ($ two);
while ($ a = each ($ two)) (
echo $ a. "-". $ one [$ i]. ",";
}
$ i ++;
a - 10, b - 10, c - 10, d - 10, a - 20, b - 20, c - 20, d - 20, a - 30, b - 30, c - 30, d - 30, a - 40, b - 40, c - 40, d - 40,
15 years ago
While can do wonders if you need something to queue writing to a file while something else has access to it.
Here is my simple example:
Function write ($ data, $ file, $ write_mode = "w") (
$ lock = $ file. ".lock";
// run the write fix, to stop any clashes that may occur
write_fix ($ lock);
// create a new lock file after write_fix () for this writing session
touch ($ lock);
// write to your file
$ open = fopen ($ file, $ write_mode);
fwrite ($ open, $ data);
fclose ($ open);
// kill your current lock
unlink ($ lock);
}
Function write_fix ($ lock_file) (
while (file_exists ($ lock_file) (
// do something in here?
// maybe sleep for a few microseconds
// to maintain stability, if this is going to
// take a while ??
}
}
?>
This method is not recommended for use with programs that will be needing a good few seconds to write to a file, as the while function will eat up alot of process cycles. However, this method does work, and is easy to implement. It also groups the writing functions into one easy to use function, making life easier. :-)
17 years ago
At the end of the while (list / each) loop the array pointer will be at the end.
This means the second while loop on that array will be skipped!
You can put the array pointer back with the reset ($ myArray) function.
$ myArray = array ("aa", "bb", "cc", "dd");
reset ($ myArray);
while (list ($ key, $ val) = each ($ myArray)) echo $ val;
?>
7 years ago
Instead of this usage;
$ arr = array ("orange", "banana", "apple", "raspberry");
$ i = 0;
while ($ i<
count
($arr
)) {
$ a = $ arr [$ i];
echo $ a. "\ n";
$ i ++;
}
// or
$ i = 0;
$ c = count ($ arr);
while ($ i<
$c
) {
$ a = $ arr [$ i];
echo $ a. "\ n";
$ i ++;
}
?>
This could be more efficient;
while ($ a = $ arr [1 * $ i ++]) echo $ a. "\ n";
?>
16 years ago
I made a test traversing an array (simple, but long, numeric array with numeric keys). My test had a cycle per method, and multiplied each array element by 100 .. These were my results:
******************************************************
30870 Element Array Traversing
0.2373 seg later -> while (list ($ key, $ val) = each ($ array)) ENDS
0.1916 seg later -> while (list ($ key,) = each ($ array)) ENDS
0.1714 seg later -> foreach ($ array AS $ key => $ value) ENDS
0.0255 seg later -> while ($ next = next ($ array)) ENDS
0.1735 seg later -> foreach ($ array AS $ value) ENDS
**************************************************************
foreach is fatser than a while (list - each), true.
However, a while (next) was faster than foreach.
These were the winning codes:
$ array = $ save;
test_time ("", 1);
foreach ($ array AS $ key => $ value)
test_time ("foreach (\ $ array AS \ $ key => \ $ value)");
$ array = $ save;
test_time ("", 1);
reset ($ array);
while ($ next = next ($ array))
($ key = key ($ array);
$ array [$ key] = $ array [$ key] * 100;
}
test_time ("while (\ $ next = next (\ $ array))");
*********************************************************
The improvement seems huge, but it isnt that dramatic in real practice. Results varied ... I have a very long bidimensional array, and saw no more than a 2 sec diference, but on 140+ second scripts. Notice though that you lose control of the $ key value (unless you have numeric keys, which I tend to avoid), but it is not always necessary.
I generally stick to foreach. However, this time, I was getting Allowed Memory Size Exceeded errors with Apache. Remember foreach copies the original array, so this now makes two huge 2D arrays in memory and alot of work for Apache. If you are getting this error, check your loops. Dont use the whole array on a foreach. Instead get the keys and acces the cells directlly. Also, try and use unset and Referencing on the huge arrays.
Working on your array and loops is a much better workaround than saving to temporary tables and unsetting (much slower).
14 years ago
The speedtest is interesting. But the seemingly fastest way contains a pitfall for beginners who just use it because it is fast and fast is cool;)
Walking through an array with next () will cut of the first entry, as this is the way next () works;)
If you really need to do it this way, make sure your array contains an empty entry at the beginning. Another way would be to use
while ($ this = current ($ array)) (
do_something ($ this);
next ($ array);
}
?>
There is an impact on speed for sure but I did not test it. I would advise to stick with conventional methods because current (), next () in while loops is too error prone for me.
4 years ago
A cool way to keep evaluating something until it fails a test.
while (true) (
if ("test") ( // is initial condition true
// do something that also changes initial condition
) else (// condition failed
break; // leave loop
}
}
?>
4 years ago
Simple pyramid pattern program using while loop
$ i = 1;
while ($ i<=
5
)
{
$ j = 1;
while ($ j<=
$i
)
{
echo "* & nbsp & nbsp";
$ j ++;
}
echo "
"
;
$ i ++;
}
?>
// or alternatively you can use:
$ i = 1;
while ($ i<=
5
):
$ j = 1;
while ($ j<=
$i
):
echo "* & nbsp & nbsp";
$ j ++;
endwhile;
Echo "
"
;
$ i ++;
endwhile;
?>
11 years ago
Due to the fact that php only interprets the necessary elements to get a result, I found it convenient to concatenate different sql queries into one statement:
$ q1 = "some query on a set of tables";
$ q2 = "similar query on a another set of tables";
if (($ r1 = mysql_query ($ q1)) && ($ r2 = mysql_query ($ q2))) (
While (($ row = mysql_fetch_assoc ($ r1)) || ($ row = mysql_fetch_assoc ($ r2))) (
/ * do something with $ row coming from $ r1 and $ r2 * /
}
}
?>
3 years ago
// test While Vs For php 5.6.17
$ t1 = microtime (true);
$ a = 0;
while ($ a ++<=
1000000000
);
$ t2 = microtime (true);
$ x1 = $ t2 - $ t1;
echo PHP_EOL, "> while ($ a ++<= 100000000); : "
, $ x1, "s", PHP_EOL;
$ t3 = microtime (true);
for ($ a = 0; $ a<=
1000000000
;
$a
++);
$ t4 = microtime (true);
$ x2 = $ t4 - $ t3;
echo PHP_EOL, "> for ($ a = 0; $ a<= 100000000;$a++); : "
, $ x2, "s", PHP_EOL;
$ t5 = microtime (true);
$ a = 0; for (; $ a ++<=
1000000000
;);
$ t6 = microtime (true);
$ x3 = $ t6 - $ t5;
echo PHP_EOL, "> $ a = 0; for (; $ a ++<= 100000000;); : "
, $ x3, "s", PHP_EOL;
//> while ($ a ++<= 100000000); = 18.509671926498s
//> for ($ a = 0; $ a<= 100000000;$a++); = 25.450572013855s
//> $ a = 0; for (; $ a ++<= 100000000;); = 22.614907979965s
// ===================
//> while ($ a ++! = 100000000); : 18.204656839371s
//> for ($ a = 0; $ a! = 100000000; $ a ++); : 25.025605201721s
//> $ a = 0; for (; $ a ++! = 100000000;); : 22.340576887131s
// ===================
//> while ($ a ++< 100000000); : 18.383454084396s
//> for ($ a = 0; $ a< 100000000;$a++); : 25.290743112564s
//> $ a = 0; for (; $ a ++< 100000000;); : 23.28609919548s
?>
16 years ago
This is an easy way for all you calculator creators to make it do factorials. The code is this:
$ c = ($ a - 1);
$ d = $ a;
while ($ c> = 1)
{
$ a = ($ a * $ c);
$ c -;
}
print ("$ d! = $ a");
?>
$ a changes, and so does c, so we have to make a new variable, $ d, for the end statement.
The PHP foreach loop can be used like this:
foreach ($ array_name as $ value) (// code to be executed)
foreach ($ array_name as $ key => $ value) (// // code to be executed)
Example using a foreach loop with a numeric array
In this example, we will create a five-element array with numeric values. The PHP foreach loop will then be used to iterate through this array. Inside the foreach loop, we used echo to print out the values of the array:
View demo and code
Example with keys and array values
This example describes another way to use the PHP foreach loop. For this, we have created an associative array of three elements. It includes the names of employees ( as keys) and the amount of wages ( as values):
View demo and code
An example of changing the value of an array element in a foreach loop
You can also use PHP array foreach to change the values of array elements. To do this, use "&" before "$" for the variable value. For instance:
& $ value_of_element
The value will be changed. To make it clearer, consider the following example.
In this example, we have created a numeric array of five elements. After that, we used a foreach loop to display the values of the elements.
Then we created another foreach loop where "&" is added before $ value_of_element. Inside the curly braces, we assign new values to the array elements.
To see the difference before and after assigning new values, the array is displayed using the print_r () function.
View demo and code
What is the PHP foreach loop used for?
The PHP foreach loop is used to work with an array. It iterates over each of its elements.
You can also use a for loop to work with arrays. For example using the length property to get the length of an array and then apply it as the max operator. But foreach makes it easier because it is designed to work with arrays.
If you are working with MySQL, then this cycle is even more suitable for this. For example, you can select multiple rows from a database table and pass them to an array. After that, using a foreach loop, iterate over all the elements of the array and perform some action.
Note that you can use a foreach loop with an array or just an object.
Using a foreach loop
There are two ways to use PHP foreach loop in PHP. Both are described below.
- The syntax for the first usage method is:
foreach ($ array_name as $ value) (echo $ value)
In this case, you need to specify the name of the array, and then the variable $ value.
For each iteration, the value of the current element is assigned to the $ value variable. Upon completion of the iteration, the variable is assigned the value of the next element. And so on until all the elements of the array are enumerated.
- The syntax of the second method ( PHP foreach as key value):
This is suitable for associative arrays that use key / value pairs.
During each iteration, the value of the current element will be assigned to the $ value_of_element variable. In addition, the element key is assigned to the $ key_of_element variable.
If you are working with numeric arrays, then you can use the first method, which does not require element keys.
This publication is a translation of the article " PHP foreach loop 2 ways to use it"Prepared by the friendly project team
The note: the adaptive version of the site is activated, which automatically adjusts to the small size of your browser and hides some of the site's details for readability. Happy viewing!
Hello dear readers and regular subscribers! It's time to continue the series of articles about PHP and today we will learn such a basic and at the same time very important thing, like loops. What is the first thing you need to know about loops? And the fact that they are used everywhere and everywhere, and templates Joomla, VirtueMart, Wordpress, OpenCart and any other CMS is no exception.
What is a cycle? Cycle Is a multiple repetition of the same piece of code. How many repetitions need to be done depends on the cycle counter, which we ourselves create and can manage. This is very convenient, for example, when we need to draw products in the category of an online store, display blog posts, display comments on an article or product, all menus in CMS (site engines) are also made using loops. In general, loops are used very often.
But before moving on to the loops themselves, first you need to mess with such a thing as operators increment and decrement.
The ++ (increment) operator increases the value of a variable by one, while the - (decrement) operator decreases the value of a variable by one. They are very convenient to use in loops as a counter, and in programming in general. There are also PRE increment / decrement and POST increment / decrement:
PRE increment / decrement ++ $ a Increments $ a by one and returns the value of $ a. - $ a Decreases $ a by one and returns the value of $ a. POST increment / decrement $ a ++ Returns the value of $ a and then increments $ a by one. $ a-- Returns the value of $ a and then decrements $ a by one.
For instance:
$ a = 1; echo "Print number:". $ a ++; // Print number: 1 echo "Print number:". $ a; // Outputting a number: 2 echo "Outputting a number: $ a"; $ a + = 1; // same as in the first line$ a = 1; echo "Print number:". ++ $ a; // Print number: 2 echo "Print number:". $ a; // Display the number: 2 $ a + = 1; echo "Print number: $ a"; // the same as in the first line of this block
For loop
for (part A; part B; part C) (// Any code, as many lines as you want;)The for loop consists of 3 parts and the body itself. Part A it just does what it says, as a rule, in 90% of cases, a loop counter is created there. Part B- this, roughly speaking, is already familiar to us if, that is, checking for true (true?). If the condition is true, that is true, then PHP goes inside the loop and continues to execute it. Part C- the same as part A, as a rule in Part C we do some kind of conversion with a counter. For instance:
";) echo" LOOK OUT and move on through the code ... ";?>
Now about the algorithm of the for loop. First of all, when it sees for, PHP goes into part A and executes it once (see image below). PHP then goes to B and checks if there is true or false. If true, then it executes the body of the loop and only then goes to part C. After that PHP goes to part B again and checks whether it is still true there or not. If not, then the loop ends, if yes, then continues until part B is false.
The result of the previous example:
While Loop
while (part B) (// Any code, as many lines as you like;)As you can see, there is no part A and part C, only the condition remains from the for loop, that is, part B. If we need to use a counter, then we must put it inside the while loop, among the rest of the code, this will be part C. the counter is needed before the start of the while construction:
Part A; while (part B) (// Any code, as many lines as you like; Part C;)
Let's transform the previous for loop into a while loop:
"; $ i ++;) echo" LOOK OUT and move on through the code ... ";?>
The result will be exactly the same. What to use: a for loop or a while loop is a matter of taste, see how it is more convenient and logical for you, there is no difference.
Do ... while loop
Less common of all types of cycles. It is essentially an inverted while. Its trick is that PHP at least once (the first), but will certainly go into the body of the do ... while loop, because in this loop the condition at the end:
Part A; do (// Any code, as many lines as you like; Part C;) while (Part B);
"; $ i ++;) while ($ i< 8); echo "ВЫШЛИ ИЗ ЦИКЛА и пошли дальше по коду..."; ?>
It is important to understand that there are no mandatory parts in all three types of cycles.
An example of a for loop without part A and part C:
For (; $ i> 8;) (// your code)
An example of a for loop without all three parts:
For (;;) (// classic infinite loop)
That is, all semicolons still remain in the for loop, this is the syntax!
Endless loops
An infinite loop is a developer's mistake in which the page will never be able to load to the end, since the loop condition (part B) will always be true. For instance:
"; $ i ++;) while ($ i! = 0); echo" EXIT THE CYCLE and move on through the code ... ";?>
Result:
This I showed only a part, because everything does not fit on the screen. This is how your browser and your site's server will torment endlessly until the browser crashes after 30 seconds. This is because in the example above, the $ i variable will never be equal to zero, it is initially equal to 1 and is constantly increasing.
That is, the developer was inattentive when he came up with such a condition.
Cycle control
The break statement. There are situations when we don't need the loop to play out all iterations (repetitions). For example, at some certain moment we want to interrupt it and continue execution below in the code:
"; if ($ i === 5) break; // exit the loop if $ i is 5 $ i ++;) echo" I can only count up to 5 :( ";?>
Result:
In the example above, as soon as we got to five, PHP exited the loop, otherwise it would count to 7.
The continue statement also interrupts the execution of the loop, but unlike break, continue does not exit the loop, but returns the PHP interpreter back to the condition (to part B). Example:
";) echo" Did you miss something? ";?>
Result:
We just skipped the 5 because PHP didn't get to echo.
A loop can be nested within a loop. In this case, the continue and break statements only cover one cycle, the one in which they are located. That is, in other words, they are thrown one level, and not through all. Example:
But we ourselves can choose how many levels to jump over:
"; $ i ++; $ i = 1; $ k = 1; while ($ k< 8) {
echo "Итерация $k номер ". $k . "
"; if ($ k === 5) break 2; $ k ++;))?>
Result:
Naturally, in this case, we cannot put a number greater than our nested loops.
Foreach loop
The most recent, but most important, is the foreach loop. Used by only to iterate over and objects (it's too early to learn them). Sample syntax:
"; } ?>
Result:
It was a short foreach construction, but it also has an extended version, which, in addition to the values of the array cells, also displays the names of the cells (keys):
$ value) (echo "In the section ". $ key." there is an article called: ". $ value."
";
}
?>
Result:
I draw your attention to the fact that we can call variables whatever we want, even $ key and $ value, even $ xxx and $ yyy.
If an array, then we use only the foreach loop and no others. This cycle is used throughout VirtueMart, and indeed everywhere.
It is often convenient to be able to terminate the cycle ahead of schedule when certain conditions arise. This opportunity is provided by the break statement. It works with constructs such as while, do while, for, foreach, or switch.
The break statement can take an optional numeric argument that tells it how many nested structures to terminate. The default value for a numeric argument is 1, which ends the execution of the current loop. If a switch statement is used in a loop, then break / break 1 only exits the switch statement.
\ n "; break 1; / * Exit only from the switch statement. * / case 10: echo" Iteration 10; leaving
\ n "; break 2; / * Exit from the switch construction and from the while loop. * /)) // another example for ($ bar1 = -4; $ bar1< 7; $bar1++) {
// проверка деления на ноль
if ($bar1 == 0) {
echo "Выполнение остановлено: деление на ноль невозможно.";
break;
}
echo "50/$bar1 = ",50/$bar1,"
";
}
?>
Of course, sometimes you would prefer to just skip one of the loop iterations rather than terminate the loop completely, in which case this is done using the continue statement.
continue
To stop processing the current block of code in the body of the loop and go to the next iteration, you can use the continue statement. It differs from the break statement in that it does not terminate the loop, but simply moves to the next iteration.
The continue statement, like break, can take an optional numeric argument, which indicates how many levels of nested loops the rest of the iteration will be skipped. The default value for a numeric argument is 1, which skips only the remainder of the current loop.
"; continue;) echo" 50 / $ bar1 = ", 50 / $ bar1,"
";
}
?>
Please note: during the loop, the zero value of the $ counter variable was skipped, but the loop continued from the next value.
goto
goto is an unconditional jump operator. It is used to jump to another section of the program code. The place where you need to go in the program is indicated by a label (simple identifier) followed by a colon. For the transition, the desired label is placed after the goto statement.
A simple example of using the goto statement:
The goto statement has some limitations on its use. The target label must be in the same file and in the same context, which means that you cannot go outside the boundaries of a function or method, nor can you go inside one of them. Also, you cannot go inside any loop or switch statement. But it can be used to exit these constructs (from loops and switch statements). Usually a goto statement is used instead of multilevel breaks.
";) echo" after the loop - until the mark "; // the instruction will not be executed end: echo" After the mark ";?>
