Appends each argument in objects to self; returns self:
a = [:foo, 'bar', 2] # => [:foo, "bar", 2] a.push(:baz, :bat) # => [:foo, "bar", 2, :baz, :bat]
Appends each argument as a single element, even if it is another array:
a = [:foo, 'bar', 2] # => [:foo, "bar", 2] a.push([:baz, :bat], [:bam, :bad]) # => [:foo, "bar", 2, [:baz, :bat], [:bam, :bad]]
Related: see Methods for Assigning.
Removes and returns trailing elements of self.
With no argument given, removes and returns the last element, if available; otherwise returns nil:
a = [:foo, 'bar', 2] a.pop # => 2 a # => [:foo, "bar"] [].pop # => nil
With non-negative integer argument count given, returns a new array containing the trailing count elements of self, as available:
a = [:foo, 'bar', 2] a.pop(2) # => ["bar", 2] a # => [:foo] a = [:foo, 'bar', 2] a.pop(50) # => [:foo, "bar", 2] a # => []
Related: Array#push; see also Methods for Deleting.
Removes and returns leading elements from self.
With no argument, removes and returns one element, if available, or nil otherwise:
a = [0, 1, 2, 3] a.shift # => 0 a # => [1, 2, 3] [].shift # => nil
With non-negative numeric argument count given, removes and returns the first count elements:
a = [0, 1, 2, 3] a.shift(2) # => [0, 1] a # => [2, 3] a.shift(1.1) # => [2] a # => [3] a.shift(0) # => [] a # => [3]
If count is large, removes and returns all elements:
a = [0, 1, 2, 3] a.shift(50) # => [0, 1, 2, 3] a # => []
If self is empty, returns a new empty array.
Related: see Methods for Deleting.
Prepends the given objects to self:
a = [:foo, 'bar', 2] a.unshift(:bam, :bat) # => [:bam, :bat, :foo, "bar", 2]
Related: Array#shift; see also Methods for Assigning.
Inserts the given objects as elements of self; returns self.
When index is non-negative, inserts objects before the element at offset index:
a = ['a', 'b', 'c'] # => ["a", "b", "c"] a.insert(1, :x, :y, :z) # => ["a", :x, :y, :z, "b", "c"]
Extends the array if index is beyond the array (index >= self.size):
a = ['a', 'b', 'c'] # => ["a", "b", "c"] a.insert(5, :x, :y, :z) # => ["a", "b", "c", nil, nil, :x, :y, :z]
When index is negative, inserts objects after the element at offset index + self.size:
a = ['a', 'b', 'c'] # => ["a", "b", "c"] a.insert(-2, :x, :y, :z) # => ["a", "b", :x, :y, :z, "c"]
With no objects given, does nothing:
a = ['a', 'b', 'c'] # => ["a", "b", "c"] a.insert(1) # => ["a", "b", "c"] a.insert(50) # => ["a", "b", "c"] a.insert(-50) # => ["a", "b", "c"]
Raises IndexError if objects are given and index is negative and out of range.
Related: see Methods for Assigning.
With a block given, iterates over the elements of self, passing each element to the block; returns self:
a = [:foo, 'bar', 2] a.each {|element| puts "#{element.class} #{element}" }
Output:
Symbol foo String bar Integer 2
Allows the array to be modified during iteration:
a = [:foo, 'bar', 2] a.each {|element| puts element; a.clear if element.to_s.start_with?('b') }
Output:
foo bar
With no block given, returns a new Enumerator.
Related: see Methods for Iterating.
Returns the count of elements in self:
[0, 1, 2].length # => 3 [].length # => 0
Related: see Methods for Querying.
Returns the count of elements in self:
[0, 1, 2].length # => 3 [].length # => 0
Related: see Methods for Querying.
Returns true if the count of elements in self is zero, false otherwise.
Related: see Methods for Querying.
Returns the zero-based integer index of a specified element, or nil.
With only argument object given, returns the index of the first element element for which object == element:
a = [:foo, 'bar', 2, 'bar'] a.index('bar') # => 1
Returns nil if no such element found.
With only a block given, calls the block with each successive element; returns the index of the first element for which the block returns a truthy value:
a = [:foo, 'bar', 2, 'bar'] a.index {|element| element == 'bar' } # => 1
Returns nil if the block never returns a truthy value.
With neither an argument nor a block given, returns a new Enumerator.
Related: see Methods for Querying.
Returns the index of the last element for which object == element.
With argument object given, returns the index of the last such element found:
a = [:foo, 'bar', 2, 'bar'] a.rindex('bar') # => 3
Returns nil if no such object found.
With a block given, calls the block with each successive element; returns the index of the last element for which the block returns a truthy value:
a = [:foo, 'bar', 2, 'bar'] a.rindex {|element| element == 'bar' } # => 3
Returns nil if the block never returns a truthy value.
When neither an argument nor a block is given, returns a new Enumerator.
Related: see Methods for Querying.
Returns the new string formed by joining the converted elements of self; for each element element:
Converts recursively using element.join(separator) if element is a kind_of?(Array).
Otherwise, converts using element.to_s.
With no argument given, joins using the output field separator, $,:
a = [:foo, 'bar', 2] $, # => nil a.join # => "foobar2"
With string argument separator given, joins using that separator:
a = [:foo, 'bar', 2] a.join("\n") # => "foo\nbar\n2"
Joins recursively for nested arrays:
a = [:foo, [:bar, [:baz, :bat]]] a.join # => "foobarbazbat"
Related: see Methods for Converting.
Returns a new array containing the elements of self in reverse order:
[0, 1, 2].reverse # => [2, 1, 0]
Related: see Methods for Combining.
Reverses the order of the elements of self; returns self:
a = [0, 1, 2] a.reverse! # => [2, 1, 0] a # => [2, 1, 0]
Related: see Methods for Assigning.
Returns a new array formed from self with elements rotated from one end to the other.
With non-negative numeric count, rotates elements from the beginning to the end:
[0, 1, 2, 3].rotate(2) # => [2, 3, 0, 1] [0, 1, 2, 3].rotate(2.1) # => [2, 3, 0, 1]
If count is large, uses count % array.size as the count:
[0, 1, 2, 3].rotate(22) # => [2, 3, 0, 1]
With a count of zero, rotates no elements:
[0, 1, 2, 3].rotate(0) # => [0, 1, 2, 3]
With negative numeric count, rotates in the opposite direction, from the end to the beginning:
[0, 1, 2, 3].rotate(-1) # => [3, 0, 1, 2]
If count is small (far from zero), uses count % array.size as the count:
[0, 1, 2, 3].rotate(-21) # => [3, 0, 1, 2]
Related: see Methods for Fetching.
Rotates self in place by moving elements from one end to the other; returns self.
With non-negative numeric count, rotates count elements from the beginning to the end:
[0, 1, 2, 3].rotate!(2) # => [2, 3, 0, 1] [0, 1, 2, 3].rotate!(2.1) # => [2, 3, 0, 1]
If count is large, uses count % array.size as the count:
[0, 1, 2, 3].rotate!(21) # => [1, 2, 3, 0]
If count is zero, rotates no elements:
[0, 1, 2, 3].rotate!(0) # => [0, 1, 2, 3]
With a negative numeric count, rotates in the opposite direction, from end to beginning:
[0, 1, 2, 3].rotate!(-1) # => [3, 0, 1, 2]
If count is small (far from zero), uses count % array.size as the count:
[0, 1, 2, 3].rotate!(-21) # => [3, 0, 1, 2]
Related: see Methods for Assigning.
Returns a new array containing the elements of self, sorted.
With no block given, compares elements using operator #<=> (see Object#<=>):
[0, 2, 3, 1].sort # => [0, 1, 2, 3]
With a block given, calls the block with each combination of pairs of elements from self; for each pair a and b, the block should return a numeric:
Negative when b is to follow a.
Zero when a and b are equivalent.
Positive when a is to follow b.
Example:
a = [3, 2, 0, 1] a.sort {|a, b| a <=> b } # => [0, 1, 2, 3] a.sort {|a, b| b <=> a } # => [3, 2, 1, 0]
When the block returns zero, the order for a and b is indeterminate, and may be unstable.
Related: see Methods for Fetching.
Like Array#sort, but returns self with its elements sorted in place.
Related: see Methods for Assigning.
With a block given, calls the block with each element of self; returns a new array whose elements are the return values from the block:
a = [:foo, 'bar', 2] a1 = a.map {|element| element.class } a1 # => [Symbol, String, Integer]
With no block given, returns a new Enumerator.
Related: collect!; see also Methods for Converting.
With a block given, calls the block with each element of self and replaces the element with the block’s return value; returns self:
a = [:foo, 'bar', 2] a.map! { |element| element.class } # => [Symbol, String, Integer]
With no block given, returns a new Enumerator.
Related: collect; see also Methods for Converting.
With a block given, calls the block with each element of self; returns a new array whose elements are the return values from the block:
a = [:foo, 'bar', 2] a1 = a.map {|element| element.class } a1 # => [Symbol, String, Integer]
With no block given, returns a new Enumerator.
Related: collect!; see also Methods for Converting.
With a block given, calls the block with each element of self and replaces the element with the block’s return value; returns self:
a = [:foo, 'bar', 2] a.map! { |element| element.class } # => [Symbol, String, Integer]
With no block given, returns a new Enumerator.
Related: collect; see also Methods for Converting.
With a block given, calls the block with each element of self; returns a new array containing those elements of self for which the block returns a truthy value:
a = [:foo, 'bar', 2, :bam] a.select {|element| element.to_s.start_with?('b') } # => ["bar", :bam]
With no block given, returns a new Enumerator.
Related: see Methods for Fetching.
With a block given, calls the block with each element of self; removes from self those elements for which the block returns false or nil.
Returns self if any elements were removed:
a = [:foo, 'bar', 2, :bam] a.select! {|element| element.to_s.start_with?('b') } # => ["bar", :bam]
Returns nil if no elements were removed.
With no block given, returns a new Enumerator.
Related: see Methods for Deleting.
With a block given, calls the block with each element of self; returns a new array containing those elements of self for which the block returns a truthy value:
a = [:foo, 'bar', 2, :bam] a.select {|element| element.to_s.start_with?('b') } # => ["bar", :bam]
With no block given, returns a new Enumerator.
Related: see Methods for Fetching.