# 11 Great Uses for Swift Range Operators

When you work with a set of numbers, you want to keep things clean by writing the minimal code possible. Ranges are your super shortcut to working with multiple number values. With the simple >< symbols, you can do a lot of work without much space required.

## 11. Easy Number Array Creation

Creating an array full of numbers in a row is fast.

``````let numberArray = [Int](1...5)
//[1, 2, 3, 4, 5]``````

## 10. Access Multiple Array Elements

Let’s say you have an array and only want the first 3 elements.

``````let redThings = ["strawberry", "apple", "ruby", "lipstick", "heart", "lobster"]
print (redThings[0...2])
//["strawberry", "apple", "ruby"]

//Make it even shorter using a one-sided range dropping the 0.
print (redThings[...2])
//["strawberry", "apple", "ruby"]

//Start from an index and go to the end
print (redThings[3...])
//["lipstick", "heart", "lobster"]
``````

## 9. Replace Multiple Array Elements

``````var redThings = ["strawberry", "apple", "ruby", "lipstick", "heart", "lobster"]
redThings[1...2] = ["blood", "cherry"]
print (redThings)
//["strawberry", "blood", "cherry", "lipstick", "heart", "lobster"]``````

## 8. Iterate Through a Bunch of Numbers

``````for i in 1...5 {
print (i)
}

//1
//2
//3
//4
//5

//If you want to print them all out on the same line
for i in 1...5 {
print(i, terminator: "")
}
//"12345"``````

## 7. Use Half-Open Ranges to Aid Array Iteration

Half-open ranges don’t include the final value. This can prevent the annoying array.count – 1 that accounts for indexes starting from a value of 0.

``````let myRange = [Int](1..<5)
//[1, 2, 3, 4]

let hotThings = ["sun", "fire", "desert", "stove", "soup"]
for i in 0..<hotThings.count {
print (hotThings[i])
}
//sun
//fire
//desert
//stove
//soup``````

## 6. Value Check Your Ranges

Simply printing out a range doesn’t produce the result you might be expecting.

``````let myRange = 1...5
print (1...5)
//Prints 1...5
//Doesn't print [1, 2, 3, 4, 5]
//You need to create an array with this range to do this``````

But you can value check with a simple range.

``````let range = 1...5

print (range.contains(2))
//true

print (range.contains(6))
//false``````

You can even do this with one-sided ranges.

``````let range = ...5

print (range.contains(2))
//true
print (range.contains(-500))
//true
print (range.contains(6))
//false``````

There is also a special pattern matching operator to indicate whether a value is included in a range. It has the same function as contains.

``````let specialNumber = 9
print(0...10 ~= specialNumber) //true``````

## 5. Make Intervals

While not as simple as using just “…”, you can create intervals over a range by using stride.

``````let interval = 10
for n in stride(from: 0, to: 50, by: interval) {
print (n)

}

//0
//10
//20
//30
//40

//If you want it to print 50 as well, change "to" to "through"

for n in stride(from: 0, through: 50, by: interval) {
print (n)
}

//Also includes 50``````

## 4. Make Elegant Switch Statements

``````let testScore = 70
var comment = String()

switch testScore {
case 0..<60: comment = "What happened?"
case 60..<75: comment = "Needs work"
case 75..<85: comment = "Not bad"
case 85...100: comment = "You Rock"
default: break
}

print (comment)
//Needs work``````

## 3. Create Empty Ranges

Maybe you have 0 numbers in a range and want to check if it is empty.

``````//This range might look empty, but it includes itself, a range from 5 to 5.

let tinyRange = 5...5
print(tinyRange.contains(5)) //true
print (tinyRange.isEmpty) //false

//This is empty because there are no numbers between 2 and less than 2.
let emptyRange = 2..<2
print (emptyRange.contains(2)) //false
print (emptyRange.isEmpty) //true``````

## 2. Count Range Items and Get Their Bounds

``````let largeRange = 1...5000
print (largeRange.count) //5000
print (largeRange.lowerBound) //1
print (largeRange.upperBound) //5000``````

Creating a range is the same as creating an array of numbers. So a lot of what you can do with arrays can be done with ranges. For example, finding the minimum and maximum values.

``````let largeRange = 1...5000
print (largeRange.min()) //Optional(1)
print (largeRange.max()) //Optional(5000)``````

## 1. Clamp Ranges Together

You can’t just add ranges together.

``````let range = 0...10
let range2 = 11...20
let combinedRange = range + range2

//Error``````

But you can clamp one to another, which further restricts a range.

``````let range1 = 0...20
let range2 = 10...100
let clampedRange = range1.clamped(to: range2)
//10...20

print (clampedRange.contains(21)) //false``````

Clamping takes the overlapping values. You have 0-20 and 10-100. What overlaps is 10-20. If the ranges don’t overlap, the result is a range with just the first number of what is being clamped to.

``````let range1 = 0...10
let range2 = 20...100
let clampedRange = range1.clamped(to: range2)
//20...20

print (clampedRange.contains(21)) //false``````

Also, the range types (regular, open or closed) must be the same in order to clamp.

``````let range1 = 0..<20
let range2 = 10...100
let clampedRange = range1.clamped(to: range2)

//Error. This does not create a range of 10...<20``````