Set Intersection — Returns a new array containing unique elements common to self and other_arys. Order is preserved from the original array.
It compares elements using their hash and eql? methods for efficiency.
[ 1, 1, 3, 5 ].intersection([ 3, 2, 1 ]) # => [ 1, 3 ] [ "a", "b", "z" ].intersection([ "a", "b", "c" ], [ "b" ]) # => [ "b" ] [ "a" ].intersection #=> [ "a" ]
See also Array#&.
Append—Pushes the given object on to the end of this array. This expression returns the array itself, so several appends may be chained together.
a = [ 1, 2 ] a << "c" << "d" << [ 3, 4 ] #=> [ 1, 2, "c", "d", [ 3, 4 ] ] a #=> [ 1, 2, "c", "d", [ 3, 4 ] ]
Append — Pushes the given object(s) on to the end of this array. This expression returns the array itself, so several appends may be chained together. See also Array#pop for the opposite effect.
a = [ "a", "b", "c" ] a.push("d", "e", "f") #=> ["a", "b", "c", "d", "e", "f"] [1, 2, 3].push(4).push(5) #=> [1, 2, 3, 4, 5]
Removes the last element from self and returns it, or nil if the array is empty.
If a number n is given, returns an array of the last n elements (or less) just like array.slice!(-n, n) does. See also Array#push for the opposite effect.
a = [ "a", "b", "c", "d" ] a.pop #=> "d" a.pop(2) #=> ["b", "c"] a #=> ["a"]
Removes the first element of self and returns it (shifting all other elements down by one). Returns nil if the array is empty.
If a number n is given, returns an array of the first n elements (or less) just like array.slice!(0, n) does. With ary containing only the remainder elements, not including what was shifted to new_ary. See also Array#unshift for the opposite effect.
args = [ "-m", "-q", "filename" ] args.shift #=> "-m" args #=> ["-q", "filename"] args = [ "-m", "-q", "filename" ] args.shift(2) #=> ["-m", "-q"] args #=> ["filename"]
Prepends objects to the front of self, moving other elements upwards. See also Array#shift for the opposite effect.
a = [ "b", "c", "d" ] a.unshift("a") #=> ["a", "b", "c", "d"] a.unshift(1, 2) #=> [ 1, 2, "a", "b", "c", "d"]
Inserts the given values before the element with the given index.
Negative indices count backwards from the end of the array, where -1 is the last element. If a negative index is used, the given values will be inserted after that element, so using an index of -1 will insert the values at the end of the array.
a = %w{ a b c d } a.insert(2, 99) #=> ["a", "b", 99, "c", "d"] a.insert(-2, 1, 2, 3) #=> ["a", "b", 99, "c", 1, 2, 3, "d"]
Calls the given block once for each element in self, passing that element as a parameter. Returns the array itself.
If no block is given, an Enumerator is returned.
a = [ "a", "b", "c" ] a.each {|x| print x, " -- " }
produces:
a -- b -- c --
Returns the number of elements in self. May be zero.
[ 1, 2, 3, 4, 5 ].length #=> 5 [].length #=> 0
Returns the index of the first object in ary such that the object is == to obj.
If a block is given instead of an argument, returns the index of the first object for which the block returns true. Returns nil if no match is found.
See also Array#rindex.
An Enumerator is returned if neither a block nor argument is given.
a = [ "a", "b", "c" ] a.index("b") #=> 1 a.index("z") #=> nil a.index {|x| x == "b"} #=> 1
Returns the index of the last object in self == to obj.
If a block is given instead of an argument, returns the index of the first object for which the block returns true, starting from the last object.
Returns nil if no match is found.
See also Array#index.
If neither block nor argument is given, an Enumerator is returned instead.
a = [ "a", "b", "b", "b", "c" ] a.rindex("b") #=> 3 a.rindex("z") #=> nil a.rindex {|x| x == "b"} #=> 3
Returns a string created by converting each element of the array to a string, separated by the given separator. If the separator is nil, it uses current $,. If both the separator and $, are nil, it uses an empty string.
[ "a", "b", "c" ].join #=> "abc" [ "a", "b", "c" ].join("-") #=> "a-b-c"
For nested arrays, join is applied recursively:
[ "a", [1, 2, [:x, :y]], "b" ].join("-") #=> "a-1-2-x-y-b"
Returns a new array containing self‘s elements in reverse order.
[ "a", "b", "c" ].reverse #=> ["c", "b", "a"] [ 1 ].reverse #=> [1]
Reverses self in place.
a = [ "a", "b", "c" ] a.reverse! #=> ["c", "b", "a"] a #=> ["c", "b", "a"]
Returns a new array by rotating self so that the element at count is the first element of the new array.
If count is negative then it rotates in the opposite direction, starting from the end of self where -1 is the last element.
a = [ "a", "b", "c", "d" ] a.rotate #=> ["b", "c", "d", "a"] a #=> ["a", "b", "c", "d"] a.rotate(2) #=> ["c", "d", "a", "b"] a.rotate(-3) #=> ["b", "c", "d", "a"]
Rotates self in place so that the element at count comes first, and returns self.
If count is negative then it rotates in the opposite direction, starting from the end of the array where -1 is the last element.
a = [ "a", "b", "c", "d" ] a.rotate! #=> ["b", "c", "d", "a"] a #=> ["b", "c", "d", "a"] a.rotate!(2) #=> ["d", "a", "b", "c"] a.rotate!(-3) #=> ["a", "b", "c", "d"]
Returns a new array created by sorting self.
Comparisons for the sort will be done using the <=> operator or using an optional code block.
The block must implement a comparison between a and b and return an integer less than 0 when b follows a, 0 when a and b are equivalent, or an integer greater than 0 when a follows b.
The result is not guaranteed to be stable. When the comparison of two elements returns 0, the order of the elements is unpredictable.
ary = [ "d", "a", "e", "c", "b" ] ary.sort #=> ["a", "b", "c", "d", "e"] ary.sort {|a, b| b <=> a} #=> ["e", "d", "c", "b", "a"]
To produce the reverse order, the following can also be used (and may be faster):
ary.sort.reverse! #=> ["e", "d", "c", "b", "a"]
See also Enumerable#sort_by.
Sorts self in place.
Comparisons for the sort will be done using the <=> operator or using an optional code block.
The block must implement a comparison between a and b and return an integer less than 0 when b follows a, 0 when a and b are equivalent, or an integer greater than 0 when a follows b.
The result is not guaranteed to be stable. When the comparison of two elements returns 0, the order of the elements is unpredictable.
ary = [ "d", "a", "e", "c", "b" ] ary.sort! #=> ["a", "b", "c", "d", "e"] ary.sort! {|a, b| b <=> a} #=> ["e", "d", "c", "b", "a"]
See also Enumerable#sort_by.
Invokes the given block once for each element of self.
Creates a new array containing the values returned by the block.
See also Enumerable#collect.
If no block is given, an Enumerator is returned instead.
a = [ "a", "b", "c", "d" ] a.collect {|x| x + "!"} #=> ["a!", "b!", "c!", "d!"] a.map.with_index {|x, i| x * i} #=> ["", "b", "cc", "ddd"] a #=> ["a", "b", "c", "d"]
Invokes the given block once for each element of self, replacing the element with the value returned by the block.
See also Enumerable#collect.
If no block is given, an Enumerator is returned instead.
a = [ "a", "b", "c", "d" ] a.map! {|x| x + "!" } a #=> [ "a!", "b!", "c!", "d!" ] a.collect!.with_index {|x, i| x[0...i] } a #=> ["", "b", "c!", "d!"]
Invokes the given block once for each element of self.
Creates a new array containing the values returned by the block.
See also Enumerable#collect.
If no block is given, an Enumerator is returned instead.
a = [ "a", "b", "c", "d" ] a.collect {|x| x + "!"} #=> ["a!", "b!", "c!", "d!"] a.map.with_index {|x, i| x * i} #=> ["", "b", "cc", "ddd"] a #=> ["a", "b", "c", "d"]
Invokes the given block once for each element of self, replacing the element with the value returned by the block.
See also Enumerable#collect.
If no block is given, an Enumerator is returned instead.
a = [ "a", "b", "c", "d" ] a.map! {|x| x + "!" } a #=> [ "a!", "b!", "c!", "d!" ] a.collect!.with_index {|x, i| x[0...i] } a #=> ["", "b", "c!", "d!"]
Returns a new array containing all elements of ary for which the given block returns a true value.
If no block is given, an Enumerator is returned instead.
[1,2,3,4,5].select {|num| num.even? } #=> [2, 4] a = %w[ a b c d e f ] a.select {|v| v =~ /[aeiou]/ } #=> ["a", "e"]
See also Enumerable#select.
Array#filter is an alias for Array#select.
Invokes the given block passing in successive elements from self, deleting elements for which the block returns a false value.
The array may not be changed instantly every time the block is called.
If changes were made, it will return self, otherwise it returns nil.
If no block is given, an Enumerator is returned instead.
See also Array#keep_if.
Array#filter! is an alias for Array#select!.