Ruby/Method/Code Block

0.step(50, 5) { puts "Test" }

10.downto(5) { puts "Test" }

1.upto(5) { puts "Test" }

1.upto(5) do |number|
  puts number
end

A block is delimited with {}:
{ puts "Hello there!" }
or do and end:
do
  puts "Hello there!"
end
# Generally, you use {} for a one-line block, and do..end for a multi-line block.

# This code is passed to the each method that then runs the code block for each element of the array.
# You can write methods of your own to handle code blocks.
def each_vowel(&code_block)
  %w{a e i o u}.each { |vowel| code_block.call(vowel) }
end
each_vowel { |vowel| puts vowel }

# block is referred to as a nameless function.
# block in Ruby is often an idiom for getting all the values out of a data structure. 
pacific = [ "Washington", "Oregon", "California" ]
pacific.each do |element|
 puts element
end
# characters (|element|) can be any name you want. 
# The block uses it as a local variable to keep track of every element in the array
# later uses it to do something with the element. 
# This block uses puts to print each element in the array:
# You can replace do/end with a pair of braces: pacific.each { |e| puts e }

def my_lambda(&block)
  block
end
b = my_lambda { puts "Hello World My Way!" }
b.call
# Hello World My Way!
puts b.class                                # => Proc

x = [1, 2, 3]
x.each { |y| puts y }
# The each method accepts a single code block as a parameter. 
# The code block is defined within the { and } symbols, or within do and end delimiters:
x = [1, 2, 3]
x.each do |y|
  puts y
end

# This object is called a proc (procedure). 
# procs preserve their execution environment and pack it along with them. 
# The lambda method is one way to create a proc object. 
 
prc = lambda { |name| puts "Hello, " + name }
prc.call "Matz!" # => Hello, Matz!

then call the new version of hello with a block (the code in braces).
def hello
  yield
end
hello { puts "Hello, Matz!" } # => Hello, Matz!

#!/usr/bin/env ruby
def times_tables
  1.upto(12) { |i| 1.upto(12) { |j| print i.to_s + " x " + j.to_s + " = ", j * i, "\n"} }
end
times_tables

5.times do | i |
  puts i
end

[ "Hello, ", "Matz!"].each { |e| print e }

def every_n_seconds(n)
  loop do
    before = Time.now
    yield
    interval = n-(Time.now-before)
    sleep(interval) if interval > 0
  end
end
every_n_seconds(5) do
 puts "#{Time.now.strftime("%X")}... beep!"
end

["Hello", "there", "sweetie."].each {|word| puts word}
4.upto(8) {|loop_index_value| puts loop_index_value}
4.times {print "X"}