Цикл For Loop в VBA – один из самых популярных циклов в Excel. Данный цикл имеет две формы – For Next и For Each In Next. Данные операторы используются для последовательного перемещения по списку элементов или чисел. Для завершения цикла мы можем в любой момент использовать команду выхода. Давайте подробнее рассмотрим каждый из этих циклов.
VBA цикл For Next
Цикл For Next имеет следующий синтаксис:
То что мы делаем здесь, по существу, это создаем цикл, который использует переменную счетчик как хранитель времени. Устанавливаем его значение равным начало_счетчика , и увеличиваем (или уменьшаем) на 1 во время каждого витка. Цикл будет выполняться до тех пор, пока значение счетчик не станет равным конец_счетчика. Когда оба эти значения совпадут, цикл выполнится последний раз и остановится.
Пример цикла
счетчик будет равным 11
VBA обратный цикл For Loop с инструкцией STEP
Если у вас появилась необходимость перемещаться от большего значения к меньшему – вы можете использовать цикл в обратном направлении. Вот пример обратного цикла:
Последнее значение переменной счетчик будет равным 1.
Как вы могли заметить, мы можем использовать инструкцию Step n для работы цикла как вперед, так и в обратном направлении. По умолчанию значение Step равно 1, но оно может быть изменено, если необходимо пропускать какие-либо значения, тогда значение n будет больше одного, или перемещаться в обратном направлении, тогда n будет отрицательным.
VBA цикл For Each … Next
Цикл For Each … Next имеет следующий цикл:
Здесь переменная элемент_группы принадлежит к группе_элементов (железная логика!!!). Я имею в виду, что объект группа_элементов должен быть коллекцией объектов. Вы не сможете запустить цикл For Each для отдельно объекта (Microsoft сразу оповестит вас об этом 438-й ошибкой).
Данный цикл перебирает все элементы какой-либо коллекции, начиная с самого первого. Вы можете использовать данный цикл, если вам необходимо, например, обойти все листы в книге, объекты на листе, сводные таблицы и т.д.
Ниже представлен пример, как можно воспользоваться циклом For Each для просмотра всех листов книги:
… либо всех сводных таблиц на листе
Прерывание цикла VBA
Если вам необходимо выйти из цикла до момента, как будет достигнуто условие завершения цикла, воспользуйтесь командой End For в связке с инструкцией IF . В примере, приведенном ниже, мы выйдем из цикла до момента достижения условия завершения, в данном цикле выход будет осуществлен при условии, когда переменная счетчик будет равна 3.
Пропуск части цикла в For Each
Пропускать часть цикла, а затем возвращаться назад – плохая практика. Тем не менее, давайте рассмотрим пример:
Здесь мы пропустили одну итерацию (когда j = 3). Как вы думаете, какой результат выдаст программа? 3? 5? Ну… на самом деле, ни один из вариантов не верный. Цикл будет выполняться бесконечно, пока память компьютера не переполнится.
Однако возможность пропустить шаг цикла без последствий существует. Вы можете увеличить значение счетчика на 1 (или другое значение), что приведет к пропуску операций, находящихся между этими значениями. Вот пример:
Но опять же, это плохая практика написания кода, и может привести к нежелательным последствиям при написании кода в будущем. Вместо этого, при необходимости пропуска некоторых итераций, попробуйте использовать функцию If или Select Case.
Иногда сложно найти в Сети правильные, а главное актуальные «best practices» для языка. Документация, конечно же, содержит всю необходимую информацию, но отсеять нужную вещь в абзацах подробного (на то она и документация) описания довольно сложно. Но недавно мне улыбнулся поиск Google, и я наткнулся на очень полезные «паттерны» языка Python от одного из core разработчиков - Raymond Hettinger.
Примечание
: Все рекомендации даны в нескольких вариантах: сначала идут самые «плохие» варианты, а дальше предлагается лучшая альтернатива. Актуально для версии языка 2.7, отличия для версии 3.3 читайте в примечаниях к конкретному «паттерну».
Цикл по массиву из чисел
Плохо : иногда пишут так.for i in : print i**2
Хорошо : лучший, с генератором. Но в 32 битной системе список из миллиона чисел будет занимать ~ 32 mb памяти.
for i in range(6): print i**2
Отлично: самый лучший вариант. В отличии от второго xrange возвращает только одно значение за раз, и не нужно лишнюю память для хранения всего массива.
for i in xrange(6): print i**2
Примечание : В версии Python 3.3 xrange уже в ядре и называеться просто range .
Цикл по списку
Плохо : часто бывшие С программисты пишут так.colors = ["red", "green", "blue", "yellow"] for i in range(len(colors)): print colors[i]
Хорошо : лучший вариант.
colors = ["red", "green", "blue", "yellow"] for color in colors: print color
Но если нужно пройти по списку задом на перед?
Плохо
: опять, прошло из C дает о себе знать:
colors = ["red", "green", "blue", "yellow"]
for i in range(len(colors)-1, -1, -1):
print colors[i]
Хорошо
: но в Python пишут вот так:
colors = ["red", "green", "blue", "yellow"]
for color in reversed(colors):
print color
Цикл по списку с индексами
Плохо тоже что и выше.colors = ["red", "green", "blue", "yellow"] for i in range(len(colors)): print i, "-->", colors[i]
Хорошо : более элегантный вариант:
colors = ["red", "green", "blue", "yellow"] for i, color in enumerate(colors): print i, "-->", color
Цикл по двум спискам
Плохо тоже что и выше.names = ["raymond", "rachel", "matthew"] colors = ["red", "green", "blue", "yellow"] n = min(len(names), len(colors)) for i in range(n): print names[i], "-->", colors[i]
Хорошо : с двух списков делаем один список кортежей. Проблема в том что zip использует больше памяти чем первый вариант.
names = ["raymond", "rachel", "matthew"] colors = ["red", "green", "blue", "yellow"] for name, color in zip(names, colors): print name, "-->", color
Отлично : в отличии от zip , izip использует кэширование, что помогает существенно сэкономить память.
names = ["raymond", "rachel", "matthew"] colors = ["red", "green", "blue", "yellow"] for name, color in izip(names, colors): print name, "-->", color
Примечание : В версии Python 3.3 izip вписан в ядро и называется просто zip .
Сортировка списка по алгоритму
Плохо : используя функцию для сравнения.colors = ["red", "green", "blue", "yellow"] def compare_length(c1, c2): if len(c1) < len(c2): return -1 if len(c1) > len(c2): return 1 return 0 print sorted(colors, cmp=compare_length)
Хорошо
: используя сортировку по ключу. Использует намного меньше памяти.
colors = ["red", "green", "blue", "yellow"]
print sorted(colors, key=len)
Примечание
: Метод cmp убран с ядра Python 3.x.
Цикл по ключам словаря
Обычный способ возвращает ключи. При таком цикле происходит итерация словаря, поэтому в процессе его изменять нельзя.for k in d: print k
Для изменения словаря в цикле используйте цикл по ключам (Пример: удаление всех ключей начинающихся с R):
for k in d.keys(): if k.startswith("R"): del d[k]
В этом случае d.keys() делает копию ключей словаря, что позволяет нам свободно работать с оригинальной структурой.
Цикл по ключам и значением словаря
Плохо : цикл по ключам и возвращение значение по последним. Медленный способ:for k in d: print k, "-->", d[k]
Хорошо : быстрее делать цикл по значениях:
for k, v in d.items(): print k, "-->", v
Отлично : Но самый лучший и быстрый способ это использовать итератор:
for k, v in d.iteritems(): print k, "-->", v
Соединение двух списков в один словарь
Очень быстрый метод, используется только один кортеж для генерации словаря.names = ["raymond", "rachel", "matthew"] colors = ["red", "green", "blue"] d = dict(izip(names, colors)) # d будет иметь следующее значение: # {"matthew": "blue", "rachel": "green", "raymond": "red"}
Подсчет элементов в словаре
Плохо : обычный способ:colors = ["red", "green", "red", "blue", "green", "red"] d = {} for color in colors: if color not in d: d = 0 d += 1 #{"blue": 1, "green": 2, "red": 3}
Хорошо : использует функцию get() :
colors = ["red", "green", "red", "blue", "green", "red"] d = {} for color in colors: d = d.get(color, 0) + 1
Отлично : самый продвинутый способ это использовать defaultdict() . Но вы должны знать как он работает .
d = defaultdict(int) for color in colors: d += 1
Группирование элементов списка
Плохо : если нужно сгруппировать элементы списка по некоторому признаку (в примере - длина строки) часто используют такой метод:names = ["raymond", "rachel", "matthew", "roger", "betty", "melissa", "judith", "charlie"] d = {} for name in names: key = len(name) if key not in d: d = d.append(name) {5: ["roger", "betty"], 6: ["rachel", "judith"], 7: ["raymond", "matthew", "melissa", "charlie"]}
Хорошо : но есть способ гораздо элегантней и быстрее:
d = defaultdict(list) for name in names: key = len(name) d.append(name)
Итог
На сегодня все. Надеюсь эти тривиальные, но полезные примеры помогут кому-то улучшить свой код, как они помогли это сделать мне. Их автором является Raymond Hettinger (Массив в языке Perl - это переменная, которая содержит в себе список значений. Имя переменной массива начинается с символа @. И это достаточно логично - символ @ основан на букве a, именно с этой буквы начинается слово array - массив.
Массив в Perl может хранить в себе список значений любых типов. Может быть массив в котором одновременно хранятся и строки, и числа, и что-нибудь еще.
Определение массива и доступ к элементам
Вот простой скрипт с примером определения и использования элементов массива в Perl:
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; my @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); say $names; say $names;
Если запустить этот скрипт, то он выведет на экран:
Homer Bart
Что здесь происходит. Сначала стандартная строка с которой начинаются все Perl скрипты #!/usr/bin/perl, потом идет подключение (use) нескольких фич языка, которые делают работу с Perl удобнее. А потом создается переменная @names и ей присваивается список из 5 строк.
Как и во многих языках программирования в Perl первый элемент массива получает номер 0. После выполнения этой операции в переменной @names оказывается следующее:
- в этой переменной под номером 0 хранится строка "Homer"
- под номером 1 хранится строка "Marge"
- 2 - "Bart"
- 3 - "Lisa"
- 4 - "Maggy"
Для того чтобы достать из переменной @name элемент с номером 2 используется совершенно идиотская форма - $name. Вот тут супер нелогично что символ @ заменятся на символ $ Официальное объяснение этой глупости - мы хотим получить доступ к одному элементу, а переменная с одним элементом начинается с символа $ Но это просто ошибка в дизайне языка. В Perl версии 6 это исправлено. Но в Perl версии 5 приходится жить с этим.
Say $names;
говорит - выводи на экран то что находится в массиве под номером 0. Под номером 0 в массиве находится строка "Homer" - она и появляется на экране.
Определение массивов. Дополнение.
Только что мы определи массив с помощью такого кода:
My @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie");
Когда элементов в массиве много, то удобнее их писать в столбик:
My @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie");
В языке Perl нет проблемы JSON - в Perl разрешено указывать запятую после последнего элемента:
My @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie",);
(На самом деле, если вы перечисляете элементы массива в столбик, то стоит всегда указывать запятую после последнего элемента - это делает проще работу с кодом и упрощает чтение diff).
Если в массиве находятся строки текста в которых нет пробелов, то есть еще более простой способ определить массив - использовать оператор qw:
My @names = qw(Homer Marge Bart Lisa Maggie);
Оператор qw разрезает текст который ему передан по пробельным символам и создает элементы списка.
Если нужно создать массив из списка чисел которые идут подряд, то можно использовать оператор..
My @array = (1..5);
Это то же самое что:
My @array = (1, 2, 3, 4, 5);
Оператор.. так же работает с буквами:
My @array = ("a".."z");
Эту фичу языка можно использовать в простом perl однострочнике, для генерации паролей:
$ perl -E "@c = ("a".."z", "A".."Z", 0..9); $s .= $c for (1..12); say $s" eIryv0884sp7
Вывод массивов
Иногда во время разработки программы нужно посмотреть что находится внутри массива. Для этого можно использовать библиотеку Data::Dumper:
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; my @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); use Data::Dumper; say Dumper \@names;
Вот вывод этого скрипта:
$VAR1 = [ "Homer", "Marge", "Bart", "Lisa", "Maggie" ];
Если у вас есть Perl, то у вас библиотека Data::Dumper. Но если вы поставите дополнительно библиотеку Data::Printer, то для вывода содержимого массива придется писать меньше букв:
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; my @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); use DDP; p \@names;
И вывод скрипта гораздо приятнее:
Длина массива
Задача. У нас есть массив @names, нужно узнать его размер - сколько в нем находится элементов. Есть несколько способов это сделать. Можно использовать специальную переменную в которой содержится индекс последнего элемента, а можно воспользоваться фичей Perl под названием "контекст".
Когда появляется массив, автоматически появляется специальная переменная, которая указывает на индекс последнего элемента. У нас есть массив @names в котором содержится 5 элементов и для него существует переменная $#names в которой содержится число 4 (так как элементы нумеруются с 0, а не с 1). Если количество элементов в массиве изменится, то автоматически изменится и $#names.
Первый способ узнать количество элементов в массиве - это взять $#names и прибавить единицу:
Say $#names + 1;
Этот способ работает и совершенно корректен, но более правильный способ - это использовать "контекст":
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; my @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); my $number = @names; say $number;
Что же здесь происходит? Сначала все то же самое что и в прошлом скрипте, но потом выполняется:
My $number = @names;
Мы создаем новую переменную $number В начале имени этой переменной находится символ $ - это означает что тип этой переменной - скаляр. Символ $ совершенно логичен - это символ похож на букву s с которой начинается слово scalar. Скаляр или скалярная переменная - это переменная в которой содержится только одно значение. Это может быть строка, число или что-нибудь еще.
И тут появляется контекст. Контекст - это весьма важная вещь в языке программирования Perl. В языке Perl в зависимости от контекста (т.е. от того что рядом) разные вещи действуют по разному. Контекст - это сложная вещь. Но для того чтобы программировать на Perl нужно разобраться ка работает контекст.
Выражение my $number = @names; означает что мы взяли массив и использовали его в "скалярном контексте". В скалярном контексте массива - это количество элементов в нем, т.е. ровно то что мы хотели получить.
Вот еще один пример использования контекста. Можно использовать массив в списочном контексте:
My ($man, $woman) = @names;
Результат этой операции - в скалярной переменной $man будет находится строка "Homer", а в скалярной переменной $woman будет находится строка "Marge".
В скрипте мы сначала присваивали массив в скалярную переменную, а потом выводили значение этой переменной:
My $number = @names; say $number;
А что будет если сразу вывести на экран значение массива @names ?
Say @names
Вот результат:
HomerMargeBartLisaMaggy
Такой вывод сильно отличается от числа 5. Объяснение этому - контекст. Ключевое слово say работает в списочном контексте. say выводит на экран все элементы списка который ей передали. Но можно явно указать что мы хотим работать с массивом в скалярном контексте:
Say scalar @names;
В этом случае вывод будет 5.
Работа с массивом
Бывают задачи когда нужно только создать массив, а дальше только читать из него значения. Но чаще встречаются задачи когда массив нужно изменять. Для этого есть несколько удобных функций.
Добавление элемента в конец массива:
My @arr = (1, 2, 3); push @arr, "abc";
Результат этой операции - в массиве @arr будет список (1, 2, 3, "abc");
С помощью push можно добавить в массив несколько элементов:
My @arr = (1, 2, 3); push @arr, "abc", "def";
Результат этой операции - в массиве @arr будет список (1, 2, 3, "abc", "def");
Интересная особенность push, про которую мало кто знает - эта функция не только меняет массив, но еще и возвращает число - сколько элементов стало в массиве после добавления в массив всех указанных элементов. Так что задачу "найти количество элементов в массиве" можно решить вот таким супер извращенным способом:
My $number = push(@arr, 1) - 1;
Функция push добавляет элемент (или элементы) в конец массива. В Perl есть функция для обратной операции - достать из массива последний элемент. Это делается с помощью функции pop (с помощью этой функции достать несколько элементов нельзя, эта функция достает только один элемент).
My @arr = (1, 2, 3); my $smth = pop @arr;
После выполнения кода выше массив @arr будет состоять из двух элементов (1, 2), а в переменной $smth будет находится число 3.
С помощью функций push/pop можно работать с массивом как со стеком.
Кроме функций push/pop, которые добавляют/убирают элементы в конце массива еще есть функции shift/unshift, которые работают с началом массива.
Добавить элемент в начало массива:
My @arr = (1, 2, 3); unshift @arr, "abc";
После выполнения этих команд в массиве @arr будет находится список ("abc", 1, 2, 3)
С помощью unshift можно добавить несколько элементов в начало массива:
My @arr = (1, 2, 3); unshift @arr, "abc", "def";
После выполнения этих команд в массиве @arr будет находится список ("abc", "def", 1, 2, 3)
Точно так же как push, unshift возвращает число - количество элементов в массиве после добавления туда всех элементов.
Достать из массива первый элемент можно с помощью функции shift:
My @arr = (1, 2, 3); my $element = shift @arr;
После выполнения этих действий массив станет состоять из двух элементов (2, 3), а в переменной $element будет бывший первый элемент массива - число 1.
- unshift добавляет элемент/элементы в начало массива
- shift достает элемент из начала массива
- push добавляет элемент/элементы в конец массива
- pop достает элемент из конца массива
Итерация по массиву
Часто бывают задача - нужно пробежаться по всем элементам массива и выполнить с ними какое-то действие.
В Perl, как и во множестве других языков программирования есть цикл for. Вот как пройти по всем элементам массива с помощью for:
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; my @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); for (my $i = 0; $i <= $#names; $i++) { say $names[$i]; }
Вот вывод этой программы:
Homer Marge Bart Lisa Maggie
Тут все стандартно и просто. Определили $i = 0, проверили что условие выполняется, выполнили тело цикла, увеличили счетчик, проверили что условие выполняется, выполнили тело цикла, увеличили счетчик, ...
Но Perl предоставляет более простой и удобный способ итерации по массиву:
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; my @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); foreach my $name (@names) { say $name; }
В этом варианте в переменную $name по очереди заносятся все элементы массива. Такой вариант проще и читать, и писать.
В Perl есть интересная фича - переменная по умолчанию. Если ну указать переменную для foreach, то perl будет заносить все элементы массива в переменную по умолчанию $_ :
Foreach (@names) { say $_; }
А если для say не указать никаких параметров, то say будет работать с переменной по умолчанию. Так что этот же цикл можно написать так:
Foreach (@names) { say; }
А еще в Perl можно использовать постфиксную запись для foreach, поэтому этот же цикл можно записать:
Say foreach @names;
В Perl есть цикл while, и его тоже можно использовать для итерации по массиву. Например так (аккуратно, в таком использовании кроется опасность):
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; my @names = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); while (my $name = shift @names) { say $name; }
Конкретно этот пример работает точно так же как и другие варианты в этом разделе. Но если в массиве есть undef элементы, то этот цикл не пройдет по всем элементам:
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; my @names = ("Homer", "Marge", "Bart", "Lisa", undef, "Maggie"); while (my $name = shift @names) { say $name; }
Вывод этого скрипта:
Homer Marge Bart Lisa
Т.е. без "Maggie". Можно переделать цикл while чтобы он работал корректно, например, так:
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; my @names = ("Homer", "Marge", "Bart", "Lisa", undef, "Maggie"); while ($#names != -1) { my $name = shift @names; say $name if $name; }
(Переменная $#names возвращает -1 в том случае если массив пустой).
Но проще и понятнее это было бы написать с помощью foreach:
Foreach (@names) { say if $_; }
Функции
Массивы в Perl используются при написании собственных функций:
#!/usr/bin/perl use strict; use warnings FATAL => "all"; use feature "say"; sub say_hello { my ($name) = @_; say "Hello, ", $name; } say_hello "Homer";
Тут определяется функция с именем say_hello. Когда мы ее вызываем, то внутри функции все параметры которые мы в нее передали попадают в специальный массив @_.
С помощью записи
My ($name) = @_;
мы сохранили первый элемент массива @_ в переменную $name.
@_ - это массив, так что можно было работать с ним иначе. Например так:
Sub say_hello { say "Hello, ", $_; }
Sub say_hello { my $name = shift @_; say "Hello, ", $name; }
Если использовать shift внутри sub и не указать ей параметры, то она будет работать с @_. Так что последний вариант можно было записать:
Sub say_hello { my $name = shift; say "Hello, ", $name; }
Повторяет группу операторов применительно к каждому элементу коллекции.
For Each element [ As datatype ] In group [ statements ] [ Continue For ] [ statements ] [ Exit For ] [ statements ] Next [ element ]
Части
Определение |
|
Обязателен в операторе For Each. Необязателен в операторе Next. Переменная. Используется для циклического прохода (итерации) элементов коллекции. |
|
Является обязательным, если element еще не объявлен. Тип данных element. |
|
Обязательное. Переменную с типом, тип коллекции или объект. Указывает на коллекцию, применительно к элементам которой будут повторяться операторы statements. |
|
Необязательный параметр. Один или несколько операторов, стоящих между операторами For Each и Next и выполняющихся применительно к каждому элементу group. |
|
Необязательный параметр. Передача управления в начало цикла For Each. |
|
Необязательный параметр. Передача управления из цикла For Each. |
|
Обязательное. Завершение определения цикла For Each. |
Простой пример
Цикл For Each...Next используется при необходимости повтора набора инструкций для каждого элемента коллекции или массива.
Вложенные циклы
Циклы For Each могут вкладываться друг в друга.
В следующем примере демонстрируется вложенные структуры For Each…Next.
" Create lists of numbers and letters " by using array initializers. Dim numbers() As Integer = {1, 4, 7} Dim letters() As String = {"a", "b", "c"} " Iterate through the list by using nested loops. For Each number As Integer In numbers For Each letter As String In letters Debug.Write(number.ToString & letter & " ") Next Next Debug.WriteLine("") "Output: 1a 1b 1c 4a 4b 4c 7a 7b 7c
При поместите циклы, каждый цикл должен иметь уникальное имя переменной element.
Также можно вложить друг в друга различные виды управляющих структур. Для получения дополнительной информации см. Вложенные структуры управления (Visual Basic) .
Оставьте для; для
В следующем примере показано, как используются операторы Continue For и Exit For.
Dim numberSeq() As Integer = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12} For Each number As Integer In numberSeq " If number is between 5 and 7, continue " with the next iteration. If number >= 5 And number <= 8 Then Continue For End If " Display the number. Debug.Write(number.ToString & " ") " If number is 10, exit the loop. If number = 10 Then Exit For End If Next Debug.WriteLine("") " Output: 1 2 3 4 9 10
Любое число операторов Exit For можно разместить в цикле For Each. При использовании вложенных циклов For Each оператор Exit For вызывает выход из самого внутреннего цикла и передает управление следующему уровню вложения.
Exit For часто используется после оценки некоторого условия, например в структуре If...Then...Else. Можно использовать Exit For при следующих условиях:
Продолжать выполнение итераций не нужно или невозможно. Это может быть вызвано ошибочным значением или запросом на прерывание.
Исключение перехватывается в Try...Catch...Finally. Можно использовать Exit For в конце блока Finally.
Там бесконечный цикл, то есть цикл, которые может быть запущен большое или даже бесконечное количество раз. При обнаружении таких условий для выхода из цикла можно использовать Exit For. Дополнительные сведения см. в разделе Оператор Do...Loop (Visual Basic) .
Итераторы
Используется итератор, чтобы выполнять пользовательскую итерации по коллекции. Итератор может быть функцией или доступом Get. Он использует оператора Yield для получения каждого элемента коллекции по одному.
Следует вызвать итератор выписки с помощью For Each...Next. Каждая итерация цикла For Each вызывает итератор. При достижении выписка Yield в итераторе, возвращается выражение в инструкцию Yield, и текущего расположения в коде сохраняются. При следующем вызове итератора выполнение возобновляется с этого места.
В следующем примере используется функция итератора. Функция итератора имеет оператора Yield, внутри цикла For… Next . В методе ListEvenNumbers на каждую итерацию тела выписки For Each создает вызов функции итератора, которая переходит на следующую инструкцию Yield.
Public Sub ListEvenNumbers() For Each number As Integer In EvenSequence(5, 18) Debug.Write(number & " ") Next Debug.WriteLine("") " Output: 6 8 10 12 14 16 18 End Sub Private Iterator Function EvenSequence(ByVal firstNumber As Integer, ByVal lastNumber As Integer) _ As System.Collections.Generic.IEnumerable(Of Integer) " Yield even numbers in the range. For number = firstNumber To lastNumber If number Mod 2 = 0 Then Yield number End If Next End Function
Дополнительные сведения см. в разделах Итераторы (C# и Visual Basic) , Оператор Yield (Visual Basic) и Итератор (Visual Basic) .
Техническая реализация
Когда выписка For Each…Next выполняется, Visual Basic возвращает коллекцию только один раз, перед началом цикла. Если блок выписки изменяет element или group, то эти изменения не влияют на итерации цикла.
Когда переменной element будут присвоены все элементы коллекции, цикл For Each остановится и управление будет передано оператору, следующему за оператором Next.
Если element не было объявлено вне этого цикла, необходимо объявить его в инструкцию For Each. Можно объявить тип element явным образом при помощи оператора As, или можно использовать определение типа для назначения типа. В этом случае областью действия element является основная часть цикла. В то же время нельзя определять element и внутри, и снаружи цикла.
Можно дополнительно указать element в инструкции Next. Это повышает удобочитаемость программы, особенно если в ней имеются вложенные циклы For Each. При этом следует указать ту же переменную, что и в соответствующем операторе For Each.
Можно избежать изменения значения element внутри цикла. Это может сделать его более сложным для чтения и отладку кода. Изменение значения group не влияет на коллекцию или элементы, которые были определены при цикл сначала был введен.
Если циклы вложения, если выписка Next внешнего уровень вложенности обнаружении перед Next внутреннего уровня, компилятор сигнализирует об ошибке. При этом компилятор может обнаружить эту ошибку только в том случае, если в каждой инструкции Next указан element.
Если код зависит от переместить коллекцию в определенном порядке, цикл For Each…Next нет рекомендуемые варианта, если не требуется знать характеристики объекта перечислителя коллекции предоставляет. Порядок обхода не определен Visual Basic, но методом объекта перечислителя. Это означает, что пользователь не может задать, какой элемент должен быть первым записан в element, или какой элемент должен следовать за каким-либо элементом. С помощью другой циклической структуры, например For...Next или Do...Loop, можно добиться более надежных результатов.
Тип данных element должен быть таким, чтобы тип данных элементов в group мог быть преобразован к нему.
Тип данных group должен быть ссылочным типом, который ссылается на коллекцию или массив, который доступен для перечисления. Чаще всего это означает, что group ссылается на объект, реализующий интерфейс из пространства имен System.Collections или интерфейс из пространства имен System.Collections.Generic . System.Collections.IEnumerable задает метод , который возвращает объект перечислителя для коллекции. Объект перечислителя реализует интерфейс System.Collections.IEnumerator пространства имен System.Collections , а также имеет свойство , методы и . Visual Basic использует их для перемещения по коллекции.
Сужающие преобразования
Если Option Strict равно On, сужающее преобразование обычно вызывает ошибки компилятора. Однако в операторе For Each преобразования из элементов group в element оцениваются и выполняются во время выполнения и ошибка компилятора, вызванная сужающим преобразованием, может быть подавлена.
В следующем примере, назначения m как начальное значение для n не будет компилироваться при Option Strict, поскольку преобразование Long в Integer сужающее преобразование. В оператореFor Each однако, не ошибка компилятора сообщается, даже несмотря на то, что присвоение number требует того же преобразования из Long в Integer. В операторе For Each , содержащем большое число, то во время выполнения возникает ошибка, когда к большому числу применяется .
Option Strict On Module Module1 Sub Main() " The assignment of m to n causes a compiler error when " Option Strict is on. Dim m As Long = 987 "Dim n As Integer = m " The For Each loop requires the same conversion but " causes no errors, even when Option Strict is on. For Each number As Integer In New Long() {45, 3, 987} Console.Write(number & " ") Next Console.WriteLine() " Output: 45 3 987 " Here a run-time error is raised because 9876543210 " is too large for type Integer. "For Each number As Integer In New Long() {45, 3, 9876543210} " Console.Write(number & " ") "Next Console.ReadKey() End Sub End Module
Вызовы IEnumerator
В начале выполнения цикла For Each...Next Visual Basic проверяет, на допустимую ли коллекцию объектов ссылается group. Если это не так, то создается исключение. В противном случае вызывается метод и свойство объекта перечислителя, возвращающее первый элемент. Если MoveNext указывает, что следующий элемент отсутствует, то есть коллекция пуста, то цикл For Each останавливается и управление передается оператору, следующему за оператором Next. В противном случае Visual Basic присваивает element значение первого элемента и выполняет блок операторов.
Каждый раз, обнаруживая инструкцию Next, Visual Basic возвращается на инструкцию For Each. Снова для получения следующего элемента вызывается метод MoveNext и свойство Current , и снова в зависимости от результата либо выполняется блок, либо цикл останавливается. Этот процесс продолжается до тех пор, пока метод MoveNext не укажет на отсутствие следующего элемента, или пока не встретится оператор Exit For.
Изменение коллекции. Возвращает объект перечислителя обычно не позволяет изменять коллекцию путем добавления, удаления и переупорядочивания заменить все элементы. Если пользователь изменит коллекцию после запуска цикла For Each...Next, то объект перечислителя станет недействительным, и следующая попытка обращения к элементу коллекции вызовет исключение .
Однако эта блокировка изменения не указана, Visual Basic, а реализацией интерфейса . Можно реализовать IEnumerable таким образом, чтобы сделать изменение коллекции во время итерации возможным. Если планируется производить такие динамические изменения, то необходимо определить характер реализации IEnumerable используемой коллекции.
Изменение элементов коллекции. Свойство объекта перечисления имеет модификатор ReadOnly (Visual Basic) и возвращает локальную копию каждого элемента коллекции. Это означает, что в цикле For Each...Next нельзя изменить сами элементы. Любые изменения, сделанные влияет только на локальную копию из Current и обратно не отражены в базовую коллекцию. Тем не менее, если элемент имеет ссылочный тип, то можно изменять члены экземпляра, на который он указывает. Следующий пример изменяет элемент BackColor каждого элемента thisControl. Нельзя изменить, однако сам оператор thisControl.
Sub lightBlueBackground(ByVal thisForm As System.Windows.Forms.Form) For Each thisControl As System.Windows.Forms.Control In thisForm.Controls thisControl.BackColor = System.Drawing.Color.LightBlue Next thisControl End Sub
В предыдущем примере можно изменить член BackColor каждого элемента thisControl, несмотря на то, что нельзя изменить сам thisControl .
Обход массива. Поскольку класс реализует интерфейс , все массивы имеют метод . Это означает, что с помощью цикла For Each... Next можно перебирать и массивы. Тем не менее, элементы массива можно только считывать. Это изменить нельзя.
Пример
В следующем примере перечислены все папки в папке C:\ с помощью класса .
Dim dInfo As New System.IO.DirectoryInfo("c:\") For Each dir As System.IO.DirectoryInfo In dInfo.GetDirectories() Debug.WriteLine(dir.Name) Next
Следующий пример демонстрирует процедуру сортировки коллекции. Пример сортирует экземпляры класса Car, хранящихся в . Класс Car реализует интерфейс , который требует, чтобы метод был реализован.
При решении задач с большим количеством данных одинакового типа использование переменных с различными именами, не упорядоченных по адресам памяти, затрудняет программирование. В подобных случаях в языке Си используют объекты, называемые массивами.
— это непрерывный участок памяти, содержащий последовательность объектов одинакового типа, обозначаемый одним именем.
Массив характеризуется следующими основными понятиями:
Элемент массива (значение элемента массива)
– значение, хранящееся в определенной ячейке памяти, расположенной в пределах массива, а также адрес этой ячейки памяти.
Каждый элемент массива характеризуется тремя величинами:
- адресом элемента — адресом начальной ячейки памяти, в которой расположен этот элемент;
- индексом элемента (порядковым номером элемента в массиве);
- значением элемента.
Адрес массива – адрес начального элемента массива.
Имя массива – идентификатор, используемый для обращения к элементам массива.
Размер массива – количество элементов массива
Размер элемента – количество байт, занимаемых одним элементом массива.
Графически расположение массива в памяти компьютера можно представить в виде непрерывной ленты адресов.
Представленный на рисунке массив содержит q элементов с индексами от 0 до q-1 . Каждый элемент занимает в памяти компьютера k байт, причем расположение элементов в памяти последовательное.
Адреса i -го элемента массива имеет значение
Адрес массива представляет собой адрес начального (нулевого) элемента массива. Для обращения к элементам массива используется порядковый номер (индекс) элемента, начальное значение которого равно 0 . Так, если массив содержит q элементов, то индексы элементов массива меняются в пределах от 0 до q-1 .
Длина массива – количество байт, отводимое в памяти для хранения всех элементов массива.
ДлинаМассива = РазмерЭлемента * КоличествоЭлементов
Для определения размера элемента массива может использоваться функция
int
sizeof
(тип);
Например,
sizeof
(char
) = 1;
sizeof
(int
) = 4;
sizeof
(float
) = 4;
sizeof
(double
) = 8;
Объявление и инициализация массивов
Для объявления массива в языке Си используется следующий синтаксис:
тип имя[размерность]={инициализация};
Инициализация
представляет собой набор начальных значений элементов массива, указанных в фигурных скобках, и разделенных запятыми.
int
a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // массив a из 10 целых чисел
Если количество инициализирующих значений, указанных в фигурных скобках, меньше, чем количество элементов массива, указанное в квадратных скобках, то все оставшиеся элементы в массиве (для которых не хватило инициализирующих значений) будут равны нулю. Это свойство удобно использовать для задания нулевых значений всем элементам массива.
int
b = {0}; // массив b из 10 элементов, инициализированных 0
Если массив проинициализирован при объявлении, то константные начальные значения его элементов указываются через запятую в фигурных скобках. В этом случае количество элементов в квадратных скобках может быть опущено.
int
a = {1, 2, 3, 4, 5, 6, 7, 8, 9};
При обращении к элементам массива индекс требуемого элемента указывается в квадратных скобках .
Пример на Си
1
2
3
4
5
6
7
8
#include
int
main()
{
int
a = { 5, 4, 3, 2, 1 }; // массив a содержит 5 элементов
printf("%d %d %d %d %d\n"
, a, a, a, a, a);
getchar();
return
0;
}
Результат выполнения программы:
Однако часто требуется задавать значения элементов массива в процессе выполнения программы. При этом используется объявление массива без инициализации. В таком случае указание количества элементов в квадратных скобках обязательно.
int
a;
Для задания начальных значений элементов массива очень часто используется параметрический цикл:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include
int
main()
{
int
a;
int
i;
// Ввод элементов массива
for
(i = 0; i<5; i++)
{
printf("a[%d] = "
, i);
scanf("%d"
, &a[i]);
}
// Вывод элементов массива
for
(i = 0; i<5; i++)
printf("%d "
, a[i]); // пробел в формате печати обязателен
getchar(); getchar();
return
0;
}
Результат выполнения программы
Многомерные массивы
В языке Си могут быть также объявлены многомерные массивы. Отличие многомерного массива от одномерного состоит в том, что в одномерном массиве положение элемента определяется одним индексом, а в многомерном - несколькими. Примером многомерного массива является матрица.
Общая форма объявления многомерного массива
тип имя[размерность1][размерность2]...[размерностьm];
Элементы многомерного массива располагаются в последовательных ячейках оперативной памяти по возрастанию адресов. В памяти компьютера элементы многомерного массива располагаются подряд, например массив, имеющий 2 строки и 3 столбца,
int
a;
будет расположен в памяти следующим образом
Общее количество элементов в приведенном двумерном массиве определится как
КоличествоСтрок * КоличествоСтолбцов = 2 * 3 = 6.
Количество байт памяти, требуемых для размещения массива, определится как
КоличествоЭлементов * РазмерЭлемента = 6 * 4 = 24 байта.
Инициализация многомерных массивов
Значения элементов многомерного массива, как и в одномерном случае, могут быть заданы константными значениями при объявлении, заключенными в фигурные скобки {} . Однако в этом случае указание количества элементов в строках и столбцах должно быть обязательно указано в квадратных скобках .
Пример на Си
1
2
3
4
5
6
7
8
9
#include
int
main()
{
int
a = { 1, 2, 3, 4, 5, 6 };
printf("%d %d %d\n"
, a, a, a);
getchar();
return
0;
}
Однако чаще требуется вводить значения элементов многомерного массива в процессе выполнения программы. С этой целью удобно использовать вложенный параметрический цикл .
Пример на Си
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#define
_CRT_SECURE_NO_WARNINGS
#include
int
main()
{
int
a; // массив из 2 строк и 3 столбцов
int
i, j;
// Ввод элементов массива
for
(i = 0; i<2; i++) // цикл по строкам
{
for
(j = 0; j<3; j++) // цикл по столбцам
{
printf("a[%d][%d] = "
, i, j);
scanf("%d"
, &a[i][j]);
}
}
// Вывод элементов массива
for
(i = 0; i<2; i++) // цикл по строкам
{
for
(j = 0; j<3; j++) // цикл по столбцам
{
printf("%d "
, a[i][j]);
}
printf("\n"
); // перевод на новую строку
}
getchar(); getchar();
return
0;
}
Передача массива в функцию
Обработку массивов удобно организовывать с помощью специальных функций. Для обработки массива в качестве аргументов функции необходимо передать
- адрес массива,
- размер массива.
Исключение составляют функции обработки строк, в которые достаточно передать только адрес.
При передаче переменные в качестве аргументов функции данные передаются как копии. Это означает, что если внутри функции произойдет изменение значения параметра, то это никак не повлияет на его значение внутри вызывающей функции.
Если в функцию передается адрес переменной (или адрес массива), то все операции, выполняемые в функции с данными, находящимися в пределах видимости указанного адреса, производятся над оригиналом данных, поэтому исходный массив (или значение переменной) может быть изменено вызываемой функцией.
Пример на Си
Дан массив из 10 элементов. Поменять местами наибольший и начальный элементы массива. Для операций поиска максимального элемента и обмена использовать функцию.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#define
_CRT_SECURE_NO_WARNINGS
#include
// Функция обмена
void
change(int
*x, int
n)
{
// x - указатель на массив (адрес массива)
// n - размер массива
int
i;
int
max, index;
max = x;
index = 0;
// Поиск максимального элемента
for
(i = 1; i
if
(x[i]>max)
{
max = x[i];
index = i;
}
}
// Обмен
x = x;
x = max;
}
// Главная функция
int
main()
{
int
a;
int
i;
for
(i = 0; i<10; i++)
{
printf("a[%d] = "
, i);
scanf("%d"
, &a[i]);
}
change(a, 10); // вызов функции обмена
// Вывод элементов массива
for
(i = 0; i<10; i++)
printf("%d "
, a[i]);
getchar();
getchar();
return
p = p * x[i];
}
return
p;
}
// Главная функция
int
main()
{
int
a; // объявлен массив a из 5 элементов
int
i;
int
pr;
// Ввод элементов массива
for
(i = 0; i<5; i++)
{
printf("a[%d] = "
, i);
scanf("%d"
, &a[i]); // &a[i] - адрес i-го элемента массива
}
pr = func(a, 5); // вычисление произведения
printf("\n pr = %d"
, pr); // вывод произведения четных элементов
getchar(); getchar();
return
0;
}
