Array

Returns the nth element in the array or nil.

let arr = [1, 2, 3]
arr.at(0) #=> 1
arr.at(4) #=> nil

Choose a random element from the array.

let arr = [1, 2, 3]
arr.sample      #=> 2
arr.sample      #=> 1
arr.sample      #=> 1
arr.sample      #=> 2
arr.sample      #=> 3
arr             #=> [1, 2, 3]

If the array is empty Array#sample returns nil.

[].sample       #=> nil

Choose a random element or n random elements from the array. The elements are chosen by using random and unique indices into the array in order to ensure that an element doesn’t repeat itself unless the array already contained duplicate elements. If the array is empty the Array#sample returns nil and the Array#sample(n:) form returns an empty array.

let arr = [1, 2, 3]
arr.sample(1)       #=> [2]
arr.sample(2)       #=> [1, 2]
arr.sample(2)       #=> [1, 3]
arr.sample(2)       #=> [3, 1]
arr.sample(3)       #=> [3, 1, 2]
arr.sample(4)       #=> [2, 3, 1]
arr.sample(0)       #=> []
arr                 #=> [1, 2, 3]

If the array is empty Array#sample(n:) returns an empty array.

[].sample()         #=> []

Returns a new array with elements of self shuffled.

let arr = [1, 2, 3]
arr.shuffle         #=> [1, 2, 3]
arr.shuffle         #=> [3, 2, 1]
arr.shuffle         #=> [2, 1, 3]
arr.shuffle         #=> [1, 3, 2]
arr                 #=> [1, 3, 2]

Returns the tail of the array from the position.

["a", "b", "c", "d"].from(0)        #=> ["a", "b", "c", "d"]
["a", "b", "c", "d"].from(2)        #=> ["c", "d"]
["a", "b", "c", "d"].from(10)   #=> []
[].from(0)                      #=> []
["a", "b", "c", "d"].from(-2)   #=> ["c", "d"]
["a", "b", "c"].from(-10)       #=> []

Returns the beginning of the array up to the position.

["a", "b", "c", "d"].to(0)      #=> ["a"]
["a", "b", "c", "d"].to(2)      #=> ["a", "b", "c"]
["a", "b", "c", "d"].to(10)     #=> ["a", "b", "c", "d"]
[].to(0)                        #=> []
["a", "b", "c", "d"].to(-2)     #=> ["a", "b", "c"]
["a", "b", "c"].to(-10)         #=> []

Returns a copy of the Array without the specified elements.

let people = ["David", "Rafael", "Aaron", "Todd"]
people.without("David", "Aaron")        #=> ["Rafael", "Todd"]

Makes the current string empty

var arr = [1, 2, 3]
arr.clear()     #=> []
arr             #=> []

Remove last element in array or nil

var arr = [1, 2, 3]
arr.pop()       #=> 3
arr.pop()       #=> 2
arr.pop()       #=> 1
arr.pop()       #=> nil
arr             #=> []

Return the last several elements in array.

var arr = [1, 2, 3]
arr.pop()       #=> [3]
arr.pop(2)      #=> [1, 2]
arr             #=> []
arr.pop()       #=> []
arr.pop()       #=> []
arr             #=> []

Appends objects to the front of self.

var arr = ["a", "b", "c"]
arr.push("d")           #=> ["a", "b", "c", "d"]
arr.push("e", "f")      #=> ["a", "b", "c", "d", "e", "f"]
arr                     #=> ["a", "b", "c", "d", "e", "f"]

Remove first element in array or nil

var arr = ["a", "b", "c"]
arr.shift()     #=> "a"
arr             #=> ["b", "c"]
arr.shift()     #=> "b"
arr.shift()     #=> "c"
arr.shift()     #=> nil
arr             #=> []

Return the first several elements in array.

var arr = ["a", "b", "c"]
arr.shift()     #=> "a"
arr             #=> ["b", "c"]
arr.shift(2)     #=> ["b", "c"]
arr.shift()     #=> []
arr             #=> []

Prepends objects to the front of self, moving other elements upwards

var arr = [1]
arr.unshift(2)      #=> [2, 1]
arr.unshift(2, 3)   #=> [2, 3, 2, 1]
arr                 #=> [2, 3, 2, 1]

A mutating version of Sequence#select(closure:)

var arr1 = [1, 2, 3]
arr1.select { $0 > 2 }       #=> [3]
arr1                         #=> [3]

var arr2 = [1, 2, 3]
arr2.select { $0 <= 2 }      #=> [1, 2]
arr2                         #=> [1, 2]

var arr3 = [1, 2, 3]
arr3.select { _ in false }   #=> []
arr3                         #=> []

A mutating version of Sequence#reject(closure:)

var arr1 = [1, 2, 3]
arr1.reject { $0 > 2 }       #=> [1, 2]
arr1                         #=> [1, 2]

var arr2 = [1, 2, 3]
arr2.reject { $0 <= 2 }      #=> [3]
arr2                         #=> [3]

var arr3 = [1, 2, 3]
arr3.reject { _ in false }   #=> [1, 2, 3]
arr3                         #=> [1, 2, 3]

Deletes all items from self that are equal to obj. If all is false, delete the first object the the array.

var arr = [1, 2, 3, 4, 1, 2, 3, 5, 6]
arr.delete(1)                   #=> 1
arr                             #=> [2, 3, 4, 2, 3, 5, 6]
arr.delete(2)                   #=> 2
arr                             #=> [3, 4, 3, 5, 6]
arr.delete(3, all: false)       #=> 3
arr                             #=> [4, 3, 5, 6]
arr.delete(1000)                #=> nil
arr                             #=> [4, 3, 5, 6]

Convert an array of integer to int by base default is 10.

[1,2,3].to_i()      #=> 321
[1,2,3,4].to_i()    #=> 4321
[0,0,0,1].to_i(2)   #=> 8

Converts the array to a comma-separated sentence where the last element is joined by the connector word.

[].to_sentence                          #=> ""
["one"].to_sentence                     #=> "one"
["one", "two"].to_sentence              #=> "one and two"
["one", "two", "three"].to_sentence     #=> "one, two, and three"
["one", "two"].to_sentence(twoWordsConnector: "-")      #=> "one-two"
["one", "two", "three"].to_sentence(wordsConnector: " or ", lastWordConnector: " or at least ") 
    #=> "one or two or at least three"

Converts the array to a comma-separated sentence where the last element is joined by the connector word.

[].to_sentence                          #=> ""
["one"].to_sentence                     #=> "one"
["one", "two"].to_sentence              #=> "one and two"
["one", "two", "three"].to_sentence     #=> "one, two, and three"
["one", "two"].to_sentence(twoWordsConnector: "-")      #=> "one-two"
["one", "two", "three"].to_sentence(wordsConnector: " or ", lastWordConnector: " or at least ")
     #=> "one or two or at least three"

Splits or iterates over the array in groups of size number, padding any remaining slots with with unless it is nil.

arr.inGroup(of: 0)              #=> []
arr.inGroup(of: 3)              #=> [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
arr.inGroup(of: 4)              #=> [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]
arr.inGroup(of: 4, fill: 0)     #=> [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 0, 0]]

arr.inGroup(of: 4, fill: 0) { group in
    print(group)    #=> [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 0, 0]
}

Splits or iterates over the array in number of groups, padding any remaining slots with with unless it is false.

arr.inGroup(0)              #=> []
arr.inGroup(3)              #=> [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
arr.inGroup(4)              #=> [[1, 2, 3], [4, 5, 6], [7, 8], [9, 10]]
arr.inGroup(4, fill: 0)     #=> [[1, 2, 3], [4, 5, 6], [7, 8, 0], [9, 10, 0]]

arr.inGroup(4, fill: 0) { group in
    print(group)    #=> [1, 2, 3], [4, 5, 6], [7, 8, 0], [9, 10, 0]
}

Divides the array into one or more subarrays based on a delimiting value or the result of an block.

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
arr.split(3)    #=> [[1, 2], [4, 5, 6, 7, 8, 9, 10]]

arr.split { 
    $0 % 3 == 0 
}   #=> [[1, 2], [4, 5], [7, 8], [10]]

Divides the array into one or more subarrays based on a delimiting value or the result of an block.

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
arr.split(3)    #=> [[1, 2], [4, 5, 6, 7, 8, 9, 10]]

arr.split {
    $0 % 3 == 0
}   #=> [[1, 2], [4, 5], [7, 8], [10]]

Equals to self[1].

Equals to self[2].

Equals to self[3].

Equals to self[4].

Equals to self[5].

Equals to self[6].

Equals to self[7].

Equals to self[8].

Equals to self[9].

Equals to self[-2]

Equals to self[-3]

Returns true if self and other are the same object, or are both arrays with the same content

let arr1 = [1, 2, 3]
let arr2 = [3, 2, 1]
arr1.isEql(arr2)    #=> true

let arr3 = [3, 2, 3]
let arr4 = [3, 2, 1]
arr3.isEql(arr4)    #=> false

let arr5 = [1, 2, 3, 4, 5, 6]
let arr6 = [3, 2, 1]
arr5.isEql(arr6)    #=> false

Returns true if the given object is present in self (that is, if any element == object).

[1, 2, 3].isInclude(1)              #=> true
["a", "b", "c"].isInclude("b")      #=> true

Otherwise returns false.

[1, 2, 3].isInclude(100)            #=> false
["a", "b", "c"].isInclude("bbb")        #=> false

Returns a new array with unique element.

let arr = [1, 2, 3, 4, 1, 2]
arr.uniq        #=> [1, 2, 3, 4]
arr             #=> [1, 2, 3, 4, 1, 2]

When invoked with a closure, pass all combinations of length n of elements from the array and then returns the array itself. The implementation makes no guarantees about the order in which the combinations are yielded.

let arr = [1, 2, 3]
arr.combination(1) #=> [[1], [2], [3]]
arr.combination(2) #=> [[1, 2], [1, 3], [2, 3]]
arr.combination(3) #=> [[1, 2, 3]]
arr.combination(0) #=> []
arr.combination(5) #=> [[]]

When invoked with a closure, pass all repeated combinations of length n of elements from the array and then returns the array itself. The implementation makes no guarantees about the order in which the combinations are yielded.

let arr = [1, 2, 3]
arr.repeatedCombination(1) #=> [[1],[2],[3]]
arr.repeatedCombination(2) #=> [[1,1],[1,2],[1,3],[2,2],[2,3],[3,3]]
arr.repeatedCombination(3) #=> [[1,1,1],[1,1,2],[1,1,3],[1,2,2],[1,2,3],[1,3,3],[2,2,2],[2,2,3],[2,3,3],[3,3,3]]
arr.repeatedCombination(4) #=> [[1,1,1,1],[1,1,1,2],[1,1,1,3],[1,1,2,2],[1,1,2,3],[1,1,3,3],
    [1,2,2,2],[1,2,2,3],[1,2,3,3],[1,3,3,3], [2,2,2,2],[2,2,2,3],[2,2,3,3],[2,3,3,3],[3,3,3,3]]
arr.repeatedCombination(0) #=> []

Extracts the nested value specified by the sequence of idx objects by calling dig at each step, returning nil if any intermediate step is nil.

let a = [[1, 2, 3], [3, 4, 5]]
a.dig(0)                    #=> [1, 2, 3]
a.dig(1, 2)                 #=> 5
a.dig(1, 2, 3)              #=> nil
a.dig(10, 2, 3)             #=> nil

Extracts the nested value specified by the sequence of idx objects by calling dig at each step, returning nil if any intermediate step is nil.

let a = [[1, 2, 3], [3, 4, 5]]
a.dig(0)                    #=> [1, 2, 3]
a.dig(1, 2)                 #=> 5
a.dig(1, 2, 3)              #=> nil
a.dig(10, 2, 3)             #=> nil

Converts any arguments to arrays, then merges elements of self with corresponding elements from each argument.

let a = [ 4, 5, 6 ]
let b = [ 7, 8, 9 ]
[1, 2, 3].zip(a, b)   #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

This generates a nested n-element arrays, where n is the least count of all the ararys including the receiver.

[1, 2].zip(a, b)      #=> [[1, 4, 7]]
a.zip([1, 2], [8])    #=> [[4, 1, 8]]

Returns the tranpose of the current two-dimentional array.

let a = [[1, 2], [3, 4], [5, 6]]
a.transpose()   #=> [[1, 3, 5], [2, 4, 6]]

If the receiver’s elements have different length, Array#transpose() will return nil.

let b = [[1, 2], [3], [5, 6, 7]]
b.transpose()   #=> nil

Returns a new array by rotating self so that the element at count is the first element of the new array.

let a = [ "a", "b", "c", "d" ]
a.rotate         #=> ["b", "c", "d", "a"]
a                #=> ["a", "b", "c", "d"]

Returns a new array by rotating self so that the element at count is the first element of the new array.

let a = [ "a", "b", "c", "d" ]
a.rotate         #=> ["b", "c", "d", "a"]
a                #=> ["a", "b", "c", "d"]
a.rotate(2)      #=> ["c", "d", "a", "b"]

If count is negative then it rotates in the opposite direction, starting from the end of self where -1 is the last element.

a.rotate(-3)     #=> ["b", "c", "d", "a"]

Returns a new string by concatenating the elements of the sequence, adding the given separator between each element.

The following example shows how an array of strings can be joined to a single, comma-separated string:

let cast = ["Vivien", "Marlon", "Kim", "Karl"]
let list = cast.join(", ")
print(list)
// Prints "Vivien, Marlon, Kim, Karl"