Swift - Operators

---

---

Operators are special symbols that perform operations on operands. Operators can be used for various mathematical calculations and logical operations.

What is an Operator in Swift?

An operator is a symbol that tells the compiler to perform specific mathematical or logical operations. Or we can say that operators are special symbols that are used to perform specific operations between one or more operands.

For example, to add two numbers such as 34 and 21 we will use the + operator (34 + 21 = 55).

Type of Swift Operators

Swift supports the following types of operators −

• Arithmetic Operators
• Comparison Operators
• Logical Operators
• Bitwise Operators
• Assignment Operators
• Range Operators
• Misc Operators

Let's discuss each operator separately in detail.

Swift Arithmetic Operators

Arithmetic operators are used to perform mathematic operations like addition, division, multiplication, etc. on the given operands. They always work on two operands but the type of these operands should be the same. Swift supports the following arithmetic operators −

Example

Swift program to calculate the total cost of items purchased using arithmetic operators.

import Foundation

let item1Price = 120
let item2Price = 80
let quantity1 = 2
let quantity2 = 3

let totalCostItem1 = item1Price * quantity1
let totalCostItem2 = item2Price * quantity2
let totalAmount = totalCostItem1 + totalCostItem2

print("Total cost of item 1: \(totalCostItem1)")
print("Total cost of item 2: \(totalCostItem2)")
print("Total bill amount: \(totalAmount)")

Output

Total cost of item 1: 240
Total cost of item 2: 240
Total bill amount: 480

Swift Comparison Operators

Comparison operators are used to compare two operands and find the relationship between them. They return the result into a boolean(either true or false). Swift supports the following comparison operators −

Example

Swift program to compare the prices of two mobile phones using comparison operators.

import Foundation

let pricePhoneA = 45000
let pricePhoneB = 50000

print("Phone A is cheaper than Phone B: \(pricePhoneA < pricePhoneB)")
print("Phone A and Phone B have the same price: \(pricePhoneA == pricePhoneB)")
print("Phone B is more expensive than Phone A: \(pricePhoneB > pricePhoneA)")

Output

Phone A is cheaper than Phone B: true
Phone A and Phone B have the same price: false
Phone B is more expensive than Phone A: true

Swift Logical Operators

Logical operators are used to perform logical operations between the given expressions. It can also make decisions on multiple conditions. It generally works with Boolean values. Swift supports the following logical operators −

Example

Swift program to check if a user is eligible for a loan based on age and income using logical operators.

import Foundation

let age = 28
let monthlyIncome = 35000

let hasMinimumAge = age >= 21
let hasSufficientIncome = monthlyIncome >= 30000

if hasMinimumAge && hasSufficientIncome {
    print("Eligible for loan.")
} else {
    print("Not eligible for loan.")
}

// Using OR and NOT
let hasGoodCreditScore = false
if hasSufficientIncome || hasGoodCreditScore {
    print("Eligible based on income or credit score.")
}

print("Is NOT underage: \(!(age < 18))")

Output

Eligible for loan.
Eligible based on income or credit score.
Is NOT underage: true

Swift Bitwise Operators

Bitwise operators are used to manipulate individual bits of the integer. They are commonly used to perform bit-level operations. Swift supports the following bitwise operators −

Example

Swift program to demonstrate bitwise operations using two integer values representing access permissions.

import Foundation

let readPermission: UInt8 = 0b0001  // 1
let writePermission: UInt8 = 0b0010 // 2

let fullAccess = readPermission | writePermission
let hasRead = (fullAccess & readPermission) != 0
let hasWrite = (fullAccess & writePermission) != 0
let inverted = ~readPermission

print("Full access (read | write): \(fullAccess)")
print("Has read permission: \(hasRead)")
print("Has write permission: \(hasWrite)")
print("Inverted read permission: \(inverted)")

Output

Full access (read | write): 3
Has read permission: true
Has write permission: true
Inverted read permission: 254

Swift Assignment Operators

Assignment operators are used to assign and update the value of the given variable with the new value. Swift supports the following assignment operators −

Example

Swift program to calculate and update a savings account balance using assignment operators.

import Foundation

var savings = 10000

// Deposit amount
savings += 5000  // Add 5000
print("After deposit, savings: \(savings)")

// Withdrawal amount
savings -= 2000  // Subtract 2000
print("After withdrawal, savings: \(savings)")

// Apply 10% interest
savings *= 110
savings /= 100
print("After applying interest, savings: \(savings)")

Output

After deposit, savings: 15000
After withdrawal, savings: 13000
After applying interest, savings: 14300

Swift Misc Operators

Apart from the general operators Swift also supports some special operators (miscellaneous operators) and they are −

Example

Swift program demonstrating unary minus and plus to adjust temperatures, and the ternary operator to check if the temperature is comfortable.

import Foundation

var currentTemperature = 25
let temperatureChange = -5

// Unary minus
let newTemperature = currentTemperature + (-temperatureChange)  // increases by 5
print("New Temperature: \(newTemperature) Degree Celsius")

// Unary plus
let adjustedTemperature = +newTemperature //no effect
print("Adjusted Temperature: \(adjustedTemperature) Degree Celsius")

// Ternary operator to check comfort
let comfort = (adjustedTemperature >= 20 && adjustedTemperature <= 30) ? "Comfortable" : "Uncomfortable"
print("Temperature is: \(comfort)")

Output

New Temperature: 30 Degree Celsius
Adjusted Temperature: 30 Degree Celsius
Temperature is: Comfortable

Swift Advance Operators

Apart from the basic operators Swift also provides some advanced operators that are used to manipulate complex values and they are −

• Arithmetic Overflow Operators
• Identity Operators
• Range Operators

Let's discuss each operator separately in detail.

Swift Arithmetic Overflow Operators

Arithmetic overflow operators are used to perform arithmetic operations and handle overflow very well if occurs. Or we can say that arithmetic operators work with those integers whose value may exceed the maximum or minimum bound. Swift supports the following arithmetic overflow operators −

Swift Identity Operators

Identity operators are used to determine whether the given variable refers to the same instance or not. These operators work with objects and classes. They are referenced type operators. Swift supports the following type of identity operators −

Swift Range Operators

Range operators are used to define ranges. They are used in loops, collections and control flow statements. Swift supports the following range operators −

Swift Operator Precedence

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, and those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.