Applying Operators and Expressions in Swift

Course: iOS App Development Training

Topic: Applying Operators and Expressions in Swift

Course Link: JustAcademy iOS App Development Training

Demo Link: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction to Operators and Expressions

Operators and expressions are fundamental concepts in Swift programming. Operators perform actions on values, while expressions combine values, variables, constants, function calls, and operators to produce a result or perform an operation.

In iOS development, operators are used for calculations, validating user input, comparing values, checking permissions and conditions, calculating prices, updating counters, and controlling application behavior.

For example, a shopping application can use arithmetic operators to calculate a total price, comparison operators to check whether a product is in stock, and logical operators to determine whether a user can proceed to checkout.

2. Learning Objectives

• Understand operators, operands, and expressions in Swift.
• Use arithmetic and assignment operators.
• Compare values using comparison operators.
• Combine conditions using logical operators.
• Apply compound assignment and unary operators.
• Understand operator precedence and associativity.
• Use ranges, ternary expressions, and nil-coalescing operators.
• Work with optional values and type-casting operators.
• Apply Swift operators in practical iOS development examples.

3. What Is an Operator?

An operator is a symbol or keyword that performs an operation on one or more values. The values used by an operator are called operands.

Example

let a = 20
let b = 10
let result = a + b

print(result) // 30

In this example:

• + is the arithmetic operator.
• a and b are operands.
• a + b is an expression.
• result stores the calculated value.

4. Types of Operators in Swift

5. Arithmetic Operators

Arithmetic operators perform mathematical calculations on numeric values. They are useful for prices, scores, counters, measurements, and other calculations in iOS applications.

5.1 Addition

The addition operator combines numeric values. It can also concatenate two strings.

let price = 250
let deliveryCharge = 40
let total = price + deliveryCharge

print(total) // 290

let firstName = "Swift"
let secondWord = " Programming"
print(firstName + secondWord)
// Swift Programming

5.2 Subtraction

The subtraction operator calculates the difference between values.

let accountBalance = 1500
let purchaseAmount = 450
let remainingBalance = accountBalance - purchaseAmount

print(remainingBalance) // 1050

5.3 Multiplication

The multiplication operator is useful when calculating totals for multiple items.

let itemPrice = 120
let quantity = 4
let totalPrice = itemPrice * quantity

print(totalPrice) // 480

5.4 Division

The division operator divides one numeric value by another. When both operands are integers, the result is an integer and any fractional part is discarded.

let integerResult = 7 / 2
print(integerResult) // 3

let decimalResult = 7.0 / 2.0
print(decimalResult) // 3.5

To obtain a decimal result, use compatible floating-point types such as Double.

5.5 Remainder

The remainder operator % returns the remainder after division. It can help determine whether a number is even or odd.

let number = 17
let remainder = number % 2

print(remainder) // 1

if number % 2 == 0 {
    print("Even number")
} else {
    print("Odd number")
}

Swift also provides a separate quotient-and-remainder operation called quotientAndRemainder(dividingBy:) for integer types when both values are needed.

6. Assignment Operator

The assignment operator = assigns a value to a variable or initializes a constant. In Swift, assignment itself does not return a value.

var score = 50
score = 80

print(score) // 80

let appName = "My iOS App"
print(appName)

Use var when a value needs to change and let when it should remain constant.

Important: The assignment operator = is different from the equality operator ==. Swift does not allow assignment to be used accidentally as a Boolean condition.

7. Compound Assignment Operators

Compound assignment operators combine an operation with an assignment. They provide a concise way to update mutable variables.

Example

var cartTotal = 500

cartTotal += 100
print(cartTotal) // 600

cartTotal -= 50
print(cartTotal) // 550

cartTotal *= 2
print(cartTotal) // 1100

cartTotal /= 2
print(cartTotal) // 550

These operators are useful for counters, running totals, and other mutable numeric values. The variable's type must support the selected operation.

8. Comparison Operators

Comparison operators compare two values and return a Boolean result: true or false. They are commonly used in conditional statements and validation logic.

Example: Checking Eligibility

let userAge = 22

if userAge >= 18 {
    print("Eligible")
} else {
    print("Not eligible")
}

Comparison operators work with compatible types. For custom structures and classes, equality or ordering may require appropriate protocol conformance or custom implementations.

9. Logical Operators

Logical operators combine or reverse Boolean conditions. They help developers create more complex validation rules.

9.1 Logical AND

let isLoggedIn = true
let hasPermission = true

if isLoggedIn && hasPermission {
    print("Access granted")
} else {
    print("Access denied")
}

The condition succeeds only when both values are true.

9.2 Logical OR

let hasEmail = false
let hasPhoneNumber = true

if hasEmail || hasPhoneNumber {
    print("Contact information available")
}

The condition succeeds when either value is true. Swift's && and || operators use short-circuit evaluation, meaning the right-hand expression may not be evaluated when the left-hand expression already determines the result.

9.3 Logical NOT

let isLoading = false

if !isLoading {
    print("Ready for input")
}

The ! operator reverses the Boolean value. Here, !isLoading evaluates to true.

10. Unary Operators

A unary operator acts on a single operand. It can appear before or after its operand depending on the operator.

Unary Minus

let temperature = 25
let negativeTemperature = -temperature

print(negativeTemperature) // -25

Unary Plus

let value = 15
let positiveValue = +value

print(positiveValue) // 15

Unary plus generally leaves the numeric value unchanged. Unary operators are useful for expressing sign changes and Boolean negation.

11. Operator Precedence and Associativity

When an expression contains multiple operators, Swift uses precedence and associativity rules to determine how the expression is grouped and evaluated.

Example Without Parentheses

let result = 2 + 3 * 4
print(result) // 14

Multiplication has higher precedence than addition, so the expression is evaluated as 2 + (3 * 4).

Example With Parentheses

let result = (2 + 3) * 4
print(result) // 20

Parentheses make the intended grouping explicit. They are especially helpful when an expression contains multiple comparisons, logical operators, or arithmetic operations.

Best Practices

• Use parentheses when the intended evaluation order may not be obvious.
• Avoid unnecessarily complicated expressions.
• Break long calculations into named intermediate variables.
• Do not rely on memory alone for complex precedence rules; consult Swift's official language documentation.

12. Ternary Conditional Operator

The ternary conditional operator is a concise alternative to a simple if-else expression. It selects one of two values based on a Boolean condition.

Syntax:

condition ? valueIfTrue : valueIfFalse

Example

let marks = 75
let result = marks >= 40 ? "Pass" : "Fail"

print(result) // Pass

If the condition is true, Swift evaluates the expression after ?. Otherwise, it evaluates the expression after :.

Example: Login Status

let isLoggedIn = true
let message = isLoggedIn ? "Welcome Back" : "Please Log In"

print(message) // Welcome Back

Use the ternary operator for short, clear choices. For complex branching logic, prefer a regular if-else statement or expression.

13. Range Operators

Range operators represent intervals of values. They are often used in loops, collection slicing, and validation.

13.1 Closed Range Operator (...)

The closed range includes both its starting and ending values.

for number in 1...5 {
    print(number)
}

This loop prints the numbers 1, 2, 3, 4, and 5.

13.2 Half-Open Range Operator (..<)

The half-open range includes the starting value but excludes the ending value.

for number in 1..<5 {
    print(number)
}

This loop prints 1, 2, 3, and 4.

13.3 One-Sided Ranges

One-sided ranges specify only a lower or upper boundary. They are useful when working with collections and slicing.

let scores = [10, 20, 30, 40, 50]
let firstThree = scores[..<3]

print(Array(firstThree)) // [10, 20, 30]

Collection ranges must respect the valid index boundaries of the collection.

14. Nil-Coalescing Operator (??)

The nil-coalescing operator provides a fallback value when an optional contains nil. It helps avoid repetitive optional-unwrapping code when a default value is appropriate.

Syntax

optionalValue ?? defaultValue

Example

let userName: String? = nil
let displayName = userName ?? "Guest"

print(displayName) // Guest

If userName contains a string, that string is used. If it is nil, Swift uses "Guest".

iOS Example

let savedTheme: String? = nil
let currentTheme = savedTheme ?? "Light"

print("Selected theme: \(currentTheme)")

This pattern is useful for optional profile details, display preferences, and other values that have a sensible default. Do not use a fallback value when missing data should instead trigger validation or an error.

15. Optional Values and the Forced-Unwrap Operator

An optional represents a value that may be present or absent. Swift uses nil to represent the absence of a value. The postfix exclamation mark ! can force-unwrap an optional, but it causes a runtime error if the optional is nil.

Example of Safe Optional Binding

let ageText = "25"

if let age = Int(ageText) {
    print("Age: \(age)")
} else {
    print("Invalid age")
}

Using if let is a safe way to unwrap an optional when conversion may fail.

Forced Unwrapping Example

let ageText = "25"
let age = Int(ageText)!

print(age) // 25

This example works because conversion succeeds. If the text were not a valid integer, the forced unwrap would crash the program. Prefer optional binding or a suitable fallback when a value is not guaranteed to exist.

16. Type-Casting Operators

Type-casting operators help check or convert values between types, especially when working with class hierarchies or values stored using a general type.

Example: Checking a Type

let value: Any = "Hello Swift"

if value is String {
    print("The value is a String")
}

Example: Conditional Casting

let value: Any = "Swift"
let text = value as? String

print(text ?? "Not a string")

Conditional casting is generally safer than forced casting because it allows the program to handle a failed conversion without crashing.

17. Bitwise Operators

Bitwise operators manipulate individual bits in integer values. They are more common in low-level programming, binary protocols, flags, and specialized performance or hardware-related tasks.

Example

let a: UInt8 = 0b0000_1100
let b: UInt8 = 0b0000_1010

print(a & b) // 8
print(a | b) // 14
print(a ^ b) // 6

Binary literals begin with 0b. Use bitwise operators only when bit-level behavior is needed, and be careful with integer widths, signedness, and shift boundaries.

18. Overflow Operators

Swift's standard arithmetic operators do not silently wrap around when fixed-width integer arithmetic overflows. An overflow normally triggers a runtime trap. Swift also provides explicit overflow operators for cases where wrapping behavior is intentionally required.

Example

let maximum = UInt8.max
let wrappedValue = maximum &+ 1

print(wrappedValue) // 0

Overflow operators are specialized tools, not replacements for ordinary arithmetic. Use them only when wrapping behavior is part of the intended design.

19. Expressions in Swift

An expression is a combination of values, operators, variables, function calls, or other language constructs that evaluates to a value, performs a side effect, or both.

Examples of Expressions

let total = 100 + 50
let isEligible = total >= 120
let message = isEligible ? "Approved" : "Rejected"

Here, 100 + 50 is an arithmetic expression, total >= 120 is a comparison expression, and the ternary expression selects a message based on the Boolean result.

Expressions and Statements

An expression computes a value or performs an operation. A statement organizes program execution, such as an if statement or a loop. Some Swift constructs can act as expressions in supported contexts, so the distinction depends on how the construct is used.

20. Practical Example: Shopping Cart Calculator

This example combines arithmetic, comparison, logical, and ternary operators to calculate an order total and determine whether a discount applies.

let itemPrice = 500.0
let quantity = 3
let discountEligible = true
let minimumOrder = 1000.0

let subtotal = itemPrice * Double(quantity)
let discount = discountEligible && subtotal >= minimumOrder
    ? subtotal * 0.10
    : 0.0

let finalTotal = subtotal - discount

print("Subtotal: \(subtotal)")
print("Discount: \(discount)")
print("Final Total: \(finalTotal)")

Explanation

• * calculates the subtotal.
• Double(quantity) converts the integer quantity into a floating-point value for compatible arithmetic.
• && checks whether the customer is eligible and the subtotal meets the minimum.
• >= compares the subtotal with the minimum order value.
• ?: selects the discount amount.
• - subtracts the discount from the subtotal.

Expected output:

Subtotal: 1500.0
Discount: 150.0
Final Total: 1350.0

21. Practical Example: Form Validation

Logical and comparison operators are frequently used to validate information entered into an iOS application.

let age = 24
let hasAcceptedTerms = true
let hasValidEmail = true

let canRegister = age >= 18
    && hasAcceptedTerms
    && hasValidEmail

if canRegister {
    print("Registration successful")
} else {
    print("Please check your information")
}

The registration condition succeeds only when the age requirement, terms acceptance, and email validation are all satisfied. In a real application, email validation should use a suitable validation strategy rather than assuming a Boolean value alone guarantees correctness.

22. Common Mistakes When Using Operators

23. Best Practices

• Choose descriptive variable names for calculations and conditions.
• Prefer constants declared with let when values do not need to change.
• Use parentheses to make complex expressions easier to read.
• Keep logical conditions simple and easy to test.
• Validate values before performing potentially unsafe operations.
• Avoid forced optional unwrapping unless the value is guaranteed to exist.
• Use the nil-coalescing operator only when a default value is appropriate.
• Convert numeric types explicitly when performing mixed-type calculations.
• Use integer overflow operators only when wrapping behavior is intentional.
• Test edge cases such as zero, negative numbers, empty values, and missing optionals.

24. Practical Exercises

Exercise 1: Basic Calculator

Create a Swift program that accepts two numeric values and calculates their sum, difference, product, and quotient. Handle a zero divisor before division.

Exercise 2: Even or Odd

Use the remainder operator to determine whether a given integer is even or odd.

Exercise 3: Age Eligibility

Use comparison and logical operators to check whether a user meets an age requirement and has accepted the required terms.

Exercise 4: Discount Calculator

Calculate the total price of multiple products and apply a discount when the purchase meets a specified condition.

Exercise 5: Range Practice

Write two loops: one using a closed range and another using a half-open range. Compare their outputs.

Exercise 6: Optional Default

Create an optional username and use the nil-coalescing operator to display a default username when the optional is nil.

Exercise 7: Ternary Operator

Use the ternary operator to display whether a student's marks meet the passing requirement.

25. Interview Questions and Answers

Q1. What is an operator in Swift?

Answer: An operator is a symbol or keyword that performs an operation on one or more operands.

Q2. What is an expression?

Answer: An expression is a combination of values, variables, operators, or other constructs that evaluates to a value, performs a side effect, or both.

Q3. What is the difference between = and ==?

Answer: The = operator assigns a value, whereas == compares two values for equality.

Q4. What is the difference between && and ||?

Answer: Logical AND requires both conditions to be true. Logical OR requires at least one condition to be true.

Q5. What is the ternary conditional operator?

Answer: It selects one of two expressions according to a Boolean condition using the syntax condition ? valueIfTrue : valueIfFalse.

Q6. What is the difference between ... and ..<?

Answer: The closed range operator includes both boundaries, while the half-open range operator excludes its upper boundary.

Q7. What does the nil-coalescing operator do?

Answer: It returns the value of an optional when present or evaluates a fallback expression when the optional is nil.

Q8. What is operator precedence?

Answer: Operator precedence determines how operators are grouped when an expression contains multiple operations.

Q9. Why should forced unwrapping be used carefully?

Answer: If the optional is nil, forced unwrapping causes a runtime trap.

Q10. What are overflow operators?

Answer: Overflow operators such as &+, &-, and &* perform integer arithmetic with wrapping behavior when overflow occurs.

26. Quick Revision Checklist

• Understand operators, operands, and expressions.
• Practice arithmetic and assignment operators.
• Use comparison operators to produce Boolean results.
• Combine conditions using logical operators.
• Understand unary and compound assignment operators.
• Apply operator precedence and parentheses correctly.
• Use ternary expressions for simple conditional values.
• Use closed and half-open ranges appropriately.
• Handle optional values with nil-coalescing and optional binding.
• Understand type casting and overflow behavior.
• Apply operators in calculators, form validation, and shopping-cart logic.

27. Conclusion

Operators and expressions are essential building blocks of Swift programming. They allow developers to perform calculations, compare values, combine conditions, handle optional values, and write concise application logic. Understanding how operators behave, how expressions are evaluated, and how types affect operations helps developers create safer and more maintainable iOS applications.

For further learning, read Apple's official Swift documentation on The Swift Programming Language, Basic Operators, and Expressions.

Course Resources

Explore the JustAcademy iOS App Development Training Course to continue learning Swift and native iOS development.

Interested in the training program? Register for a Course Demo.

Visit the JustAcademy Official Website for additional learning resources.