Ruby
counter = 1
while counter < 11
puts counter
counter += 1
end
counter = 1
until counter > 10
puts counter
counter += 1
end
for num in 1..10
puts num
end
for num in 1...11
puts num
end
i = 0
loop do
i += 1
puts i
break if i > 10
end
for i in 1..5
next if i % 2 == 0
print i
end
range = 1..10
range.each do |i|
puts i
end
10.times { |i| puts i }
1.upto(10) { |i| puts i }
10.downto(1) { |i| puts i }
["a", "b", "c"].each do |e|
print "#{e}! "
end
# prints "a! b! c!"; returns the array
{"Pinkie Pie" => "earth pony", "Rainbow Dash" => "pegasus", "Twilight Sparkle" => "unicorn"}.each do |name, race|
puts "#{name} is a #{race}"
end
[:hearts, :spades, :clubs, :diamonds].each_with_index do |suit, i|
puts "#{i}: #{suit}"
end
next # jump to next iteration
redo # restart loop; don't recheck the condition
retry # restart loop, rechecking the condition
break # exit loop
Arrays of strings can be created using ruby's percent string syntax:
array = %w(one two three four)
This is functionally equivalent to defining the array as:
array = ['one', 'two', 'three', 'four']
Instead of %w()
you may use other matching pairs of delimiters: %w{...}
, %w[...]
, or %w<...>
.
It is also possible to use arbitrary non-alphanumeric delimiters, such as: %w!...!
, %w#...#
, or %w@...@
.
%W
can be used instead of %w
to incorporate string interpolation. Consider the following:
var = 'hello'
%w(#{var}) # => ["\#{var}"]
%W(#{var}) # => ["hello"]
Multiple words can be interpreted by escaping the space with a \
.
%w(Colorado California New\ York) # => ["Colorado", "California", "New York"]
array = %i(one two three four)
creates the array [:one, :two, :three, :four]
.
You can use other delimiters ([]
, {}
, !!
...) instead of ()
, as with strings.
Additionally, if you want to use interpolation, you can do this with %I.
a = 'hello'
b = 'goodbye'
array_one = %I(#{a} #{b} world) # => [:hello, :goodbye, :world]
array_two = %i(#{a} #{b} world) # => [:"\#{a}", :"\#{b}", :world]
Adding elements:
[1, 2, 3] << 4
# => [1, 2, 3, 4]
[1, 2, 3].push(4)
# => [1, 2, 3, 4]
[1, 2, 3].unshift(4)
# => [4, 1, 2, 3]
[1, 2, 3] << [4, 5]
# => [1, 2, 3, [4, 5]]
Removing elements:
array = [1, 2, 3, 4]
array.pop
# => 4
array
# => [1, 2, 3]
array = [1, 2, 3, 4]
array.shift
# => 1
array
# => [2, 3, 4]
array = [1, 2, 3, 4]
array.delete(1)
# => 1
array
# => [2, 3, 4]
array = [1,2,3,4,5,6]
array.delete_at(2) // delete from index 2
# => 3
array
# => [1,2,4,5,6]
array = [1, 2, 2, 2, 3]
array - [2]
# => [1, 3] # removed all the 2s
array - [2, 3, 4]
# => [1] # the 4 did nothing
Combining arrays:
[1, 2, 3] + [4, 5, 6]
# => [1, 2, 3, 4, 5, 6]
[1, 2, 3].concat([4, 5, 6])
# => [1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6] - [2, 3]
# => [1, 4, 5, 6]
[1, 2, 3] | [2, 3, 4]
# => [1, 2, 3, 4]
[1, 2, 3] & [3, 4]
# => [3]
You can also multiply arrays:
[1, 2, 3] * 2
# => [1, 2, 3, 1, 2, 3]
# One line block
[1,2,3].each { |num| print "#{num}! " }
# Multi-line block
[1,2,3].each do |num|
print "#{num}! "
end
# Yielding to a block
def method_taking_block
yield("some argument for the block") if block_given?
end
# Create and use a Proc
my_proc = Proc.new { |arg1| print "#{arg1}! " }
[1,2,3].each(my_proc)
# Call a Proc inside a method
# Sort of like `yield`ing
my_proc.call("Some Argument")
# Make a new Lambda (just like Procs)
my_lam = lambda { |word| puts word }
# Use a Method
method(:print_stuff_method).call("something to print")