In Swift, operators are symbols or keywords used to perform specific operations on values, while range is a special type used to represent a sequence of values. Let's dive into each in more detail.

Operators

Swift provides a wide range of operators, including arithmetic, comparison, assignment, logical, and bitwise operators, among others. Here are some examples:

Arithmetic Operators

Arithmetic operators are used to perform mathematical calculations on numerical values.

Swift provides the standard arithmetic operators, including addition (+), subtraction (-), multiplication (*), and division (/). Swift also supports the modulo operator (%), which returns the remainder of a division operation.

// Initializing the variables a and b
let a = 5
let b = 2

// Addition (+)
let sum = a + b // 7

// Subtration (-)
let difference = a - b // 3

// Multiplication (*)
let product = a * b // 10

// Division (/)
let quotient = a / b // 2

// Modulo operator (%)
let remainder = a % b // 1

Comparison Operators

Comparison operators are used to compare two values and return a Boolean value indicating whether the comparison is true or false.

Swift provides a range of comparison operators, including greater than (>), less than (<), greater than or equal to (>=), less than or equal to (<=), equal to (==), and not equal to (!=). These operators are used to compare two values and return a Boolean result (true or false).

// Initializing the variables a and b
let x = 5
let y = 10

// Equal to (==)
let isEqual = x == y // false

// Not Equal to (!=)
let isNotEqual = x != y // true

// Greater than (>)
let isGreater = x > y // false

// Lesser than (<)
let isLess = x < y // true

// Greater than Equal to (>=)
let isGreaterOrEqual = x >= y // false

// Lesser than Equal to (<=)
let isLessOrEqual = x <= y // true

Assignment Operators

Assignment operators are used to assign a value to a variable or constant.

// Initializing the variable c
var c = 5

// c + 2 = 5 + 2 = 7
c += 2 // c is now 7

// c - 3 = 7 - 3 = 4
c -= 3 // c is now 4

// c * 2 = 4 * 2 = 8
c *= 2 // c is now 8

// c / 2 = 8 / 2 = 4
c /= 2 // c is now 4

// c % 3 = 4 % 3 = 1
c %= 3 // c is now 1

Logical Operators

Swift provides logical operators, including AND (&&), OR (||), and NOT (!). These operators are used to evaluate logical expressions and return a Boolean result.

// Initializing the variables p and q
let p = true
let q = false

// and (&&) = both must be same to get value as true
let and = p && q // false

// or (||) = any one must be true to get value as true
let or = p || q // true

// not (!) = oposities the value of the varible
let not = !p // false

Bitwise Operators

Swift provides bitwise operators, including AND (&), OR (|), XOR (^), NOT (~), and left shift (<<) and right shift (>>). These operators are used to manipulate the individual bits of an integer value.

// Initializing the variables d and e
let d = 0b1010
let e = 0b1100

// AND (&)
let and = d & e // 0b1000

// OR (|)
let or = d | e // 0b1110

// XOR (^)
let xor = d ^ e // 0b0110

// Left Shift (<<)
let shiftLeft = d << 1 // 0b10100

// Right Shift (>>)
let shiftRight = d >> 1 // 0b0101

Range

Range is a type in Swift that represents a range of values. It is used to iterate over a sequence of values or to access a subset of elements in an array, string, or other collection. Swift provides three types of ranges

Closed Range

A closed range operator includes both the start and end values. For example, 1...5 creates a range that includes the values 1, 2, 3, 4, and 5.

let closedRange = 1...5 
// includes 1, 2, 3, 4, 5

Half-Open Range

A half-open range operator includes the start value but excludes the end value. For example, 1..<5 creates a range that includes the values 1, 2, 3, and 4.

let halfOpenRange = 1..<5 
// includes 1, 2, 3, 4

// Iterate over a closed range
for i in 1...5 {
    print(i)
}

// Slice an array using a half-open range
let array = [1, 2, 3, 4, 5]
let slice = array[1..<4] // [2, 3, 4]

// Use a range in a switch statement
let value = 3
switch value {
case 1...5:

One-Sided Range

A one-sided range is used when you want to include all the elements from the start of a collection or up to a certain index. Swift provides two types of one-sided ranges:

Closed Range from the Start (..<b):

This range includes all the elements from the start of a collection up to, but not including, the specified index.

Closed Range through the End (a...):

This range includes all the elements from the specified index to the end of the collection.

Follow for more

Linkedin: https://www.linkedin.com/in/prahladinala/
Github: https://github.com/prahladinala/
Instagram: https://instagram.com/prahlad.inala/
Twitter: https://twitter.com/prahladinala
Figma Community: https://www.figma.com/@prahladinala
Dribbble: https://dribbble.com/prahladinala
Behance: https://www.behance.net/prahladinala
Personal Portfolio: https://prahladinala.in
ToolMate: https://toolmate.co.in

Thank you!