Array range for swift

Question

What could be the swift equivalent of following python code ?

array =[ "a", "b", "c"]
print(array[1:])

( Above statement prints every element from first index upto end of array.
Output ['b', 'c'])

Edit
Is there a way where this could be done with out using array.count ? Since the array.count is redundant if I say want every element from second position

Answer 1

With Swift 4, there is many ways to solve your problem. According to your needs, you may choose one of the six following patterns.

---

#1. Using Array dropFirst() method

let array = ["a", "b", "c"]
let arraySlice = array.dropFirst()
let newArray = Array(arraySlice)
print(newArray) // prints ["b", "c"]

---

#2. Using Array suffix(from:) method

let array = ["a", "b", "c"]
let arraySlice = array.suffix(from: 1)
let newArray = Array(arraySlice)
print(newArray) // prints ["b", "c"]

---

#3. Using Array suffix(_:) method

let array = ["a", "b", "c"]
let arraySlice = array.suffix(array.endIndex.advanced(by: -1))
// let arraySlice = array.suffix(array.count - 1) // also works
let newArray = Array(arraySlice)
print(newArray) // prints ["b", "c"]

---

#4. Using Array subscript(_:​) and CountableRange

let array = ["a", "b", "c"]
let range = array.startIndex.advanced(by: 1) ..< array.endIndex
// let range = 1 ..< array.count // also works
let arraySlice = array[range]
let newArray = Array(arraySlice)
print(newArray) // prints ["b", "c"]

---

#5. Using Array subscript(_:​) and CountableClosedRange

let array = ["a", "b", "c"]
let range = 1 ... array.count - 1 // also works
let arraySlice = array[range]
let newArray = Array(arraySlice)
print(newArray) // prints ["b", "c"]

---

#6. Using Array subscript(_:​) and CountablePartialRangeFrom

let array = ["a", "b", "c"]
let range = 1...
let arraySlice = array[range]
let newArray = Array(arraySlice)
print(newArray) // prints ["b", "c"]

Answer 2

You can get sub range of an swift array like that:

let array =[ "a", "b", "c"]
//be sure that your array.count has more than 1 item (in this case)
let subArray1 = array[1..<array.count]
print(subArray1)
//or
let subArray2 = array[1...array.count-1]
print(subArray2)

This is 2 notes from Swift Programming Language book

“Use .. to make a range that omits its upper value, and use ... to make a range that includes both values.”

And

“If you try to use subscript syntax to retrieve or set a value for an index that is outside of an array’s existing bounds, you will trigger a runtime error. However, you can check that an index is valid before using it, by comparing it to the array’s count property. Except when count is 0 (meaning the array is empty), the largest valid index in an array will always be count - 1, because arrays are indexed from zero.”

Answer 3

You can achieve what you're looking for in the following way:

1. Create a custom struct to store a start and end index. If startIndex or endIndex is nil this will be taken to mean the range extends infinitely in that direction.

struct UnboundedRange<Index> {
    var startIndex, endIndex: Index?

    // Providing these initialisers prevents both `startIndex` and `endIndex` being `nil`.
    init(start: Index) {
        self.startIndex = start
    }

    init(end: Index) {
        self.endIndex = end
    }
}

2. Define operators to create an BoundedRange as having to use the initialisers will lead to some quite unsightly code, in my option.

postfix operator ... {}
prefix  operator ... {}

postfix func ... <Index> (startIndex: Index) -> UnboundedRange<Index> {
    return UnboundedRange(start: startIndex)
}

prefix func ... <Index> (endIndex: Index) -> UnboundedRange<Index> {
    return UnboundedRange(end: endIndex)
}

Some example usage:

1...  // An UnboundedRange<Int> that extends from 1 to infinity.
...10 // An UnboundedRange<Int> that extends from minus infinity to 10.

3. Extend the CollectionType so it can handle UnboundedRanges.

extension CollectionType {
    subscript(subrange: UnboundedRange<Index>) -> SubSequence {
        let start = subrange.startIndex ?? self.startIndex
        let end = subrange.endIndex?.advancedBy(1) ?? self.endIndex
        return self[start..<end]
    }
}

4. To use this in your given example:

let array = ["a", "b", "c"]

array[1...] // Returns ["b", "c"]
array[...1] // Returns ["a", "b"]