Swift: Range Operators - Closed Range Operator, Half-Open Range Operator, One-Sided Ranges

Range operators

Range operators in Swift provide a concise way to express a sequence of values. They are commonly used to iterate through a range of numbers, characters, or other elements. Swift offers two primary range operators:

Closed Range Operator (...): The closed range operator, denoted by three dots (...), creates a range that includes both the starting and ending values. For instance, the range 1...5 encompasses the numbers 1, 2, 3, 4, and 5.

Half-Open Range Operator (..<): The half-open range operator, denoted by two dots followed by a less-than sign (..<), creates a range that includes the starting value but excludes the ending value. For example, the range 1..<5 includes the numbers 1, 2, 3, and 4, but not 5.

Range operators can be used in various contexts, including:

For-in loops: Range operators are frequently employed in for-in loops to iterate through a sequence of values. For instance, to print all numbers from 1 to 5, you can use a for-in loop with a closed range:

for number in 1...5 { 

 print(number) 

}

Array slicing: Range operators can be used to extract a subsequence of elements from an array. For example, to extract the first three elements of an array, you can use a half-open range:

let numbers = [1, 2, 3, 4, 5] 

let firstThree = numbers[0..<3] 

print(firstThree) // Prints [1, 2, 3]

Switch statements: Range operators can be used in switch statements to match against a range of values. For instance, to perform different actions based on a number falling within specific ranges, you can use a switch statement with range expressions:

let score = 85 

switch score { 

case 0...59: 

 print("Fail") 

case 60...79: 

 print("Pass") 

case 80...100: 

 print("Excellent") 

default: 

 print("Invalid score") 

}

Range operators provide a powerful tool for working with sequences of values in Swift. They enhance code readability and conciseness, making it easier to express and manipulate ranges of numbers, characters, or other elements.

One-Sided Ranges

One-sided ranges in Swift are a powerful feature that allows you to express ranges that only have one specified end point. This can be useful in a variety of situations, such as when you need to iterate over a collection from the beginning to a certain index, or when you need to select a subset of a collection from a certain index to the end.

To create a one-sided range, you can use the following syntax:

<start value>..<end value> // Half-open range 

<start value>... // Closed range

The start value is the only required operand. The end value is optional, and if it is omitted, the range will extend to the end of the collection.

Here are some examples of one-sided ranges:

// Iterate over the first three elements of an array 

let numbers = [1, 2, 3, 4, 5] 

for number in numbers[..<3] { 

 print(number) 

} 




// Select the last two elements of an array 

let lastTwo = numbers[3...] 




// Iterate over a string from the beginning to the first space 

let greeting = "Hello, world!" 

for character in greeting[..<greeting.firstIndex(of: " ")] { 

 print(character) 

}

One-sided ranges can also be used in conjunction with other operators, such as the + and - operators. This allows you to create complex range expressions that can be used to select specific subsets of a collection.

Here are some examples of complex range expressions:

// Select the elements from the middle to the end of an array 

let middleToEnd = numbers[(numbers.count / 2)...] 




// Select the elements from the beginning to the second-to-last element of an array 

let beginningToSecondToLast = numbers[..<(numbers.count - 1)] 




// Select the elements from the third element to the fifth element of an array 

let thirdToFifth = numbers[2...4]

One-sided ranges can be particularly useful when working with collections that have an unknown number of elements. For example, if you have an array that contains the results of a database query, you may not know how many elements the array will contain. In this case, you can use a one-sided range to iterate over the array from the beginning to the end, without having to worry about specifying the ending index.

One-sided ranges can also be used to implement lazy evaluation. For example, the following code snippet uses a one-sided range to create a sequence that contains all of the even numbers from 1 to infinity:

let evenNumbers = 1..<()




for number in evenNumbers { 

 print(number) 

}

The evenNumbers sequence is lazy, which means that the next element in the sequence is only calculated when it is needed. This allows you to iterate over the sequence without having to pre-allocate memory for all of the elements in the sequence.

One-sided ranges are a powerful tool that can be used to make your Swift code more concise and readable. By understanding how to use one-sided ranges, you can write more efficient and effective code.

Here are some tips for using one-sided ranges effectively:

• Use one-sided ranges to simplify your code by avoiding the need to explicitly specify the starting or ending point of a range.
• Use one-sided ranges to create complex range expressions that can be used to select specific subsets of a collection.
• Avoid using nested one-sided ranges, as this can make your code difficult to read and understand.

Overall, one-sided ranges are a valuable addition to the Swift language. By using one-sided ranges effectively, you can write more concise, readable, and efficient code.

Previous: Swift: Operators: Comparison Operators, Ternary Conditional Operator, Nil-Coalescing Operator

Next: Swift: Logical Operators, Combining Logical Operators