Array Class

Arrays are sequences of heterogeneous elements, are represented as a comma separate list between square brackets; an integer index, between square brackets is used to refer to single elements; We can have arrays of arrays, simulating multi-dimensional structures.

The class mixes in the Enumerable module , with a lot of iterators.

In the following figure the hierarchy of the Array and Hash classes; some class methods are listed in the square box.

Arrays can be created in the following ways:

a=Array.new          : an empty array

a=Array.new(3)       : to make an array of 3 elements containing "nil"

a=Array.new(3,"a")   : to make an array of 3 elements containing the object: "a"


a=[12,"asd",3.5E3,1,2,3]   : another way to make an array

To make an array from words in a string:

a= %w{ a b c d \n  }  => ["a", "b", "c", "d", "\\n"]

a= %W{ a b c d \\n  } => ["a", "b", "c", "d", "\n"]

if "%w" is used, backslash symbols are not interpreted, as in single-quoted strings. If "%W" is used, backslash are interpreted as in double-quoted strings

The "split" function can obtain an array from a string, the "join" function obtains a string from an array.

The '*' operator can act as a join for arrays, if the second operator is a string:

"1-2-3".split("-") => ["1", "2", "3"]
[1,2,3].join("-")  => "1-2-3"

[1,2]*"a"  => "1a2"

Some operators and functions for arrays are listed in the following table:

flatten has an optional argument: the number of dimension to eliminate:

a=[1,2,[13,14],[15,[26,[37,38]]]]

a.flatten(1) => [1, 2, 13, 14, 15, [26, [37, 38]]]

a.flatten(2) => [1, 2, 13, 14, 15, 26, [37, 38]]

a.flatten(3) => [1, 2, 13, 14, 15, 26, 37, 38]

a.flatten    => [1, 2, 13, 14, 15, 26, 37, 38]

to_a, a member Enumerable, creates an array from a sequence.

zip combines arrays element by element, producing an array of arrays:

(1..3).zip [ "a","b","c"]             => [[1, "a"], [2, "b"], [3, "c"]]

[1,2,3].zip([10,20,30],["a","b","c"]) => [[1, 10, "a"], [2, 20, "b"], [3, 30, "c"]]

(1..3).zip                            => [[1], [2], [3]]

a=[1,2,3,4] ;

a[0] => 1                # index begins from zero
a[-1]=> 4                # negative indexes from the end
a[a.size-1]              # last element

a[0..2]   => [1, 2, 3]   # extracts using a range (last element included)
a[0...2]  => [1, 2]      # extracts using a range (last element NOT included)
a[-4..-2] => [1, 2]

a[0,2]  => [1, 2]        # a sub-array (2 elements from 0)
a[1,2]  => [2, 3]        # 2 elements , from 1
a[-3,2] => [2, 3]        # 2 elements , from -3 ( a[-3]=> 2 )
a[-4,2]    => [1, 2]     # from element -4 (the first) takes 2 elements

a[/regular expr/]        # regular expressions can be used too

a.first(2) => [1, 2]     # first elements
a.last(2)  => [3, 4]     # last elements

a=[1,2,3,4] ; a=['a','b']=> ["a", "b", 2, 3, 4] # reassigns a range of elements

a=[0] ; a[3]=3    => [0, nil, nil, 3]

a=[1,2,3,4]
a[0,2]=0      => [0, 3, 4]     # starting from position 0, sets 2 elements

a=[1,2,3,4]
a[0,2]=5,6    => [5, 6, 3, 4]  # multiple assignments are possible
a[0,2]=[5,6]  => [5, 6, 3, 4]

a=[1,2,3,4]
a[-1]=9       => [1, 2, 3, 9]  # negative indexes counts from the end

Hash Class

Hashes, also named maps, or associative arrays, or dictionaries, are sequences of objects, not retrieved by an integer index, but by a key, which can be any object. Hashes are written as key/value pairs, separated by an arrow, in curly braces, Es.: (1=>"a",2=>"b"}

Hashes mixes in the Enumerable module, with a lot of useful iterators.

The elements are in the order in which they have been inserted in the hash; the last element being the last inserted.

The attempt to access to a non-existing elements returns nil or a default value which can be set at the hash creation or with the default= method.

For hashes the operator "[]" returns values, based on keys; symbols can also be used as keys, for a faster access::

a={"one" => 1, "two" =>2 ,3 => "a"}

a["one"] => 1
a[3]     => "a"

h["a"]=723                # adds, or replaces, en element

h={ :one => 1, :two =>2 } # symbols can be used as keys

h={one: 1 , two: 2 }      # alternate syntax, possible  when keys are symbols

Operators and methods for hashes are listed in the following table:

Range Class

Range objects represent an interval in a sequence, are mainly used in loops and case statements, but also as indexes of arrays and strings. Ranges mixes in the module Enumerable, with a lot of iterators.

Ranges are written as two numbers or characters separated by two or three dots. When three dots are used the last object is not included, when two are used the last element is included.

Not only numbers or characters can be used to make a Range object, but every object which can be treated as a sequence, responding to the comparison method: "<=>" and the "succ" method (which gives the next item of the sequence).

The Range method can be used to built ranges:

a=Range.new(1,3)
1..3             => 1,2,3   # last element is INCLUDED

a=Range.new(1,3,true)
1...3            => 1,2   ; range with last element NOT INCLUDED

(1...3).exclude_end? : true

-3..-1         => -3,-2,-1

'a'..'c'     # range of characters

 1.2..3.5    # range of float (but you can't iterate on these)

 a=[0,1,2,3,4]
 a[1..3]        => [1, 2, 3]
 a[1...3]       => [1, 2]

We can have array of ranges, in this case ranges are not expanded to the sequence they represent, there is nothing as the list comprehension of Python, and, to built an array of values from the range, the "to_a" method must be used.

a=[1..3,5...9] => [1..3, 5...9]

Some methods of ranges are in the following table: