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!.
Deletes all items from self that are equal to obj.
Returns the last deleted item, or nil if no matching item is found.
If the optional code block is given, the result of the block is returned if the item is not found. (To remove nil elements and get an informative return value, use Array#compact!)
a = [ "a", "b", "b", "b", "c" ] a.delete("b") #=> "b" a #=> ["a", "c"] a.delete("z") #=> nil a.delete("z") {"not found"} #=> "not found"
Returns a new array containing the items in self for which the given block is not true. The ordering of non-rejected elements is maintained.
See also Array#delete_if
If no block is given, an Enumerator is returned instead.
Deletes every element of self for which the block evaluates to true, if no changes were made returns nil.
The array may not be changed instantly every time the block is called.
See also Enumerable#reject and Array#delete_if.
If no block is given, an Enumerator is returned instead.
Converts any arguments to arrays, then merges elements of self with corresponding elements from each argument.
This generates a sequence of ary.size n-element arrays, where n is one more than the count of arguments.
If the size of any argument is less than the size of the initial array, nil values are supplied.
If a block is given, it is invoked for each output array, otherwise an array of arrays is returned.
a = [ 4, 5, 6 ] b = [ 7, 8, 9 ] [1, 2, 3].zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]] [1, 2].zip(a, b) #=> [[1, 4, 7], [2, 5, 8]] a.zip([1, 2], [8]) #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]]
Replaces the contents of self with the contents of other_ary, truncating or expanding if necessary.
a = [ "a", "b", "c", "d", "e" ] a.replace([ "x", "y", "z" ]) #=> ["x", "y", "z"] a #=> ["x", "y", "z"]
The first three forms set the selected elements of self (which may be the entire array) to obj.
A start of nil is equivalent to zero.
A length of nil is equivalent to the length of the array.
The last three forms fill the array with the value of the given block, which is passed the absolute index of each element to be filled.
Negative values of start count from the end of the array, where -1 is the last element.
a = [ "a", "b", "c", "d" ] a.fill("x") #=> ["x", "x", "x", "x"] a.fill("z", 2, 2) #=> ["x", "x", "z", "z"] a.fill("y", 0..1) #=> ["y", "y", "z", "z"] a.fill {|i| i*i} #=> [0, 1, 4, 9] a.fill(-2) {|i| i*i*i} #=> [0, 1, 8, 27]
Returns true if the given object is present in self (that is, if any element == object), otherwise returns false.
a = [ "a", "b", "c" ] a.include?("b") #=> true a.include?("z") #=> false
Comparison — Returns an integer (-1, 0, or +1) if this array is less than, equal to, or greater than other_ary.
Each object in each array is compared (using the <=> operator).
Arrays are compared in an “element-wise” manner; the first element of ary is compared with the first one of other_ary using the <=> operator, then each of the second elements, etc… As soon as the result of any such comparison is non zero (i.e. the two corresponding elements are not equal), that result is returned for the whole array comparison.
If all the elements are equal, then the result is based on a comparison of the array lengths. Thus, two arrays are “equal” according to Array#<=> if, and only if, they have the same length and the value of each element is equal to the value of the corresponding element in the other array.
nil is returned if the other_ary is not an array or if the comparison of two elements returned nil.
[ "a", "a", "c" ] <=> [ "a", "b", "c" ] #=> -1 [ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ] #=> +1 [ 1, 2 ] <=> [ 1, :two ] #=> nil
Element Reference — Returns the element at index, or returns a subarray starting at the start index and continuing for length elements, or returns a subarray specified by range of indices.
Negative indices count backward from the end of the array (-1 is the last element). For start and range cases the starting index is just before an element. Additionally, an empty array is returned when the starting index for an element range is at the end of the array.
Returns nil if the index (or starting index) are out of range.
a = [ "a", "b", "c", "d", "e" ] a[2] + a[0] + a[1] #=> "cab" a[6] #=> nil a[1, 2] #=> [ "b", "c" ] a[1..3] #=> [ "b", "c", "d" ] a[4..7] #=> [ "e" ] a[6..10] #=> nil a[-3, 3] #=> [ "c", "d", "e" ] # special cases a[5] #=> nil a[6, 1] #=> nil a[5, 1] #=> [] a[5..10] #=> []
Deletes the element(s) given by an index (optionally up to length elements) or by a range.
Returns the deleted object (or objects), or nil if the index is out of range.
a = [ "a", "b", "c" ] a.slice!(1) #=> "b" a #=> ["a", "c"] a.slice!(-1) #=> "c" a #=> ["a"] a.slice!(100) #=> nil a #=> ["a"]
Searches through an array whose elements are also arrays comparing obj with the first element of each contained array using obj.==.
Returns the first contained array that matches (that is, the first associated array), or nil if no match is found.
See also Array#rassoc
s1 = [ "colors", "red", "blue", "green" ] s2 = [ "letters", "a", "b", "c" ] s3 = "foo" a = [ s1, s2, s3 ] a.assoc("letters") #=> [ "letters", "a", "b", "c" ] a.assoc("foo") #=> nil
Concatenation — Returns a new array built by concatenating the two arrays together to produce a third array.
[ 1, 2, 3 ] + [ 4, 5 ] #=> [ 1, 2, 3, 4, 5 ] a = [ "a", "b", "c" ] c = a + [ "d", "e", "f" ] c #=> [ "a", "b", "c", "d", "e", "f" ] a #=> [ "a", "b", "c" ]
Note that
x += y
is the same as
x = x + y
This means that it produces a new array. As a consequence, repeated use of += on arrays can be quite inefficient.
See also Array#concat.
Repetition — With a String argument, equivalent to ary.join(str).
Otherwise, returns a new array built by concatenating the int copies of self.
[ 1, 2, 3 ] * 3 #=> [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ] [ 1, 2, 3 ] * "," #=> "1,2,3"
Array Difference
Returns a new array that is a copy of the original array, removing all occurrences of any item that also appear in other_ary. The order is preserved from the original array.
It compares elements using their hash and eql? methods for efficiency.
[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ] #=> [ 3, 3, 5 ]
Note that while 1 and 2 were only present once in the array argument, and were present twice in the receiver array, all occurrences of each Integer are removed in the returned array.
If you need set-like behavior, see the library class Set.
See also Array#difference.
Set Intersection — Returns a new array containing unique elements common to the two arrays. The order is preserved from the original array.
It compares elements using their hash and eql? methods for efficiency.
[ 1, 1, 3, 5 ] & [ 3, 2, 1 ] #=> [ 1, 3 ] [ 'a', 'b', 'b', 'z' ] & [ 'a', 'b', 'c' ] #=> [ 'a', 'b' ]
See also Array#uniq.
Set Union — Returns a new array by joining ary with other_ary, excluding any duplicates and preserving the order from the given arrays.
It compares elements using their hash and eql? methods for efficiency.
[ "a", "b", "c" ] | [ "c", "d", "a" ] #=> [ "a", "b", "c", "d" ] [ "c", "d", "a" ] | [ "a", "b", "c" ] #=> [ "c", "d", "a", "b" ]
See also Array#union.
Returns the object in ary with the maximum value. The first form assumes all objects implement Comparable; the second uses the block to return a <=> b.
ary = %w(albatross dog horse) ary.max #=> "horse" ary.max {|a, b| a.length <=> b.length} #=> "albatross"
If the n argument is given, maximum n elements are returned as an array.
ary = %w[albatross dog horse] ary.max(2) #=> ["horse", "dog"] ary.max(2) {|a, b| a.length <=> b.length } #=> ["albatross", "horse"]
Returns the object in ary with the minimum value. The first form assumes all objects implement Comparable; the second uses the block to return a <=> b.
ary = %w(albatross dog horse) ary.min #=> "albatross" ary.min {|a, b| a.length <=> b.length} #=> "dog"
If the n argument is given, minimum n elements are returned as an array.
ary = %w[albatross dog horse] ary.min(2) #=> ["albatross", "dog"] ary.min(2) {|a, b| a.length <=> b.length } #=> ["dog", "horse"]
Returns a two element array which contains the minimum and the maximum value in the array.
Can be given an optional block to override the default comparison method a <=> b.
Returns a new array by removing duplicate values in self.
If a block is given, it will use the return value of the block for comparison.
It compares values using their hash and eql? methods for efficiency.
self is traversed in order, and the first occurrence is kept.
a = [ "a", "a", "b", "b", "c" ] a.uniq # => ["a", "b", "c"] b = [["student","sam"], ["student","george"], ["teacher","matz"]] b.uniq {|s| s.first} # => [["student", "sam"], ["teacher", "matz"]]
Removes duplicate elements from self.
If a block is given, it will use the return value of the block for comparison.
It compares values using their hash and eql? methods for efficiency.
self is traversed in order, and the first occurrence is kept.
Returns nil if no changes are made (that is, no duplicates are found).
a = [ "a", "a", "b", "b", "c" ] a.uniq! # => ["a", "b", "c"] b = [ "a", "b", "c" ] b.uniq! # => nil c = [["student","sam"], ["student","george"], ["teacher","matz"]] c.uniq! {|s| s.first} # => [["student", "sam"], ["teacher", "matz"]]
Returns a copy of self with all nil elements removed.
[ "a", nil, "b", nil, "c", nil ].compact #=> [ "a", "b", "c" ]
Removes nil elements from the array.
Returns nil if no changes were made, otherwise returns the array.
[ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ] [ "a", "b", "c" ].compact! #=> nil