While в цикле foreach
34
C# — Руководство по C# — Циклы do while и foreach
Цикл do. . . while
Цикл do…while в C# — это версия while с постпроверкой условия. Это значит, что
условие цикла проверяется после выполнения тела цикла. Следовательно, циклы do…while удобны в тех ситуациях, когда блок операторов должен быть выполнен как минимум однажды. Ниже приведена общая форма оператора цикла do-while:
операторы;
} while (условие);
При наличии лишь одного оператора фигурные скобки в данной форме записи необязательны. Тем не менее они зачастую используются для того, чтобы сделать конструкцию do-while более удобочитаемой и не путать ее с конструкцией цикла while. Цикл do-while выполняется до тех пор, пока условное выражение истинно. В качестве примера использования цикла do-while можно привести следующую программу, расчитывающую факториал числа:
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
try
{
// Вычисляем факториал числа
int i, result = 1, num = 1;
Console.WriteLine(“Введите число:”);
i = int.Parse(Console.ReadLine());
Console.Write(“nnФакториал {0} = “, i);
do
{
result *= num;
num++;
} while (num
Цикл foreach
Цикл foreach служит для циклического обращения к элементам коллекции,
представляющей собой группу объектов. В C# определено несколько видов коллекций, каждая из которых является массивом. Ниже приведена общая форма оператора
цикла foreach:
оператор;
Здесь тип имя_переменной_цикла обозначает тип и имя переменной управления циклом, которая получает значение следующего элемента коллекции на каждом
шаге выполнения цикла foreach. А коллекция обозначает циклически опрашиваемую коллекцию, которая здесь и далее представляет собой массив. Следовательно, тип
переменной цикла должен соответствовать типу элемента массива. Кроме того, тип
может обозначаться ключевым словом var. В этом случае компилятор определяет тип
переменной цикла, исходя из типа элемента массива. Это может оказаться полезным для работы с определенного рода запросами.
Но, как правило, тип указывается явным образом.
Оператор цикла foreach действует следующим образом. Когда цикл начинается,
первый элемент массива выбирается и присваивается переменной цикла. На каждом последующем шаге итерации выбирается следующий элемент массива, который сохраняется в переменной цикла. Цикл завершается, когда все элементы массива окажутся выбранными.
Цикл foreach позволяет проходить по каждому элементу коллекции (объект, представляющий список других объектов).
Формально для того, чтобы нечто можно было рассматривать как коллекцию, это нечто должно поддерживать интерфейс IEnumerable. Примерами коллекций могут служить массивы C#, классы коллекций из пространства имен System.Collection, а также пользовательские классы коллекций.
Пример использования цикла foreach:
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
// Объявляем два массива
int[] myArr = new int[5];
int[,] myTwoArr = new int[5, 6];
int sum = 0;
Random ran = new Random();
// Инициализируем массивы
for (int i = 1; i
Попробуйте запустить данный пример несколько раз и вы наглядно увидите, что элементы массива изменяются каждый раз (с помощью метода Random.Next), и соответственно опрашиваются в цикле foreach. Мой результат:
Источник
В этой части учебника рассмотрим циклы в PHP 7, вы научитесь выходить из него и делать бесконечные циклы.
Для начала разберём, для чего вообще нужны циклы, всё очень просто, в первую очередь они нужны для того чтобы не повторять код, вот и всё.
PHP циклы:
В PHP есть несколько циклов, а конкретно четыре, сейчас мы все их рассмотрим.
Цикл while:
Этот цикл пожалуй самый простой из всех, вот его синтаксис.
$i = 0; // Создаём переменную и присваиваем ей ноль // Пишем цикл while while ($i < 10) { echo $i . ‘ ‘; // Выводим переменную $i $i++; // Увеличиваем переменную $i на один } |
Вот такой код получился, создаём переменную $i которую будим выводить на экран и увеличивать на один после каждой итерации цикла
(Итерация — один проход по циклу), после ключевого слова while в круглых скобках обязательно пишем условие при которых будет работать цикл, в нашем случае, пока $i не станет равен 10.
Вот что вывелось на экран.
Также, его можно записать в удобной форме для верстальщика.
$i = 0; // Создаём переменную и присваиваем ей ноль // Пишем цикл while while ($i < 10) : echo $i . ‘ ‘; // Выводим переменную $i $i++; // Увеличиваем переменную $i на один endwhile |
Этот цикл достаточно популярен в PHP разработке, поэтому обязательно запомните его.
Благодаря этому циклу в PHP можно делать бесконечный цикл, что редко но бывает полезно, вот как он пишется.
$i = 0; // Создаём переменную и присваиваем ей ноль // Пишем цикл while бесконечным while (true) { echo $i . ‘ ‘; // Выводим переменную $i $i++; // Увеличиваем переменную $i на один } |
Как видите, что бы сделать его бесконечным, достаточно только в условие цикла, написать true, вот что получилось.
Также ещё делают переменную, а в цикли условие, при каких обстоятельствах переменная будет меняться на false, и если она равно false, то цикл заканчивается, как это сделать будет ниже.
Цикл do while:
Этот цикл очень похож на предыдущий, единственное, обязательно хотя бы один раз произойдёт итерация, так как он проверяет условие после итерации, а не перед неё.
$i = 0; // Создаём переменную и присваиваем ей ноль // Пишем цикл do while, в начале всегда пишем do do { echo $i . ‘ ‘; // Выводим переменную $i $i++; // Увеличиваем переменную $i на один } while ($i < 10); // Условие пишется в конце цикла |
Вид для верстальщиков у этого цикла нет, но и как показывает мой опыт, он редко используется, по крайне мере я его редко вижу, в основном вы будите использовать обычный while.
Цикл for:
Это наверное самый популярный цикл во многих языках программирования, но не в PHP, тем не менее, о нём рассказать надо.
// Пишем цикл for for ($i = 0; $i < 10; $i++) { echo $i . ‘ ‘; // Выводим переменную $i } |
Давайте разберём его, в начале в круглых скобках пишется переменная, которую будем увеличивать на один, потом переменная увеличиваться на один, идёт проверка чему в итоге равна она.
И так пока переменная не будет равна десяти, конечно, вам не обязательно создавать переменную или увеличивать её, вы можете вообще это не писать.
Также вы можете использовать другие операции и условия, к примеру, $i можете присвоит один и уменьшать её на один, пока переменная не будет равна нулю.
Ещё у этого цикла есть вид для верстальщиков.
// Пишем цикл for for ($i = 0; $i < 10; $i++) : echo $i . ‘ ‘; // Выводим переменную $i endfor; |
Этот цикл тоже не особо популярен.
Цикл foreach:
Этот цикл очень популярен, но он сделан для работы с массивами, поэтому, рекомендую сначала прочитать часть про массивы (Ссылка на часть), потом уже переходить к циклу foreach.
Цикл foreach в PHP его синтаксис достаточно простой, их целых два, различие лишь в том, что один вариант не берёт ключ значения массива, а второй берёт, рассмотрим их оба.
// Объявление массива $arr $arr = array(1, 2, 3, 4); // Запуск цикла foreach foreach ($arr as $value) { echo $value . ‘ ‘; // Вывод значений массива на экран } |
Вот результат.
Как видите он вывел на экран значения массива, сначала в круглых скобках пишется сам массив, потом слово as и название переменной, оно может быть любое, эту переменную используем как обычную переменную внутри цикла, равна она одному значению массива, и при каждой итерации, оно меняется на следующее значение.
Также можем получить ключ каждого значение, делается это так.
// Объявление массива $arr $arr = array(80, 12, 44, 15); // Запуск цикла foreach foreach ($arr as $key => $value) { echo $key . ‘ => ‘ . $value . ‘</br>’; // Вывод ключа и значений массива на экран } |
Вот результат.
Как видите, слева показывается индекс (ключ) значения, а справа само значение, точно также как и переменная, ключ это переменная.
Также у foreach есть вид специально для верстальшиков.
// Объявление массива $arr $arr = array(80, 12, 44, 15); // Запуск цикла foreach для верстальшиков foreach ($arr as $key => $value) : echo $key . ‘ => ‘ . $value . ‘</br>’; // Вывод ключа и значений массива на экран endforeach |
Если вам было что то не понятно, то наверное вам надо сначала изучить массивы, а потом уже и цикл foreach.
PHP выйти из цикла:
Что бы в PHP выйти из цикла, есть два способа, первый, просто сделать переменную которая будет равна true, а в цикле условий и кода оно выполняется менять переменную на false.
$i = 0; // Создаём переменную и присваиваем ей ноль $cycle_works = true; // Переменная, которая отвечает за работу в цикли // Пишем цикл while while ($cycle_works) { echo $i . ‘ ‘; // Выводим переменную $i $i++; // Увеличиваем переменную $i на один // Условие при котором надо менять значение переменной $cycle_work if ($i == 10) { $cycle_works = false; // меняем значение переменной } } |
Это очень простой способ, но на мой взгляд, это редко бывает полезно, но возможно кому то полезно.
Второй вариант, в том, что бы в PHP использовать break и continue, сейчас вы узнаете о них.
Continue:
Как же использовать в PHP в цикле while continue, всё очень просто.
$i = 0; // Создаём переменную и присваиваем ей ноль while ($i < 5) { $i++; // Увеличиваем переменную на один // условие при котором должен выходить цикл if ($i == 2) { continue; // Выход из цикла } echo $i . ‘ ‘; // Отображение $i } |
Вот результат.
Как видите цифра два не вывелась, но почему же вывелись остальные, дела в том, что continue выходит из цикла перед циклом, при этом переменная $i не обнуляется.
То есть, то что идёт после continue не будет работать, при этом цикл снова пройдётся без изменений, надеюсь мне удалось понятно это объяснить.
break:
В PHP это почти тоже самое, что и continue, но выходит из цикла уже после него, то есть цикл больше не будет проходить, сейчас покажу это на примере while break.
$i = 0; // Создаём переменную и присваиваем ей ноль while ($i < 5) { $i++; // Увеличиваем переменную на один // условие при котором должен выходить цикл if ($i == 2) { break; // Выход из цикла } echo $i . ‘ ‘; // Отображение $i } |
Результат этого кода.
Так получается, потому что, когда переменная $i, становится равна двум, то срабатывает break и выходит из цикла, после цикла, не успев вывести на экран.
Но на мой взгляд лучше делать правильные условия работы цикла, чем использовать break и continue.
Вывод:
Тут я разобрал как работают в PHP 7 циклы, разобрали циклы while, do while, for, и foreach, ещё рассмотрели break с continue.
Подписываетесь на соц-сети:
Оценка:
Загрузка…
Дополнительно:
Источник
Дело было вечером, делать было нечего. Самое время устроить небольшой разбор того, чем изнутри отличаются некоторые способы перебора массивов в PHP.
Исходники от master ветки (это сейчас 7.4 с вкраплениями 8)
Генератор опкодов от php 7.3.0.
Замеры производились на 7.3.6.
Дисклеймер для зануд: упоминание пары наносекунд и тактов процессора – это такой полемический приём под названием «гипербола».
Может быть, на самом деле, там десятки или сотни наносекунд и тысячи тактов, но это всё равно настолько малые величины, что необходимость экономить на них говорит о том, что что-то в вашем коде не так.
Этап компиляции
for, foreach, do и while являются ключевыми словами языка, тогда как функции array_* – это функции стандартной библиотеки. Следовательно, при прочих равных, по первым парсер отработает на пару наносекунд быстрее.
Парсер
До токена statement путь будет одинаков для всех
start -> top_statement_list -> top_statement -> statement
Циклы определены на уровне statement:
->T_FOR ‘(‘ for_exprs ‘;’ for_exprs ‘;’ for_exprs ‘)’ for_statement
->T_FOREACH ‘(‘ expr T_AS foreach_variable ‘)’ foreach_statement
->T_FOREACH ‘(‘ expr T_AS foreach_variable T_DOUBLE_ARROW foreach_variable ‘)’ foreach_statement
->T_DO statement T_WHILE ‘(‘ expr ‘)’ ‘;’
->T_WHILE ‘(‘ expr ‘)’ while_statement
Отличие for_exprs от просто expr только в том, что для первого допустима запись нескольких expr через запятую.
foreach_variable – это конструкция, которая помимо просто variable, также отслеживает распаковку с помощью list или [].
for_statement, foreach_statement, while_statement отличаются от стандартного statement тем, что в них добавлена возможность разбора альтернативного синтаксиса:
foreach($array as $element):
#do something
endforeach;
Вызов функций закопан гораздо глубже:
-> expr -> variable -> callable_variable -> function_call -> name argument_list
callable_variable, хм… Забавно, не правда ли? 🙂
Перейдём к опкодам
Для примера давайте возьмём простой перебор индексированного массива с печатью каждого ключа и значения. Понятно, что использование for, while и do для такой задачи не оправдано, но у нас цель просто показать внутреннее устройство.
foreach
$arr = [‘a’, ‘b’, ‘c’]; // в дальнейших примерах будем использовать его же
foreach($arr as $key => $value) echo $key.$value;
line #* E I O op fetch ext return operands
—————————————————————————
2 0 E > ASSIGN !0, <array>
4 1 > FE_RESET_R $4 !0, ->7
2 > > FE_FETCH_R ~5 $4, !1, ->7
3 > ASSIGN !2, ~5
4 CONCAT ~7 !2, !1
5 ECHO ~7
6 > JMP ->2
7 > FE_FREE $4
5 8 > RETURN 1
Что тут происходит:
FE_RESET_R: создаёт итератор $4 для массива !0. Либо, если массив пуст, сразу переходит к инструкции 7.
FE_FETCH_R: совершает шаг итерации, извлекает текущий ключ в ~5, а значение в !1. Либо, если достигнут конец массива, переходит к инструкции 7.
Инструкции 3-6 не особо интересны. Тут происходит вывод и возврат к FE_FETCH_R.
FE_FREE: уничтожает итератор.
for, while, …
$length = count($arr);
for($i = 0; $i < $length; $i++) echo $i.$arr[$i];
На самом деле это частный случай while
$i = 0;
while($i < $length) {
echo $i.$arr[$i];
$i++;
}
На самом деле это частный случай if+goto
$i = 0;
goto check;
body:
echo $i.$arr[$i];
$i++;
check:
if($i < $length) goto body;
Опкоды для всех трёх случаев будут практически идентичны. Разве что в случае с if, JMPNZ поменяется на пару JMPZ+JMP из-за входа в тело if‘а.
Для цикла do опкоды будут незначительно отличаться из-за его постпроверочной природы.
line #* E I O op fetch ext return operands
—————————————————————————
3 0 E > ASSIGN !0, <array>
5 1 COUNT ~4 !0
2 ASSIGN !1, ~4
6 3 ASSIGN !2, 0
4 > JMP ->10
5 > FETCH_DIM_R ~7 !0, !2
6 CONCAT ~8 !2, ~7
7 ECHO ~8
8 POST_INC ~9 !2
9 FREE ~9
10 > IS_SMALLER ~10 !2, !1
11 > JMPNZ ~10, ->5
12 > > RETURN 1
Опкодов, ожидаемо, стало больше.
0-2: вычисление $length.
3: $i = 0
4, 10, 11: первичная проверка условия выхода и, собственно, либо выход, либо переход к телу цикла.
5(FETCH_DIM_R): $arr[$i]
6-7: вывод
8-9: $i++ (обратите внимание, что опкод инкремента в любом случае возвращает значение, даже если оно не нужно. Поэтому требуется дополнительная инструкция FREE, для его очистки).
10-11: проверка условия выхода после инкремента.
А можно ещё и так поитерировать
$value = reset($arr);
$key = key($arr);
while($key !== null) {
echo $key.$value;
$value = next($arr);
$key = key($arr);
}
Простыня, так что под спойлер
—————————————————————————
3 0 E > ASSIGN !0, <array>
5 1 INIT_FCALL ‘reset’
2 SEND_REF !0
3 DO_ICALL $4
4 ASSIGN !1, $4
6 5 INIT_FCALL ‘key’
6 SEND_VAR !0
7 DO_ICALL $6
8 ASSIGN !2, $6
7 9 > JMP ->20
8 10 > CONCAT ~8 !2, !1
11 ECHO ~8
9 12 INIT_FCALL ‘next’
13 SEND_REF !0
14 DO_ICALL $9
15 ASSIGN !1, $9
10 16 INIT_FCALL ‘key’
17 SEND_VAR !0
18 DO_ICALL $11
19 ASSIGN !2, $11
7 20 > IS_NOT_IDENTICAL ~13 !2, null
21 > JMPNZ ~13, ->10
11 22 > > RETURN 1
Этот вариант хорош тем, что подходит для итерации по массиву с любыми ключами, а не только с монотонно возрастающими целыми числами.
Функции reset, next и key довольно легковесные, но накладные расходы на их вызов всё же есть. И, как мы увидим дальше, расходы эти велики.
Хотя такой подход очень сильно напоминает принцип работы foreach, между ними есть два принципиальных отличия.
1) Тогда как reset, next и key (и current тоже) работают напрямую с внутренним указателем массива, foreach использует собственный итератор и не меняет состояние внутреннего указателя.
Т.е.
foreach($arr as $v) echo $v.’ – ‘.current($arr).PHP_EOL;
//—————-
a – a
b – a
c – a
2) При использовании foreach для итерации по значению, что бы вы не делали с массивом внутри цикла, проитерирован будет именно первоначальный набор данных
foreach($arr as $v) {
$arr = [‘X’,’Y’,’Z’];
echo $v.PHP_EOL;
}
var_dump($arr);
//—————-
a
b
c
array(3) {
[0]=>
string(1) “X”
[1]=>
string(1) “Y”
[2]=>
string(1) “Z”
}
Что будет при итерации по ссылке, можно почитать в этом RFC. Там всё не очень просто.
array_walk с анонимной функцией
array_walk($arr, function($value, $key){ echo $key.$value;});
Так как используется пользовательская функция, то будет дополнительный набор опкодов.
Функция
line #* E I O op fetch ext return operands
—————————————————————————
0 E > RECV !0
1 RECV !1
2 CONCAT ~2 !1, !0
3 ECHO ~2
4 > RETURN null
Основной код
line #* E I O op fetch ext return operands
—————————————————————————
2 0 E > ASSIGN !0, <array>
4 1 INIT_FCALL ‘array_walk’
2 SEND_REF !0
3 DECLARE_LAMBDA_FUNCTION ‘%00%7Bclosure%7D%2Fin%2FHuNEK0x7f9fa62d105a’
4 SEND_VAL ~2
5 DO_ICALL
6 > RETURN 1
Поскольку array_walk, как и остальные функции стандартной библиотеки, является интринсиком, то в скомпилированных опкодах механизм итерации отсутствует.
INIT_FCALL: инициализируем вызов array_walk
SEND_REF: кладём ссылку на массив на стек вызова
DECLARE_LAMBDA_FUNCTION: объявляем анонимную функцию
SEND_VAL: кладём анонимную функцию на стек вызова
DO_ICALL: запускаем array_walk на выполнение
Далее там происходит магия с вызовом нашей лямбды для каждого элемента массива.
array_walk с использованием предопределённой функции
Не сильно отличается от вызова с анонимной, разве только чуть меньше накладных расходов на создание лямбды во время исполнения.
line #* E I O op fetch ext return operands
—————————————————————————
3 0 E > ASSIGN !0, <array>
9 2 INIT_FCALL ‘array_walk’
3 SEND_REF !0
4 SEND_VAL ‘my_echo’
5 DO_ICALL
6 > RETURN 1
Выводы банальны. foreach заточен под итерирование массивов, тогда как остальные циклы – просто обёртка над if+goto.
Функции же стандартной библиотеки работают по принципу чёрного ящика.
Погружаемся чуть глубже
Для начала рассмотрим случай с for и его опкодом FETCH_DIM_R, использующимся для извлечения значения по ключу. Извлечение элемента идёт через поиск в хеш-таблице (ZEND_HASH_INDEX_FIND). В нашем случае извлечение идёт из упакованного массива (ключи – непрерывная числовая последовательность) – это довольно лёгкая и быстрая операция. Для неупакованных массивов она будет чуть подороже.
Теперь foreach (FE_FETCH_R). Тут все банально:
- Проверяем, не вышел ли указатель итератора за пределы массива
- Извлекаем текущие ключ и значение
- Инкрементируем указатель
Ну а что происходит с функциями типа array_walk? Хоть все они делают разные вещи, но в основе у них у лежит один и тот же принцип.
Если совсем упрощённо, то (псевдокод):
reset_pointer()
do {
value = get_current_value()
if (value == NULL) break // Именно NULL, а не zval типа NULL
key = get_current_key()
call_function(myFunction, key, value)
increment_pointer()
} while(true)
На самом деле внутри всё сложнее, но суть одна – идёт довольно быстрый перебор хеш-таблицы без участия виртуальной машины PHP (не учитывая вызова пользовательской функции).
Ну и немного замеров
А то ведь какая же статья без замеров (по памяти получилось настолько одинаково, что убрал её измерение).
В качестве массива, по традиции, возьмём zend_vm_execute.h на 70.108 строк.
Скрипт замера под спойлером
$array = explode(“n”, file_get_contents(‘/Users/rjhdby/CLionProjects/php-src/Zend/zend_vm_execute.h’));
function myEcho($key, $value){
echo $key . $value;
}
ob_start();
$startTime = microtime(true);
for ($i = 0; $i < 10; $i++) {
// foreach ($array as $key => $value) {
// echo $key . $value;
// }
// foreach ($array as $key => &$value) {
// echo $key . $value;
// }
// $length = count($array);
// for ($j = 0; $j < $length; $j++) {
// echo $j . $array[$j];
// }
// array_walk($array, function($value, $key) {
// echo $key . $value;
// });
// array_walk($array, static function($value, $key) {
// echo $key . $value;
// });
// array_walk($array, ‘myEcho’);
// $value = reset($array);
// $key = key($array);
// while($key !== null) {
// echo $key.$value;
// $value = next($array);
// $key = key($array);
// }
}
$endTime = microtime(true);
ob_clean();
echo “time: ” . ($endTime – $startTime);
Каждое измерение запускал раз по 10, выбирая наиболее часто встречающееся по первым 4-м цифрам.
foreach time: 0.12159085273743
foreach(reference) time: 0.11191201210022
for, while time: 0.13130807876587
array_walk(lambda) time: 0.87953400611877
array_walk(static lambda) time: 0.87544417497211
array_walk(name) time: 0.50753092765808
next,key time: 1.06258893013
Подведём итоги
Анализируя результаты, не забываем учитывать, что они получены на 10 проходах по массиву из 70 тысяч элементов.
Абсолютным антигероем оказалась «эмуляция» foreach с помощью next/key. Не делайте так без крайней на то необходимости.
array_walk с лямбдой дышит ему в спину, но тут есть нюанс. Грядущий JIT может кардинально изменить ситуацию. А может и не изменить. Интересно будет посмотреть.
array_walk с использованием готовой функции – крепкий середнячок.
Так как при итерации по ссылке foreach работает несколько иначе (использует опкод FE_FETCH_RW вместо FE_FETCH_R), то сделал для него отдельный замер. Он действительно чуть-чуть быстрее получился.
Как оказалось, создание лямбды на лету – не самая дешёвая операция. Казалось бы, создаётся она всего 10 раз. Надо будет поизучать.
Все остальные способы показали примерно одинаковые результаты, с очень незначительным разрывом.
Спасибо за внимание!
Если есть предложения, что ещё можно «поковырять» – пишите в комментариях. Я пока подумываю о лямбдах – уж очень странна такая просадка производительности.
UPD
Добавил замер для array_walk со статической лямбдой. Разницы не видно.
Источник