Я два дня прожил, не видя Вас, и тем доказал, что способен вынести все (Б. Шоу).

20 Практических примеров команд Цикла в Ruby – For, Each, While, Until

FavoriteLoadingДобавить в избранное
1 Звезда2 Звезды3 Звезды4 Звезды5 Звезд (1 оценок, среднее: 5,00 из 5)
Загрузка...
8 октября 2018
20 Практических примеров команд Цикла в Ruby - For, Each, While, Until
Изучение циклов – важный аспект любого языка программирования.

Основное внимание в этой статье уделяется циклам в Ruby.

В языке программирования Ruby используются следующие 8 различных типов команд (функций), которые можно использовать для циклического перебора.

  1. Loop
  2. Until
  3. While
  4. Do – While
  5. For
  6. Each
  7. Upto
  8. Times

В этой статье мы обсудим следующие 20 примеров, которые будут охватывать все команды, связанные с циклом Ruby.

  1. Краткая сводка – для нетерпеливых
  2. Команда Loop – просто продолжает цикл
  3. Команда Loop – вырваться из цикла
  4. Команда Loop – просто пропустите один конкретный цикл, используя следующий
  5. Команда Until – продолжайте цикл до тех пор, пока оно не будет истинным
  6. Команда While – пока правда, продолжайте цикл
  7. Цикл Do-While – While в конце блока
  8. Команда For – цикл через диапазон номеров
  9. Использование массивов в For – Цикл для массива элементов
  10. Использование длины массива в For
  11. Использование размера массива в For
  12. For внутри For – вложенные циклы
  13. Команда Each – метод популярного цикла в Ruby
  14. Команда Each – цикл через несколько строк в массиве
  15. Команда Every_Index – перебирает только индексы массива
  16. Команда each_with_Index – цикл через массив с использованием индекса и значения
  17. Each внутри Each  – вложенная команда Each
  18. Команда Each – цикл через статические диапазоны чисел
  19. Команда Times – цикл X количество раз
  20. Команда Upto – цикл Upto X количество раз, начиная с Y

1. Краткая сводка – для нетерпеливых

Для нетерпеливых быстрые фрагменты основных команд цикла показаны ниже. Подробнее об этих командах читайте в полном учебнике.

Команда Loop:

loop do
 puts "do something"
end

 

Команда Until:

until count > 5
  puts "do something"
end

Команда While:

while count <= 5
  puts "do something"
end

Для командной строки 5 раз

for i in 1..5 do
  puts "#{i}"
end

 

Для командной строки через массив:

for i in myarray do
  puts "#{i}"
end

 

Каждая команда цикла – 5 раз

(1..5).each do |i|
  puts "#{i}"
end

 

Каждая команда – цикл через массив

myarray.each do |element|
  puts "#{element}"
end

 

Каждая команда – цикл через массив с индексом и элементами

myarray.each_with_index do |element,i|
  puts "#{i}. #{element}"
end

 

Команда Times – цикл 5 раз

5.times do |i|
  puts "#{i}"
end

Команда Upto – цикл от 2 до 5

2.upto(5) do |i|
  puts "#{i}"
end

2. Команда Loop – просто продолжает цикл

Первая – это сама команда Loop. Все, что она делает, это то, что он продолжает бесконечный цикл.

Как вы видите ниже, следующий пример базовой команды Loop, будет многократно печатать материал между блоком «do» и «end», пока вы не нажмете Ctrl-C

# cat loop1.rb
loop do
  puts "The AndreyEx Blogs"
  puts "Press Ctrl-C to Exit!"
end

 

Выполните вышеуказанную программу, чтобы проверить ее. Убедитесь, что вы нажимаете Ctrl-C, чтобы выйти из цикла

# ruby loop1.rb
The AndreyEx Blogs
^CPress Ctrl-C to Exit!
loop1.rb:2: Interrupt
    from loop1.rb:1:in `loop'
    from loop1.rb:1

 

Кроме того, имейте в виду, что для почти любых команд цикла в Ruby вместо «do» и «end» вы также можете указать тело цикла в фигурных скобках {}, как показано ниже.

Следующий пример точно такой же, как и выше, но с использованием фигурных скобок.

# cat loop2.rb
loop {
  puts "The AndreyEx Blogs"
  puts "Press Ctrl-C to Exit!"
}

 

Предупреждение
Не делайте { на отдельной строке! Если вы это сделаете, вы получите сообщение об ошибке. Следующее неверно, так как { находится на следующей строке после цикла. Он должен быть в той же строке, что и команда loop.
# cat loop2.rb
loop
{
  puts "The AndreyEx Blogs"
  puts "Press Ctrl-C to Exit!"
}

 

В приведенном выше примере будет выведено следующее сообщение об ошибке.

# ruby loop2.rb
loop2.rb:3: syntax error, unexpected tSTRING_BEG, expecting kDO or '{' or '('
  puts "The AndreyEx Blogs"
        ^
loop2.rb:5: syntax error, unexpected '}', expecting $end

 

3. Команда Loop – вырваться из цикла

Предыдущий пример команды цикла практически бесполезен, поскольку он просто продолжает цикл.

Итак, чтобы выйти из команды Loop, используйте команду break, как показано ниже.

Когда вы выполните «break», он просто прекратит выполнение цикла и выйдет.

# cat loop3.rb
loop do
  puts "The AndreyEx Blogs"
  break
end

 

Вышеприведенный пример будет проходить через цикл один раз.

# ruby loop3.rb
The AndreyEx Blogs

 

Прохождение цикла один раз, в значительной степени бесполезно также. Таким образом, в следующем примере будет проходить через цикл всего 5 раз до выхода из цикла.

Как вы можете себе представить, чтобы отслеживать количество циклов, мы используем переменную с именем count и каждый раз увеличиваем ее на 1. Когда значение count равно 6, мы вырвемся из цикла.

# cat loop4.rb
count = 1
loop do
  puts "#{count}" " The AndreyEx Blogs"
  count = count + 1
  if count == 6
    break
  end
end

 

Ниже приведен результат вышеприведенного примера, который проходит ровно 5 раз.

# ruby loop4.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs

 

4. Команда Loop – просто пропустите один конкретный цикл, используя следующий

Так же, как break, внутри команды loop вы также можете использовать next.

Next просто пропустить остальные команды в цикле-блоке для текущего исполнения, но он продолжит цикл сверху.

Итак, в следующем примере, используя команду if, мы проверяем, является ли значение count равным 3. Когда оно равно 3, мы выполняем команду «next», которая пропустит оставшуюся часть цикла и продолжит цикл из наверху снова.

Это означает, что в следующем примере будет пропущено только третье выполнение цикла.

# cat loop5.rb
count = 1
loop do
  if count == 3
    count = count + 1
    next
  end
  puts "#{count}" " The AndreyEx Blogs"
  count = count + 1
  if count == 6
    break
  end
end

 

Следующий вывод указывает, что приведенный выше пример пропустил третье выполнение цикла.

# ruby loop5.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs

 

5. Команда Until – продолжайте цикл до тех пор, пока оно не будет истинным

Пока это еще один тип команды, чтобы перебирать код.

В команде until команды тела будут выполняться до тех пор, пока условие не будет истинным. т.е. продолжайте цикл, пока условие будет ложным. Когда условие станет истинным, оно остановит цикл.

В следующем примере, если значение счетчика переменных не превышает 5, оно будет продолжать цикл. Когда условие становится истинным (т. е. Когда счетчик больше 5), он прекратит цикл.

# cat until1.rb
count = 1
until count > 5
  puts "#{count}" " The AndreyEx Blogs"
  count = count + 1
end

 

Как видно из приведенного ниже результата, приведенный выше пример выполнил цикл 5 раз, используя команду.

# ruby until1.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs

 

6. Команда While – пока правда, продолжайте цикл

Второй тип команды цикла – это команда while.

В команде while тело будет выполняться, пока условие, указанное в команде while, равно true.

Итак, идея здесь в том, что, хотя условие истинно, оно будет продолжать цикл навсегда. Таким образом, ваша ответственность заключается в том, чтобы убедиться, что состояние становится ложным в определенный момент времени.

В следующем примере время будет продолжаться, пока цикл не будет меньше или равен 5. Мы увеличиваем счет внутри тела цикла.

Итак, следующий пример будет проходить 5 раз.

# cat while1.rb
count = 1
while count <= 5
  puts "#{count}" " The AndreyEx Blogs"
  count = count + 1
end

 

Как видно из приведенного ниже результата, приведенный выше пример выполнил цикл 5 раз, используя команду while.

# ruby while1.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs

 

7. Цикл Do-While – While в конце блока

В предыдущем примере у нас была команда while в начале цикла.

Как правило, в большинстве языков программирования, когда вы вставляете команду while в конец цикла, это называется циклом do-while.

Ruby также поддерживает формат do-while, как показано в следующем примере.

Здесь нужно иметь в виду, что цикл do-while всегда будет выполнять тело цикла как минимум один раз.

Это связано с тем, что мы не проверяем какое-либо условие в начале цикла. Итак, первый раз цикл всегда выполняется.

В конце 1-го цикла условие проверяется. Пока условие истинно, оно будет продолжать цикл.

Итак, следующий пример выполнит цикл 1-го раза, а затем, пока условие будет истинным, оно будет продолжать цикл.

# cat do-while1.rb
count = 1
begin
  puts "#{count}" " The AndreyEx Blogs"
  count = count + 1
end while count <= 5

 

Как видно из приведенного ниже результата, приведенный выше пример выполнил цикл 5 раз, используя команду do-while.

# ruby do-while1.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs

 

8. Команда For – цикл через диапазон номеров

В следующем примере показано, как выполнить цикл с числовыми значениями, используя простой цикл.

Диапазон указан в формате начального значения и конечного значения, разделенных двумя периодами (без какого-либо промежутка между ними)

В следующем примере начальное значение диапазона равно 1. Конечным значением диапазона является 5. count – это имя переменной, которая удерживает текущее значение цикла.

# cat for1.rb
for count in 1..5 do
  puts "#{count}" " The AndreyEx Blogs"
end

 

Следующий вывод показывает, что приведенный выше пример выполнил цикл 5 раз, используя команду

# ruby for1.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs

 

9. Использование массивов в For – Цикл для массива элементов

Помимо указания диапазона чисел в команде for, вы также можете указать массив элементов для прокрутки.

В следующем примере у нас есть массив под названием myarray. В команде for мы просто указали это имя массива для прокрутки.

Он будет просто циклически перемещаться по всем элементам массива один за другим с помощью команды for.

# cat for2.rb
myarray = [ 101, 201, 301, 401, 501 ]
for i in myarray do
  puts "#{i}"
end

 

Как видно из следующего вывода, он зациклился на всех элементах массива и напечатал их соответствующим образом.

# ruby for2.rb
101
201
301
401
501

 

Вы также можете перебирать массив со строковыми значениями, как показано ниже.

# cat for2.1.rb
myarray = [ "The", "AndreyEx", "Blogs" ]
for i in myarray do
  puts "#{i}"
end

 

Как видно из следующего вывода, приведенный выше пример просто зациклился на myarray, который содержит три строковых элемента и распечатывает их.

# ruby for2.1.rb
The
AndreyEx
Blogs

 

10. Использование длины массива в For

В команде for loop вы также можете указать длину массива в диапазоне как конечное значение для цикла через массив, как показано ниже.

# cat for3.rb
myarray = [ "The", "AndreyEx", "Blogsf" ]
maxsize = myarray.length
for i in 1..maxsize
  puts "#{i}" " The AndreyEx Blogs"
end

 

В приведенном выше примере myarray содержит всего три элемента. Итак, marray.length вернет 3. Мы используем это значение в диапазоне команд для команды: 1..maxsize

Таким образом, мы не зацикливаемся по массиву. Мы как бы прокручиваем индексы массива косвенно. Существует лучший метод для циклического преобразования массива с использованием индексов, что объясняется в одном из следующих примеров.

Как видно из следующего вывода, цикл выполняется ровно 3 раза, что является длиной массива.

# ruby for3.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs

 

11. Использование размера массива в For

Следующий пример очень похож на предыдущий пример. Но мы используем размер массива вместо длины.

# cat for4.rb
myarray = [ "The", "AndreyEx", "Blogsf" ]
for i in 0...myarray.size
  puts "#{i}" " The AndreyEx Blogs"
end

 

Имейте в виду, что:

  1. Длина массива вернет количество элементов в массиве. В предыдущем примере мы получили 3. Итак, если вы хотите пройти через 1, 2, 3 – использовать длину массива.
  2. Размер массива вернет общее количество элементов в массиве минус 1. Таким образом, мы получили 2 в этом примере. Итак, если вы хотите пройти через 0, 1, 2 – используйте размер массива.

Как видно из следующего вывода, размер массива вернул 2. Итак, мы переходим от 0 до 2 в нашем диапазоне в цикле.

# ruby for4.rb
0 The AndreyEx Blogs
1 The AndreyEx Blogs
2 The AndreyEx Blogs

 

12. For внутри For – вложенные циклы

Вы также можете использовать цикл for в цикле for. Это называется вложенным циклом, как показано в следующем примере.

Внешний цикл будет проходить через массив names. Внутренний цикл будет проходить через массив «вещей».

Таким образом, для каждого человека в массиве имен он будет проходить через каждый элемент массива things.

# cat for5.rb
names = [ "AndreyEx", "Alex", "Angela" ]
things = [ "Chocolate", "Sugar" ]
counter = 1
for name in names
  puts "#{counter}. #{name} любит: "
  counter = counter + 1
  for item in things
    puts "  #{item}"
  end
end

 

Как видно из следующего вывода, для каждого человека он зацикливается на массиве things, используя формат вложенного цикла.

# ruby for5.rb
1. AndreyEx любит:
  Chocolate
  Sugar
2. Alex любит:
  Chocolate
  Sugar
3. Angela любит:
  Chocolate
  Sugar

 

13. Команда Each – метод популярного цикла в Ruby

В Ruby рекомендуемый метод для прокрутки файлов использует команду Each, как показано ниже.

Синтаксис команды Each отличается от традиционного для Loop, while loop и т. д.

В следующем примере объясняется, как цитировать массив чисел, используя команду Each в ruby.

# cat iterator1.rb
counter = [ 1, 2, 3, 4, 5 ]
counter.each do |i|
  puts "#{i} The AndreyEx Blogs"
end

 

В приведенном выше:

  • counter – это имя массива, содержащего массив чисел.
  • counter.each – Здесь мы добавляем .each к имени переменной массива. Это будет проходить через массив счетчиков.
  • do … end – это тело цикла (как и другие примеры команд цикла)
  • |i| – Это относится к каждой команде. Это указывает на то, что переменная i будет удерживать текущее значение массива во время цикла. Вы можете использовать эту переменную для управления отдельным элементом массива в стороне массива.

Как видно из следующего вывода, мы перебираем переменную массива с помощью команды Each и печатаем результат.

# ruby iterator1.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs

 

14. Команда Each – цикл через несколько строк в массиве

Это похоже на предыдущий пример, но вместо того, чтобы перебирать массив чисел, здесь мы перебираем массив строк.

# cat iterator2.rb
title = [ "The", "AndreyEx", "Blogs" ]
counter = 1
title.each do |i|
  puts "#{counter}. #{i}"
  counter = counter + 1
end

 

Как видно из следующего вывода, команда Each прошла через массив заголовков и каждый раз печатала все отдельные элементы.

# ruby iterator2.rb
1. The
2. AndreyEx
3. Blogs

 

15. Команда Every_Index – перебирает только индексы массива

Если вы просто хотите прокрутить индексы массива, а не сами элементы массива, используйте команду each_index, как показано ниже.

# cat iterator4.rb
title = [ "The", "AndreyEx", "Blogsf" ]
title.each_index do |i|
  puts "#{i}"
end

 

В приведенном выше:

  • title – это массив, содержащий три строковых элемента.
  • title.each_index – Это указывает на то, что нам нравится перебирать индексы нашего массива заголовков (а не элементы массива, просто индекс элементов)
  • do … end – это тело цикла (как и другие примеры команд цикла)
  • |i| – Это указывает на то, что переменная i будет удерживать текущее значение того, что мы прокручиваем. Поскольку мы перебираем индексы, это будет удерживать текущее значение индекса, который мы перебираем.

Как видно из следующего вывода, напечатаны индексы элементов массива. Поскольку у нас есть три элемента в массиве, этот пример напечатал 0, 1 и 2.

# ruby iterator4.rb
0
1
2

 

Имейте в виду, что индекс массива всегда начинается с 0 (не от 1)

 

16. Команда each_with_Index – цикл через массив с использованием индекса и значения

Хотя отлично, что каждая команда проходит через элементы, а each_index – через индексы.

Что делать, если вы хотите прокручивать оба, индексы и элементы.

Именно поэтому у нас есть команда each_with_index, как показано в следующем примере.

В этом примере each_with_index будет проходить через каждый отдельный элемент и хранить как значение элемента, так и значение индекса во время выполнения цикла в двух разных переменных.

# cat iterator3.rb
title = [ "The", "AndreyEx", "Blogs" ]
title.each_with_index do |element,i|
  puts "#{i}. #{element}"
end

 

В приведенном выше:

  • title – это массив, содержащий три строковых элемента.
  • title.each_with_index – Это указывает на то, что нам надо как значения массива, так и индексы
  • do … end – это тело цикла (как и другие примеры команд цикла)
  • |element, i| – Здесь мы указываем две переменные. Первая переменная (element) будет содержать значение отдельного элемента массива. Вторая переменная i будет содержать значение индексов этого конкретного элемента.
  • puts “# {i}. # {element} “- В теле цикла мы используем как отдельный элемент, так и соответствующее значение индекса.

Как видно из следующего вывода, этот пример печатает как индекс, так и значение отдельного элемента массива.

# ruby iterator3.rb
0. The
1. AndreyEx
2. Blogs

 

17. Each внутри Each  – вложенная команда Each

Вы также можете использовать Each внутри Each. Это называется вложенным циклом, это похоже на пример вложенного цикла, который мы видели ранее.

Внешний цикл будет проходить через массив имен. Внутренний цикл цикла будет проходить через массив «things».

Таким образом, для каждого человека в массиве names он будет проходить через каждый элемент массива things.

# cat iterator5.rb
names = [ "AndreyEx", "Alex", "Angela" ]
things = [ "Chocolate", "Sugar" ]
counter = 1
names.each do |name|
  puts "#{counter}. #{name} любит: "
  counter = counter + 1
  things.each do |item|
    puts "  #{item}"
  end
end

 

Как видно из следующего вывода, для каждого человека он зацикливал все things, используя вложенный формат цикла.

# ruby iterator5.rb
1. AndreyEx любит:
  Chocolate
  Sugar
2. Alex любит:
  Chocolate
  Sugar
3. Angela любит:
  Chocolate
  Sugar

 

18. Команда Each – цикл через статические диапазоны чисел

Вместо того, чтобы перебирать массив, вы также можете перебирать статические числа из диапазона, как показано в следующем примере.

# cat iterator6.rb
(1..5).each do |counter|
  puts "#{counter} The AndreyEx Blogs"
end

 

В приведенном выше примере:

  • (1..5) .each – Это означает, что мы будем перебирать заданный диапазон с помощью команды Each. Данный диапазон составляет от 1 до 5
  • do … end – это тело цикла (как и другие примеры команд цикла)
  • |counter| – Это указывает на то, что счетчик переменных будет удерживать текущее значение того, что мы прокручиваем.

Как видно из следующего вывода, вышеуказанная команда зацикливается через заданный статический диапазон с помощью команды Each.

# ruby iterator6.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs

 

19. Команда Times – цикл X количество раз

Times – очень полезная команда цикла, которая поможет вам быстро прокручивать х число раз.

Следующий пример будет циклически проходить через тело цикла 5 раз.

# cat times1.rb
5.times do |i|
  puts "#{i} The AndreyEx Blogs"
end

 

В приведенном выше:

  • 5.times – это указывает на то, сколько времени мы хотели бы пропустить. Здесь мы будем проходить через 5 раз
  • do … end – это тело цикла (как и другие примеры команд цикла)
  • |i| – Это означает, что переменная i будет удерживать текущее значение счетчика цикла, т.е. 1-го цикла, или 2-го цикла, или 3-го цикла и т. д.

Важно иметь в виду, что команда time всегда будет начинаться с 0.

Итак, когда мы говорим 5 раз, это означает: 0, 1, 2, 3 и 4

Как видно из следующего вывода, приведенный выше пример зацикливается 5 раз, но начиная с 0 до 4.

# ruby times1.rb
0 The AndreyEx Blogs
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs
4 The AndreyEx Blogs

 

20. Команда Upto – цикл Upto X количество раз, начиная с Y

Другая полезная команда – Upto.

В отличие от команды times, вы можете указать начальный номер цикла.

Следующий пример похож на предыдущий пример, но он начинается с 1 (вместо 0) и проходит 5 раз.

# cat upto1.rb
1.upto(5) do |i|
  puts "#{i} The AndreyEx Blogs"
end

 

Как видно из следующего вывода, приведенный выше пример зацикливается 5 раз, но начинается с 1 по 5.

# ruby upto1.rb
1 The AndreyEx Blogs
2 The AndreyEx Blogs
3 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs

 

В следующем примере мы начинаем с 3 и перебираем до 6. Таким образом, это будет проходить через: 3, 4, 5 и 6

# cat upto2.rb
3.upto(6) do |i|
  puts "#{i} The AndreyEx Blogs"
end

 

В следующем примере цикл повторяется 4 раза, используя команду upto, но начиная с 3 по 6.

# ruby upto2.rb
3 The AndreyEx Blogs
4 The AndreyEx Blogs
5 The AndreyEx Blogs
6 The AndreyEx Blogs

 

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Просмотров: 13

Если статья понравилась, то поделитесь ей в социальных сетях:

Добавить комментарий

Войти с помощью: 

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Сообщить об опечатке

Текст, который будет отправлен нашим редакторам:

Заполните форму и наш менеджер перезвонит Вам в самое ближайшее время!

badge
Обратный звонок 1
Отправить
galka

Спасибо! Ваша заявка принята

close
galka

Спасибо! Ваша заявка принята

close