Ruby Containers

In Ruby, we can easily put method definition inside a container class, then create new objects by sending the new message to that class like most scripting languages. Ruby has a built-in module called Enumerable that's included by Strings, Array, Hash, Range, and other classes that represent a collection of values. There are mainly four kinds of containers that represent a collection of data in Ruby:

• Strings: A string is a sequence or set of one or more characters.
• Arrays: Arrays are the collection of ordered, integer-indexed objects.
• Hashes: Hashes are collections of unique <key, value> pairs.
  • It is often known as associative arrays, maps, or dictionaries.
  • It is unordered.
• Ranges: Ranges depict a set of values between starting and endpoints. Values can be range, character, string, or objects.

Ruby Strings:

Ruby strings are Mutable, and created using single quote(' ') or double quote(" ") without mentioning the data types.

 Example 1: 

# Ruby code implementation 
# for creation of Ruby Strings

# using single quotes
 puts 'Ruby String using single quotes in GFG!'

# using double quotes
 puts "Ruby String using double quotes in GFG!"

# storing string into variables
 str = "Ruby String using variable in GFG!"

# displaying string
 puts str

Output:

Ruby String using single quotes in GFG!
Ruby String using double quotes in GFG!
Ruby String using a variable in GFG!

Double quotes interpolate the variables whereas single quotes can't interpolate.

Example 2:

# Ruby code implementation to 
# show single and double quotes

str1 = 'Hello Geeks!'
str2 = "Hello GFG"

# using single quotes
puts '#{str1}'  
puts '#{str2}'  
puts "#{str1}"  
puts "#{str2}"  

Output:

#{str1}
#{str2}
Hello Geeks!
Hello GFG

Accessed by mentioning the index inside the square bracket[].

Example 3:

# Ruby code implementation 
# for accessing of Ruby Strings
 str = "GeeksforGeeks"
  
# accessing the specified substring
 puts str["Geeks"]

# print a single character from a 
# string using positive index
 puts str[2]
  
# print a single character from a 
# string using negative index
 puts str[-2]
  
# print string in a range using comma(,)
 puts str[4, 10]
  
# print string in a range using(..) operator
 puts str[4 .. 8]

Output:

Geeks
e
k
sforGeeks
sforG

To know more about please refer Ruby Strings article.

Ruby Arrays:

A Ruby array is stored at contiguous memory locations. It is ordered by integer-indexed positions. The 1-D array can be created using a new class method(Array.new) or by using a literal constructor[]

Using new class method
 

Example 4:

# Ruby code implementation for creation of Ruby Arrays 
# using new method
 arr = Array.new(4, 'GFG')
 puts arr.size

# displaying array elements
 puts "#{arr}"

Output:

4 
["GFG", "GFG", "GFG", "GFG"]

 Example 5:

# Ruby code implementation for creation of Ruby Strings
# Using literal[] method
arr = Array['a', 'b', 'c', 'd','e', 'f']

# displaying array elements
puts "#{arr}"

# displaying array size
puts "Size of arr is: #{arr.size}"

# displaying array length
puts "Length of arr is: #{arr.length}"

Output:

["a", "b", "c", "d", "e", "f"]
Size of arr is: 6
Length of arr is: 6

We can retrieve single or multiple elements using both positive and negative indexes:

Example 6:

# Ruby code implementation for accessing of Ruby Arrays
 str = ["GFG", "Geeks", "Ruby", "Containers"]

# Accessing single array elements
 puts "Value at index 1: #{str[1]}"  # using positive index
 puts "Value at index -1: #{str[-1]}"  # using negative index

# Accessing multiple array elements
# using positive index range
puts "Positive index range [1,2]: #{str[1,2]}" 

# using negative index range
puts "Negative index range [-1,2]: #{str[-1,2]}" 

Output:

Value at index 1: Geeks
Value at index -1: Containers
Positive index range [1,2]: ["Geeks", "Ruby"]
Negative index range [-1,2]: ["Containers"]

Ruby  Hashes:

Ruby Hashes is a collection of unique keys and their values, and Hash can be created using literal[], or Hash.new() or try_convert().

Example 7:

# Ruby code implementation for creation of Ruby Hashes
# Using literal[]
 puts "Creation of Hashes using literal[]"
 p Hash["x", 30, "y", 19]
 p Hash["x" => 30, "y" => 19]

# Using of new method
 puts "\nCreation of Hashes using new"
 a = Hash.new("geeksforgeeks")
 p a["x"] = 40
 p a["x"]
 p a["y"]
 puts "\nCreation of Hashes using try_convert"

# Using of try_convert method
 p Hash.try_convert({3=>8})
 p Hash.try_convert("3=>8")

Output:

Creation of Hashes using literal[]
{"x"=>30, "y"=>19}
{"x"=>30, "y"=>19}
Creation of Hashes using new
40
40
"geeksforgeeks"
Creation of Hashes using try_convert
{3=>8}
nil

We can retrieve elements(values) using index(key) which can be anything (integer, character etc.)

Example 8:

# Ruby code implementation for accessing of Ruby Hashes
 a = {"x" => 45, "y" => 67}
 p a["x"]

Output:

45

The default value of Hashes is nil. To know more about Ruby Hashes click here.

Ruby Ranges:

It is declared using the ''..'' and ''...'' range operators.

• The ".." operator includes all the variables within the range as well as the starting and end value.
• The ".." operator includes all the variables within the range as well as the starting value but not the end value.

Example 9:

#Ruby code to show ranges in Ruby
# This will separate the values by comma ","
$, =", "   

#This include 5 & 10
r1 = (5..10).to_a 

#This include 5 but not 10
r2 = (5...10).to_a  

#This include "asa" & "asd"
r3 = ('asa'..'asd').to_a

#This include "asa" but not "asd"
r4 = ('asa'...'asd').to_a 
puts "#{r1}"
puts "#{r2}"
puts "#{r3}"
puts "#{r4}"

Output:

[5, 6, 7, 8, 9, 10]
[5, 6, 7, 8, 9]
["asa", "asb", "asc", "asd"]
["asa", "asb", "asc"]

We can use these ranges as Sequences, Conditions, and Intervals. To know more about Ruby Ranges click here.

Blocks

A block is a sequence of ruby code surrounded by do/end or curly brackets. Methods can take an implicit block argument and call the code in that block with the yield keyword.

Example 10:

# Ruby code implementation for creation of Ruby Blocks
def two_times
  yield
  yield
end
two_times {puts "GFG!"};

Output:

GFG!
GFG!

Blocks as Closures:

Blocks can take an argument: 

>> def times
  yield('fir')
  yield('sec')
end
=> nil
>> times {|n| puts "#{n}: yoo"}
GFG! Rocks
GFG! is the best
=> nil

Example 11:

# Ruby code implementation for creation of Ruby Blocks as Closures

def times
  yield("Rocks")
  yield("is the best")
end
times {|ys| puts "GFG! #{ys}"}

Output:

GFG! Rocks
GFG! is the best

Yield returns the result of executing the block:

Example 12:

# Ruby code implementation for 
# creation of Ruby Blocks as Closures

def gfg
  [yield("GEEKS"), yield("FOR"), yield("GEEKS")]
end
gfg {|geek| puts "#{geek.upcase.reverse}"}

Output:

SKEEG
ROF
SKEEG

A closure block can be defined in one scope and can be called in a different scope. To know more about closures in Ruby click here.

More Block Uses:

Blocks are used in many other ways: 

Example 13:

# Ruby code implementation for 
# Ruby Blocks using each method
 ["Geeks", "GFG", 55].each do |n|
   puts n  
 end 

Output:

Geeks
GFG
55

The default:

# Ruby code implementation for 
# Ruby Blocks using times method
 x = "NULL"
 4.times do |x|
  puts "Value Inside the block: #{x}"
   end
  puts "Value Outside the block: #{x}"

Output:

Value Inside the block: 0
Value Inside the block: 1
Value Inside the block: 2
Value Inside the block: 3
Value Outside the block: NULL

To know more about Ruby Blocks click here.