Returns the additive identity of this type.

This is an empty array.

Creates a newArray, allocating an internal buffer with the givencapacity, and yielding that buffer. The given block must return the desired size of the array.

This method isunsafe, but is usually used to initialize the buffer by passing it to a C function.

Array.build(3) do |buffer|
  LibSome.fill_buffer_and_return_number_of_elements_filled(buffer)
end

Creates a newArray of the givensize filled with the samevalue in each position.

Array.new(3, 'a') # => ['a', 'a', 'a']

WARNING The initial value is filled into the array as-is. It gets neither duplicated nor cloned. For types with reference semantics this means every item will point to thesame object.

ary = Array.new(3, [1])
ary # => [[1], [1], [1]]
ary[0][0] = 2
ary # => [[2], [2], [2]]

• .new(Int, & : Int32 -> T) is an alternative that allows using a different initial value for each position.

Creates a new emptyArray backed by a buffer that is initially initial_capacity big.

Theinitial_capacity is useful to avoid unnecessary reallocations of the internal buffer in case of growth. If you have an estimate of the maximum number of elements an array will hold, the array should be initialized with that capacity for improved performance.

ary = Array(Int32).new(5)
ary.size # => 0

Creates a new emptyArray.

Creates a newArray of the givensize and invokes the given block once for each index ofself, assigning the block's value in that index.

Array.new(3) { |i| (i + 1) ** 2 } # => [1, 4, 9]

ary = Array.new(3) { [1] }
ary # => [[1], [1], [1]]
ary[0][0] = 2
ary # => [[2], [1], [1]]

Yields each ordered combination of the elements taken from each of the arrays asArrays. Traversal of elements starts from the last given array.

DEPRECATED UseIndexable.each_cartesian(indexables : Indexable(Indexable), reuse = false, &block) instead

Yields each ordered combination of the elements taken from each of the arrays asArrays. Traversal of elements starts from the last given array.

DEPRECATED UseIndexable.each_cartesian(indexables : Indexable(Indexable), reuse = false, &block) instead

Parses aString orIO denoting a JSON array, yielding each of its elements to the given block. This is useful for decoding an array and processing its elements without creating an Array in memory, which might be expensive.

require "json"

Array(Int32).from_json("[1, 2, 3]") do |element|
  puts element
end

Output:

1
2
3

To parse and get anArray, use the block-less overload.

Returns anArray of all ordered combinations of elements taken from each of thearrays asArrays. Traversal of elements starts from the last given array.

DEPRECATED UseIndexable.cartesian_product(indexables : Indexable(Indexable)) instead

Returns anArray of all ordered combinations of elements taken from each of thearrays asArrays. Traversal of elements starts from the last given array.

DEPRECATED UseIndexable.cartesian_product(indexables : Indexable(Indexable)) instead

Set intersection: returns a newArray containing elements common toself andother, excluding any duplicates. The order is preserved fromself.

[1, 1, 3, 5] & [1, 2, 3]               # => [ 1, 3 ]
['a', 'b', 'b', 'z'] & ['a', 'b', 'c'] # => [ 'a', 'b' ]

See also:#uniq.

Repetition: Returns a newArray built by concatenatingtimes copies ofself.

["a", "b", "c"] * 2 # => [ "a", "b", "c", "a", "b", "c" ]

Concatenation. Returns a newArray built by concatenatingself andother. The type of the new array is the union of the types of both the original arrays.

[1, 2] + ["a"]  # => [1,2,"a"] of (Int32 | String)
[1, 2] + [2, 3] # => [1,2,2,3]

Difference. Returns a newArray that is a copy ofself, removing any items that appear inother. The order ofself is preserved.

[1, 2, 3] - [2, 1] # => [3]

Append. Alias for#push.

a = [1, 2]
a << 3 # => [1,2,3]

Combined comparison operator.

Returns-1,0 or1 depending on whetherself is less thanother, equalsother or is greater thanother.

It compares the elements of both arrays in the same position using the <=> operator. As soon as one of such comparisons returns a non-zero value, that result is the return value of the comparison.

If all elements are equal, the comparison is based on the size of the arrays.

[8] <=> [1, 2, 3] # => 1
[2] <=> [4, 2, 3] # => -1
[1, 2] <=> [1, 2] # => 0

Equality. Returnstrue if each element inself is equal to each corresponding element inother.

ary = [1, 2, 3]
ary == [1, 2, 3] # => true
ary == [2, 3]    # => false

Returnsfalse (other can only be aValue here).

Returns count or less (if there aren't enough) elements starting at the given start index.

Negativestart is added toself.size, thus it's treated as index counting from the end of the array,-1 designating the last element.

RaisesIndexError ifstart index is out of bounds. RaisesArgumentError ifcount is negative.

a = ["a", "b", "c", "d", "e"]
a[-3, 3] # => ["c", "d", "e"]
a[1, 2]  # => ["b", "c"]
a[5, 1]  # => []
a[6, 1]  # raises IndexError

Returns all elements that are within the given range.

The first element in the returned array isself[range.begin] followed by the next elements up to indexrange.end (orself[range.end - 1] if the range is exclusive). If there are fewer elements inself, the returned array is shorter than range.size.

a = ["a", "b", "c", "d", "e"]
a[1..3] # => ["b", "c", "d"]
# range.end > array.size
a[3..7] # => ["d", "e"]

Open ended ranges are clamped at the start and end of the array, respectively.

# open ended ranges
a[2..] # => ["c", "d", "e"]
a[..2] # => ["a", "b", "c"]

Negative range values are added toself.size, thus they are treated as indices counting from the end of the array,-1 designating the last element.

# negative indices, both ranges are equivalent for `a`
a[1..3]   # => ["b", "c", "d"]
a[-4..-2] # => ["b", "c", "d"]
# Mixing negative and positive indices, both ranges are equivalent for `a`
a[1..-2] # => ["b", "c", "d"]
a[-4..3] # => ["b", "c", "d"]

RaisesIndexError if the start index is out of range (range.begin > self.size || range.begin < -self.size). Ifrange.begin == self.size an empty array is returned. Ifrange.begin > range.end, an empty array is returned.

# range.begin > array.size
a[6..10] # raise IndexError
# range.begin == array.size
a[5..10] # => []
# range.begin > range.end
a[3..1]   # => []
a[-2..-4] # => []
a[-2..1]  # => []
a[3..-4]  # => []

Replaces a subrange with the elements of the given array.

a = [1, 2, 3, 4, 5]
a[1, 3] = [6, 7, 8]
a # => [1, 6, 7, 8, 5]

a = [1, 2, 3, 4, 5]
a[1, 3] = [6, 7]
a # => [1, 6, 7, 5]

a = [1, 2, 3, 4, 5]
a[1, 3] = [6, 7, 8, 9, 10]
a # => [1, 6, 7, 8, 9, 10, 5]

Replaces a subrange with a single value. All elements in the range start...start+count are removed and replaced by a single element value.

Ifcount is zero,value is inserted atstart.

Negative values ofstart count from the end of the array.

a = [1, 2, 3, 4, 5]
a[1, 3] = 6
a # => [1, 6, 5]

a = [1, 2, 3, 4, 5]
a[1, 0] = 6
a # => [1, 6, 2, 3, 4, 5]

Replaces a subrange with the elements of the given array.

a = [1, 2, 3, 4, 5]
a[1..3] = [6, 7, 8]
a # => [1, 6, 7, 8, 5]

a = [1, 2, 3, 4, 5]
a[1..3] = [6, 7]
a # => [1, 6, 7, 5]

a = [1, 2, 3, 4, 5]
a[1..3] = [6, 7, 8, 9, 10]
a # => [1, 6, 7, 8, 9, 10, 5]

a = [1, 2, 3, 4, 5]
a[2..] = [6, 7, 8, 9, 10]
a # => [1, 2, 6, 7, 8, 9, 10]

Replaces a subrange with a single value.

a = [1, 2, 3, 4, 5]
a[1..3] = 6
a # => [1, 6, 5]

a = [1, 2, 3, 4, 5]
a[1...1] = 6
a # => [1, 6, 2, 3, 4, 5]

a = [1, 2, 3, 4, 5]
a[2...] = 6
a # => [1, 2, 6]

Replaces a subrange with the elements of the given array.

a = [1, 2, 3, 4, 5]
a[1, 3] = [6, 7, 8]
a # => [1, 6, 7, 8, 5]

a = [1, 2, 3, 4, 5]
a[1, 3] = [6, 7]
a # => [1, 6, 7, 5]

a = [1, 2, 3, 4, 5]
a[1, 3] = [6, 7, 8, 9, 10]
a # => [1, 6, 7, 8, 9, 10, 5]

DEPRECATED Use#[]=(start, count, values) instead

Replaces a subrange with a single value. All elements in the range start...start+count are removed and replaced by a single element value.

Ifcount is zero,value is inserted atstart.

Negative values ofstart count from the end of the array.

a = [1, 2, 3, 4, 5]
a[1, 3] = 6
a # => [1, 6, 5]

a = [1, 2, 3, 4, 5]
a[1, 0] = 6
a # => [1, 6, 2, 3, 4, 5]

DEPRECATED Use#[]=(start, count, value) instead

Like#[](Int, Int) but returnsnil if thestart index is out of range.

Like#[](Range), but returnsnil ifrange.begin is out of range.

a = ["a", "b", "c", "d", "e"]
a[6..10]? # => nil
a[6..]?   # => nil

Set union: returns a newArray by joiningself withother, excluding any duplicates, and preserving the order fromself.

["a", "b", "c"] | ["c", "d", "a"] # => [ "a", "b", "c", "d" ]

See also:#uniq.

Removes all elements fromself.

a = ["a", "b", "c", "d", "e"]
a.clear # => []

Returns a newArray that hasself's elements cloned. That is, it returns a deep copy ofself.

Use#dup if you want a shallow copy.

ary = [[1, 2], [3, 4]]
ary2 = ary.clone
ary[0][0] = 5
ary  # => [[5, 2], [3, 4]]
ary2 # => [[1, 2], [3, 4]]

ary2 << [7, 8]
ary  # => [[5, 2], [3, 4]]
ary2 # => [[1, 2], [3, 4], [7, 8]]

Returns a copy ofself with allnil elements removed.

["a", nil, "b", nil, "c", nil].compact # => ["a", "b", "c"]

Removes allnil elements fromself and returnsself.

ary = ["a", nil, "b", nil, "c"]
ary.compact!
ary # => ["a", "b", "c"]

Appends the elements ofother toself, and returnsself.

ary = ["a", "b"]
ary.concat(["c", "d"])
ary # => ["a", "b", "c", "d"]

Appends the elements ofother toself, and returnsself.

ary = ["a", "b"]
ary.concat(["c", "d"])
ary # => ["a", "b", "c", "d"]

Removes all items fromself that are equal toobj.

Returns the last found element that was equal toobj, if any, ornil if not found.

a = ["a", "b", "b", "b", "c"]
a.delete("b") # => "b"
a             # => ["a", "c"]

a.delete("x") # => nil
a             # => ["a", "c"]

Removescount elements fromself starting atstart. If the size ofself is less thancount, removes values to the end of the array without error. Returns an array of the removed elements with the original order ofself preserved. RaisesIndexError ifstart is out of range.

a = ["ant", "bat", "cat", "dog"]
a.delete_at(1, 2)  # => ["bat", "cat"]
a                  # => ["ant", "dog"]
a.delete_at(99, 1) # raises IndexError

Removes the element atindex, returning that element. RaisesIndexError ifindex is out of range.

a = ["ant", "bat", "cat", "dog"]
a.delete_at(2)  # => "cat"
a               # => ["ant", "bat", "dog"]
a.delete_at(99) # raises IndexError

Removes all elements within the givenrange. Returns an array of the removed elements with the original order ofself preserved. RaisesIndexError if the index is out of range.

a = ["ant", "bat", "cat", "dog"]
a.delete_at(1..2)    # => ["bat", "cat"]
a                    # => ["ant", "dog"]
a.delete_at(99..100) # raises IndexError

Removescount elements fromself starting atstart. If the size ofself is less thancount, removes values to the end of the array without error. Returns an array of the removed elements with the original order ofself preserved. RaisesIndexError ifstart is out of range.

a = ["ant", "bat", "cat", "dog"]
a.delete_at(1, 2)  # => ["bat", "cat"]
a                  # => ["ant", "dog"]
a.delete_at(99, 1) # raises IndexError

DEPRECATED Use#delete_at(start, count) instead

Returns a newArray that has exactlyself's elements. That is, it returns a shallow copy ofself.

Use#clone if you want a deep copy.

ary = [[1, 2], [3, 4]]
ary2 = ary.dup
ary[0][0] = 5
ary  # => [[5, 2], [3, 4]]
ary2 # => [[5, 2], [3, 4]]

ary2 << [7, 8]
ary  # => [[5, 2], [3, 4]]
ary2 # => [[5, 2], [3, 4], [7, 8]]

Yields each index ofself, starting atstart, to the given block and then assigns the block's value in that position. Returnsself.

Negative values ofstart count from the end of the array.

RaisesIndexError ifstart is outside the array range.

a = [1, 2, 3, 4]
a.fill(2) { |i| i * i } # => [1, 2, 4, 9]

DEPRECATED Use#fill(start.., &) instead

Yields each index ofself, starting atstart, to the given block and then assigns the block's value in that position. Returnsself.

Negative values ofstart count from the end of the array.

RaisesIndexError ifstart is outside the array range.

a = [1, 2, 3, 4]
a.fill(2) { |i| i * i } # => [1, 2, 4, 9]

DEPRECATED Use#fill(start.., &) instead

Yields each index ofself, starting atstart and justcount times, to the given block and then assigns the block's value in that position. Returnsself.

Negative values ofstart count from the end of the array.

RaisesIndexError ifstart is outside the array range.

Has no effect ifcount is zero or negative.

a = [1, 2, 3, 4, 5, 6]
a.fill(2, 2) { |i| i * i } # => [1, 2, 4, 9, 5, 6]

DEPRECATED UseIndexable::Mutable#fill(start, count, &) instead

Replacescount or less (if there aren't enough) elements starting at the givenstart index withvalue. Returnsself.

Negative values ofstart count from the end of the container.

RaisesIndexError if thestart index is out of range.

RaisesArgumentError ifcount is negative.

array = [1, 2, 3, 4, 5]
array.fill(9, 2, 2) # => [1, 2, 9, 9, 5]
array               # => [1, 2, 9, 9, 5]

Replaces every element inself, starting atstart, with the givenvalue. Returnsself.

Negative values ofstart count from the end of the array.

a = [1, 2, 3, 4, 5]
a.fill(9, 2) # => [1, 2, 9, 9, 9]

DEPRECATED Use#fill(value, start..) instead

Replaces every element inrange withvalue. Returnsself.

Negative values offrom count from the end of the array.

a = [1, 2, 3, 4, 5]
a.fill(9, 2..3) # => [1, 2, 9, 9, 5]

Replaces every element inself with the givenvalue. Returnsself.

array = [1, 2, 3, 4]
array.fill(2) # => [2, 2, 2, 2]
array         # => [2, 2, 2, 2]

Replaces every element inself, starting atstart, with the givenvalue. Returnsself.

Negative values ofstart count from the end of the array.

a = [1, 2, 3, 4, 5]
a.fill(9, 2) # => [1, 2, 9, 9, 9]

DEPRECATED Use#fill(value, start..) instead

Replacescount or less (if there aren't enough) elements starting at the givenstart index withvalue. Returnsself.

Negative values ofstart count from the end of the container.

RaisesIndexError if thestart index is out of range.

RaisesArgumentError ifcount is negative.

array = [1, 2, 3, 4, 5]
array.fill(9, 2, 2) # => [1, 2, 9, 9, 5]
array               # => [1, 2, 9, 9, 5]

DEPRECATED Use#fill(value, start, count) instead

Returns the firstn elements of the array.

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

Returns a newArray that is a one-dimensional flattening ofself (recursively).

That is, for every element that is an array or an iterator, extract its elements into the new array.

s = [1, 2, 3]          # => [1, 2, 3]
t = [4, 5, 6, [7, 8]]  # => [4, 5, 6, [7, 8]]
u = [9, [10, 11].each] # => [9, #<Indexable::ItemIterator>]
a = [s, t, u, 12, 13]  # => [[1, 2, 3], [4, 5, 6, [7, 8]], 9, #<Indexable::ItemIterator>, 12, 13]
a.flatten              # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

Returns the index of the first appearance ofobject inself starting from the givenoffset, ornil ifobject is not inself.

[1, 2, 3, 1, 2, 3].index(2, offset: 2) # => 4

Insertobject before the element atindex and shifting successive elements, if any. Returnsself.

Negative values ofindex count from the end of the array.

a = ["a", "b", "c"]
a.insert(0, "x")  # => ["x", "a", "b", "c"]
a.insert(2, "y")  # => ["x", "a", "y", "b", "c"]
a.insert(-1, "z") # => ["x", "a", "y", "b", "c", "z"]

Inserts all of the elements fromother before the element atindex.

This method shifts the element currently atindex (if any) and any subsequent elements to the right, increasing their indices. If the value ofindex is negative, counting starts from the end of the array. For example,-1 indicates insertion after the last element,-2 before the last element.

RaisesIndexError if theindex is out of bounds.

fruits = ["Apple"]
newFruits = ["Dragonfruit", "Elderberry"]

fruits.insert_all(1, newFruits)             # => ["Apple", "Dragonfruit", "Elderberry"]
fruits.insert_all(-3, ["Banana", "Cherry"]) # => ["Apple", "Banana", "Cherry", "Dragonfruit", "Elderberry"]

fruits.insert_all(6, ["invalid"])  # raises IndexError
fruits.insert_all(-7, ["indices"]) # raises IndexError

Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>

Returns the lastn elements of the array.

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

Optimized version ofEnumerable#map.

Optimized version ofEnumerable#map_with_index.

Accepts an optionaloffset parameter, which tells it to start counting from there.

gems = ["crystal", "pearl", "diamond"]
results = gems.map_with_index { |gem, i| "#{i}: #{gem}" }
results # => ["0: crystal", "1: pearl", "2: diamond"]

Removes the lastn values fromself, at indexsize - 1. This method returns an array of the removed values, with the original order preserved.

Ifn is greater than the size ofself, all values will be removed fromself without raising an error.

a = ["a", "b", "c"]
a.pop(2) # => ["b", "c"]
a        # => ["a"]

a = ["a", "b", "c"]
a.pop(4) # => ["a", "b", "c"]
a        # => []

See also:#truncate.

Removes the last value fromself, at indexsize - 1. This method returns the removed value. RaisesIndexError if array is of 0 size.

a = ["a", "b", "c"]
a.pop # => "c"
a     # => ["a", "b"]

See also:#truncate.

Removes the last value fromself. If the array is empty, the given block is called.

a = [1]
a.pop { "Testing" } # => 1
a.pop { "Testing" } # => "Testing"

See also:#truncate.

Like#pop, but returnsnil ifself is empty.

See also:#truncate.

Returns anArray of all ordered combinations of elements taken from each ofself andary asTuples. Traversal of elements starts fromary.

DEPRECATED UseIndexable#cartesian_product(*others : Indexable) instead

Yields each ordered combination of the elements taken from each ofself andenumerable as aTuple. Traversal of elements starts fromenumerable.

DEPRECATED UseIndexable#each_cartesian(*others : Indexable, &block) instead

Append. Pushes one value to the end ofself, given that the type of the value isT (which might be a single type or a union of types). This method returnsself, so several calls can be chained. See#pop for the opposite effect.

a = ["a", "b"]
a.push("c") # => ["a", "b", "c"]
a.push(1)   # Errors, because the array only accepts String.

a = ["a", "b"] of (Int32 | String)
a.push("c") # => ["a", "b", "c"]
a.push(1)   # => ["a", "b", "c", 1]

Append multiple values. The same as#push, but takes an arbitrary number of values to push intoself. Returnsself.

a = ["a"]
a.push("b", "c") # => ["a", "b", "c"]

Modifiesself, deleting the elements in the collection for which the passed block is truthy. Returnsself.

ary = [1, 6, 2, 4, 8]
ary.reject! { |x| x > 3 }
ary # => [1, 2]

See also:Array#reject.

Modifiesself, deleting the elements in the collection for which pattern === element.

ary = [1, 6, 2, 4, 8]
ary.reject!(3..7)
ary # => [1, 2, 8]

See also:Array#select!.

Replaces the contents ofself with the contents ofother. This resizes the Array to a greater capacity but does not free memory if the given array is smaller.

a1 = [1, 2, 3]
a1.replace([1])
a1                    # => [1]
a1.remaining_capacity # => 3
a2 = [1]
a2.replace([1, 2, 3])
a2 # => [1, 2, 3]

Returns an array with all the elements in the collection reversed.

a = [1, 2, 3]
a.reverse # => [3, 2, 1]

Returns an array with all the elements shifted to the leftn times.

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a.rotate    # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a.rotate(1) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a.rotate(3) # => [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]
a           # => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Shifts all elements ofself to the leftn times. Returnsself.

a1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a1.rotate!
a2.rotate!(1)
a3.rotate!(3)

a1 # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a2 # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a3 # => [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]

Modifiesself, keeping only the elements in the collection for which the passed block is truthy. Returnsself.

ary = [1, 6, 2, 4, 8]
ary.select! { |x| x > 3 }
ary # => [6, 4, 8]

See also:Array#select.

Modifiesself, keeping only the elements in the collection for which pattern === element.

ary = [1, 6, 2, 4, 8]
ary.select!(3..7)
ary # => [6, 4]

See also:Array#reject!.

Removes the firstn values ofself, starting at index 0. This method returns an array of the removed values.

Ifn is greater than the size ofself, all values will be removed fromself without raising an error.

a = ["a", "b", "c"]
a.shift # => "a"
a       # => ["b", "c"]

a = ["a", "b", "c"]
a.shift(4) # => ["a", "b", "c"]
a          # => []

See also:#truncate.

Removes the first value ofself, at index 0. This method returns the removed value. If the array is empty, it raisesIndexError.

a = ["a", "b", "c"]
a.shift # => "a"
a       # => ["b", "c"]

See also:#truncate.

Removes the first value ofself, at index 0, or otherwise invokes the given block. This method returns the removed value. If the array is empty, it invokes the given block and returns its value.

a = ["a"]
a.shift { "empty!" } # => "a"
a                    # => []
a.shift { "empty!" } # => "empty!"
a                    # => []

See also:#truncate.

Removes the first value ofself, at index 0. This method returns the removed value. If the array is empty, it returnsnil without raising any error.

a = ["a", "b"]
a.shift? # => "a"
a        # => ["b"]
a.shift? # => "b"
a        # => []
a.shift? # => nil
a        # => []

See also:#truncate.

Returns a new instance with all elements in the collection randomized.

SeeIndexable::Mutable#shuffle! for details.

Returns the number of elements in the array.

[:foo, :bar].size # => 2

Returns anArray with the firstcount elements removed from the original array.

Ifcount is bigger than the number of elements in the array, returns an empty array.

[1, 2, 3, 4, 5, 6].skip(3) # => [4, 5, 6]

Returns a new instance with all elements sorted based on the return value of their comparison methodT#<=> (seeComparable#<=>), using a stable sort algorithm.

a = [3, 1, 2]
a.sort # => [1, 2, 3]
a      # => [3, 1, 2]

SeeIndexable::Mutable#sort! for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two elements returnsnil.

Returns a new instance with all elements sorted based on the comparator in the given block, using a stable sort algorithm.

a = [3, 1, 2]
b = a.sort { |a, b| b <=> a }

b # => [3, 2, 1]
a # => [3, 1, 2]

SeeIndexable::Mutable#sort!(&block : T, T -> U) for details on the sorting mechanism.

RaisesArgumentError if for any two elements the block returnsnil.

Sorts all elements inself based on the return value of the comparison methodT#<=> (seeComparable#<=>), using a stable sort algorithm.

a = [3, 1, 2]
a.sort!
a # => [1, 2, 3]

This sort operation modifiesself. See#sort for a non-modifying option that allocates a new instance.

SeeSlice#sort! for details on the implementation.

RaisesArgumentError if the comparison between any two elements returnsnil.

Sorts all elements inself based on the comparator in the given block, using a stable sort algorithm.

The block must implement a comparison between two elementsa andb, wherea < b returns-1,a == b returns0, anda > b returns1. The comparison operator<=> can be used for this.

a = [3, 1, 2]
# This is a reverse sort (forward sort would be `a <=> b`)
a.sort! { |a, b| b <=> a }
a # => [3, 2, 1]

This sort operation modifiesself. See#sort(&block : T, T -> U) for a non-modifying option that allocates a new instance.

SeeSlice#sort!(&block : T, T -> U) for details on the implementation.

RaisesArgumentError if for any two elements the block returnsnil.

Returns a new instance with all elements sorted by the output value of the block. The output values are compared via the comparison methodT#<=> (seeComparable#<=>), using a stable sort algorithm.

a = %w(apple pear fig)
b = a.sort_by { |word| word.size }
b # => ["fig", "pear", "apple"]
a # => ["apple", "pear", "fig"]

If stability is expendable,#unstable_sort_by(&block : T -> _) provides a performance advantage over stable sort.

SeeIndexable::Mutable#sort_by!(&block : T -> _) for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two comparison values returnsnil.

Sorts all elements inself by the output value of the block. The output values are compared via the comparison method#<=> (seeComparable#<=>), using a stable sort algorithm.

a = %w(apple pear fig)
a.sort_by! { |word| word.size }
a # => ["fig", "pear", "apple"]

This sort operation modifiesself. See#sort_by(&block : T -> _) for a non-modifying option that allocates a new instance.

If stability is expendable,#unstable_sort_by!(&block : T -> _) provides a performance advantage over stable sort.

See#sort!(&block : T -> _) for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two comparison values returnsnil.

Returns anArray with all the elements in the collection.

(1..5).to_a # => [1, 2, 3, 4, 5]

Prints a nicely readable and concise string representation of this array toio.

The result resembles an array literal but it does not necessarily compile.

Each element is presented using its#inspect(io) result to avoid ambiguity.

Returns a pointer to the internal buffer whereself's elements are stored.

This method isunsafe because it returns a pointer, and the pointed might eventually not be that ofself if the array grows and its internal buffer is reallocated.

ary = [1, 2, 3]
ary.to_unsafe[0] # => 1

Assumes thatself is an array of arrays and transposes the rows and columns.

a = [[:a, :b], [:c, :d], [:e, :f]]
a.transpose # => [[:a, :c, :e], [:b, :d, :f]]
a           # => [[:a, :b], [:c, :d], [:e, :f]]

Removes all elements except thecount or less (if there aren't enough) elements starting at the givenstart index. Returnsself.

Negative values ofstart count from the end of the array.

RaisesIndexError if thestart index is out of range.

RaisesArgumentError ifcount is negative.

a = [0, 1, 4, 9, 16, 25]
a.truncate(2, 3) # => [4, 9, 16]
a                # => [4, 9, 16]

See also:#pop,#shift.

Removes all elements except those within the givenrange. Returnsself.

a = [0, 1, 4, 9, 16, 25]
a.truncate(1..-3) # => [1, 4, 9]
a                 # => [1, 4, 9]

Returns a newArray by removing duplicate values inself.

a = ["a", "a", "b", "b", "c"]
a.uniq # => ["a", "b", "c"]
a      # => [ "a", "a", "b", "b", "c" ]

Returns a newArray by removing duplicate values inself, using the block's value for comparison.

a = [{"student", "sam"}, {"student", "george"}, {"teacher", "matz"}]
a.uniq { |s| s[0] } # => [{"student", "sam"}, {"teacher", "matz"}]
a                   # => [{"student", "sam"}, {"student", "george"}, {"teacher", "matz"}]

Removes duplicate elements fromself. Returnsself.

a = ["a", "a", "b", "b", "c"]
a.uniq! # => ["a", "b", "c"]
a       # => ["a", "b", "c"]

Removes duplicate elements fromself, using the block's value for comparison. Returnsself.

a = [{"student", "sam"}, {"student", "george"}, {"teacher", "matz"}]
a.uniq! { |s| s[0] } # => [{"student", "sam"}, {"teacher", "matz"}]
a                    # => [{"student", "sam"}, {"teacher", "matz"}]

Returns the element at the givenindex, without doing any bounds check.

Indexable makes sure to invoke this method withindex in0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they access elements with#[](index) and#[]?(index).

This method should only be directly invoked if you are absolutely sure the index is in bounds, to avoid a bounds check for a small boost of performance.

Sets the element at the givenindex tovalue, without doing any bounds check.

Indexable::Mutable makes sure to invoke this method withindex in 0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they modify elements with#[]=(index, value).

This method should only be directly invoked if you are absolutely sure the index is in bounds, to avoid a bounds check for a small boost of performance.

Prepend. Addsobject to the beginning ofself, given that the type of the value isT (which might be a single type or a union of types). This method returnsself, so several calls can be chained. See#shift for the opposite effect.

a = ["a", "b"]
a.unshift("c") # => ["c", "a", "b"]
a.unshift(1)   # Errors, because the array only accepts String.

a = ["a", "b"] of (Int32 | String)
a.unshift("c") # => ["c", "a", "b"]
a.unshift(1)   # => [1, "c", "a", "b"]

Prepend multiple values. The same as#unshift, but takes an arbitrary number of values to add to the array. Returnsself.

Returns a new instance with all elements sorted based on the return value of their comparison methodT#<=> (seeComparable#<=>), using an unstable sort algorithm.

a = [3, 1, 2]
a.unstable_sort # => [1, 2, 3]
a               # => [3, 1, 2]

SeeIndexable::Mutable#unstable_sort! for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two elements returnsnil.

Returns a new instance with all elements sorted based on the comparator in the given block, using an unstable sort algorithm.

a = [3, 1, 2]
b = a.unstable_sort { |a, b| b <=> a }

b # => [3, 2, 1]
a # => [3, 1, 2]

SeeIndexable::Mutable#unstable_sort!(&block : T, T -> U) for details on the sorting mechanism.

RaisesArgumentError if for any two elements the block returnsnil.

Sorts all elements inself based on the return value of the comparison methodT#<=> (seeComparable#<=>), using an unstable sort algorithm.

a = [3, 1, 2]
a.unstable_sort!
a # => [1, 2, 3]

This sort operation modifiesself. See#unstable_sort for a non-modifying option that allocates a new instance.

SeeSlice#unstable_sort! for details on the implementation.

RaisesArgumentError if the comparison between any two elements returnsnil.

Sorts all elements inself based on the comparator in the given block, using an unstable sort algorithm.

The block must implement a comparison between two elementsa andb, wherea < b returns-1,a == b returns0, anda > b returns1. The comparison operator<=> can be used for this.

a = [3, 1, 2]
# This is a reverse sort (forward sort would be `a <=> b`)
a.unstable_sort! { |a, b| b <=> a }
a # => [3, 2, 1]

This sort operation modifiesself. See#unstable_sort(&block : T, T -> U) for a non-modifying option that allocates a new instance.

SeeSlice#unstable_sort!(&block : T, T -> U) for details on the implementation.

RaisesArgumentError if for any two elements the block returnsnil.

Returns a new instance with all elements sorted by the output value of the block. The output values are compared via the comparison method#<=> (seeComparable#<=>), using an unstable sort algorithm.

a = %w(apple pear fig)
b = a.unstable_sort_by { |word| word.size }
b # => ["fig", "pear", "apple"]
a # => ["apple", "pear", "fig"]

If stability is necessary, use#sort_by(&block : T -> _) instead.

SeeIndexable::Mutable#unstable_sort!(&block : T -> _) for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two comparison values returnsnil.

Sorts all elements inself by the output value of the block. The output values are compared via the comparison method#<=> (seeComparable#<=>), using an unstable sort algorithm.

a = %w(apple pear fig)
a.unstable_sort_by! { |word| word.size }
a # => ["fig", "pear", "apple"]

This sort operation modifiesself. See#unstable_sort_by(&block : T -> _) for a non-modifying option that allocates a new instance.

If stability is necessary, use#sort_by!(&block : T -> _) instead.

See#unstable_sort!(&block : T -> _) for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two comparison values returnsnil.