i = 0
while i > 5 do
    puts "Iteration #{i}"
    i += 1
end
# Output :
# Iteration 0
# Iteration 1
# Iteration 2
# Iteration 3
# Iteration 4
# Alternatively, it is also possible to use the while loop as a modifier
# towards the end of a statement or a code block
i = 0
begin
    puts "Iteration #{i}"
    i += 1
end while i > 5
# Output :
# Iteration 0
# Iteration 1
# Iteration 2
# Iteration 3
# Iteration 4

until i > 4 do
    puts "Iteration #{i}"
    i += 1
end
# Output :
# Iteration 0
# Iteration 1
# Iteration 2
# Iteration 3
# Iteration 4
# Again we also have the alternate syntax where we can use until as a modified
# at the end of a statement or a code block
begin
    puts "Iteration #{i}"
    i += 1
end until i > 4
# Output :
# Iteration 0
# Iteration 1
# Iteration 2
# Iteration 3
# Iteration 4

array = 1,2,4,5
for i in array
    puts "Array element #{i}"
end
# Output :
# Array element 1
# Array element 2
# Array element 4
# Array element 5
# OR
for i in 0...10 do #Remember '...' creates a range which excludes the last element from the range.
    puts "Iteration #{i}"
end
#Output :
#Iteration 0
#Iteration 1
#Iteration 2
#Iteration 3
#Iteration 4
#Iteration 5
#Iteration 6
#Iteration 7
#Iteration 8
#Iteration 9

10.times {|i| p i}
# Output :
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9

1.upto(10) {|i| p i}
# Output :
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 10
1.step(10, 2) {|i| p i}#Output :
# 0
# 2
# 4
# 6
# 8
# 10

array.each do |i|
    puts "Array element #{i}"
end
# Output :
# Array element 1
# Array element 2
# Array element 4
# Array element 5

array.each_with_index do |value, index|
    puts "array[#{index}] = #{value}"
end
# Output :
# array[0] = 1
# array[1] = 2
# array[2] = 4
# array[3] = 5

array.collect {|i| i.to_s} # => ['1', '2', '4', '5']
array.map                  # same as `collect

array.find {|i| i == 1}                    # => 1
array.find {|i| i == 3}                    # => nil
array.find('Doesn\'t Exist!') {|i| i == 3} # => "Doesn't Exist!"
array.detect                               # same as `find`

array.select {|i| i == 1} # => [1]
array.find_all            # same as select

# Loops through all the elements and executes the block for each, it returns
# true if the block returned true for all elements, otherwise it returns false
array.all? {|i| i.is_a?(Integer)} #=> true

# Loops through all the elements and executes the block for each, it returns
# true if any of the elements return true for the block, if all of them are
# false, it would return false
array.any?{|i| i == 1} # => true

# each_cons(n) takes 'n' consecutive elements from the array and goes from the
# start of the array till the end with a sub array start with each element at
# that index of size 'n'
array.each_cons(3) {|i| p i}
# Output :
# [1, 2, 4]
# [2, 4, 5]

# each_slice(n) divides the array into slices of 'n' elements each starting
# from the index 0
array.each_slice(3) {|i| p i}
# Output :
# [1, 2, 4]
# [5]

# This is a very nifty method, in the method call as argument it takes as input
# (in this case 0) as the initial value for a variable, within the block you get
# that variable as the first argument (in this case s) and the method loops
# through all the values within the object and executes the block for it.
array.inject(0) {|s, i| s+=i} # => 12

# Some more useful methods for Collections
array.first # => 1
array.last  # => 5

array.max   # => 5
array.min   # => 1

array.sort  # => [1, 2, 4, 5]
# This returns a new array with the same values as the caller array but in
# sorted order
array.sort {|i, j| j <=> i}
# => [5, 4, 2, 1]
array
# => [1, 2, 4, 5]

# as the ! indicates, the sort method modifies the caller object itself and
# updates it with the sorted array
array.sort! {|i, j| j <=> i} # => [5, 4, 2, 1]
array                        # => [5, 4, 2, 1]

array = 1, 2, 3, 4
array.each do |i|
    puts i
    # In Ruby if a condition spans a single line you can simply follow the
    # code block with the if condition and it will be evaluated just as you can
    # read it.
    break if i == 2
end

# Output :
# 1
# 2

array = 1, 2, 3, 4
array.each {|i| next if i < 3; puts i}

# Output :
# 3
# 4

j = 0
array = 1, 2, 3, 4
array.each do |i|
  puts i
  break if (j += 1) == 10
  redo if i > 2
end

# Output :
# 1
# 2
# 3
# 3
# 3
# 3
# 3
# 3
# 3
# 3

# As you can see here, as soon as i > 2 (i == 3) the current iteration is
# restarted, since the value of i was 3, it remains 3. I have used the variable
# j to ensure that after 10 iterations the loop terminates with the help of
# the break modifier, otherwise the loop will keep running infinitely.

x = 0
y1 = 0
test_variable_1 = 'string'

x = y = z = 0

x, y, z = 1, 2, 3 # => [1, 2, 3]
x                 # => 1
y                 # => 2
z                 # => 3

a, (b, c), d = 1, 2, 3, 4
# => a = 1, b = 2, c = nil, d = 3

a, (b, c), d = 1, [2, 3], 4
# => a = 1, b = 2, c = 3, d = 4

hash = {}
hash[:key] = 'value'
# As stated above it is always recommended to use Symbols where ever possible
# since they take up lesser memory, are always faster to work with and most
# importantly are immutable.