Swift Operators

An operator is a symbol that tells the compiler to perform a mathematical or logical operation.

Swift provides the following types of operators:

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

In this section, we will detail arithmetic operators, relational operators, logical operators, bitwise operators, assignment operators, and other operators.

Arithmetic Operators

The following table lists the arithmetic operators supported by Swift, with variable A set to 10 and variable B set to 20:

Note: The ++ and -- operators have been removed in Swift 3.

Example

Here is a simple example of arithmetic operations:

import Cocoa

var A = 10
var B = 20

print("A + B results in: \(A + B)")
print("A - B results in: \(A - B)")
print("A * B results in: \(A * B)")
print("B / A results in: \(B / A)")
A += 1   // Similar to A++
print("A += 1 results in A being \(A)")
B -= 1   // Similar to B--
print("B -= 1 results in B being \(B)")

The output of the above program is:

A + B results in: 30
A - B results in: -10
A * B results in: 200
B / A results in: 2
A += 1 results in A being 11
B -= 1 results in B being 19

Comparison Operators

The following table lists the comparison operators supported by Swift, with variable A set to 10 and variable B set to 20:

Example

Here is a simple example of comparison operations:

import Cocoa

var A = 10
var B = 20

print("A == B results in: \(A == B)")
print("A != B results in: \(A != B)")
print("A > B results in: \(A > B)")
print("A < B results in: \(A < B)")
print("A >= B results in: \(A >= B)")
print("A <= B results in: \(A <= B)")

The output of the above program is:

A == B results in: false
A != B results in: true
A > B results in: false
A < B results in: true
A >= B results in: false
A <= B results in: true

Logical Operators

The following table lists the logical operators supported by Swift, with variable A set to true and variable B set to false:

Here is a simple example of logical operations:

import Cocoa

var A = true
var B = false

print("A && B results in: \(A && B)")
print("A || B results in: \(A || B)")
print("!A results in: \(!A)")
print("!B results in: \(!B)")

The output of the above program is:

A && B results in: false
A || B results in: true
!A results in: false
!B results in: true

Bitwise Operators

Bitwise operators operate on binary representations. The operators ~, &, |, and ^ are for NOT, AND, OR, and XOR operations, respectively, as shown in the table below:

| p | q | p & q | p | q | p ^ q | This is an example of bitwise operations with specified variables A = 60 and B = 13, represented in binary:

A = 0011 1100
B = 0000 1101

Bitwise operations:

Simple example of bitwise operations:

import Cocoa

var A = 60  // Binary 0011 1100
var B = 13  // Binary 0000 1101

print("A&B result: \(A&B)")
print("A|B result: \(A|B)")
print("A^B result: \(A^B)")
print("~A result: \(~A)")

Output of the above program:

A&B result: 12
A|B result: 61
A^B result: 49
~A result: -61

Assignment Operations

Basic assignment operators in Swift:

Simple example of assignment operations:

import Cocoa

var A = 10
var B = 20
var C = 100

C = A + B
print("C result: \(C)")

C += A
print("C result: \(C)")

C -= A
print("C result: \(C)")

C *= A
print("C result: \(C)")

C /= A print("C result is: (C)")

// The following tests are commented out and can be uncommented to test each instance /* C %= A print("C result is: (C)")

C <<= A print("C result is: (C)")

C >>= A print("C result is: (C)")

C &= A print("C result is: (C)")

C ^= A print("C result is: (C)")

C |= A print("C result is: (C)") */

The above program execution results are:

C result is: 30
C result is: 40
C result is: 30
C result is: 300
C result is: 30

Range Operators

Swift provides two range operators.

Here is a simple example of range operations:

import Cocoa

print("Closed Range Operator:")
for index in 1...5 {
    print("\(index) * 5 = \(index * 5)")
}

print("Half-Open Range Operator:")
for index in 1..<5 {
    print("\(index) * 5 = \(index * 5)")
}

The above program execution results are:

Closed Range Operator:
1 * 5 = 5
2 * 5 = 10
3 * 5 = 15
4 * 5 = 20
5 * 5 = 25
Half-Open Range Operator:
1 * 5 = 5
2 * 5 = 10
3 * 5 = 15
4 * 5 = 20

Other Operators

Swift provides other types of operators, such as unary, binary, and ternary operators.

• Unary operators operate on a single operand (e.g., -a). Unary operators can be prefix operators that precede their operand (e.g., !b) or postfix operators that follow their operand (e.g., c!). Note: Java/C does not have syntax like c!; it is used in Swift for Optional type value extraction.

• Binary operators operate on two operands (e.g., 2 + 3). They are infix because they appear between two operands.

• Ternary operators operate on three operands. Like C, Swift has only one ternary operator, the ternary conditional operator (a ? b : c).

Here is a simple example of unary, binary, and ternary operations:

import Cocoa

var A = 1
var B = 2
var C = true
var D = false
print("-A value is: \(-A)")
print("A + B value is: \(A + B)")
print("Ternary operation: \(C ? A : B )")
print("Ternary operation: \(D ? A : B )")

The above program execution results are:

-A value is: -1
A + B value is: 3
Ternary operation: 1
Ternary operation: 2

Operator Precedence

In an expression, there may be multiple data objects connected by different operators with different data types. Since an expression can involve multiple operations, different order of operations can lead to different results or even erroneous calculations. Therefore, it is necessary to combine operations in a certain order to ensure the reasonableness and correctness of the results.

Precedence decreases from top to bottom, with the top having the highest precedence, and the comma operator having the lowest precedence.

Within the same precedence level, calculations are performed according to the binding order. Most operations are calculated from left to right, except for three levels that are calculated from right to left, which are unary operators, conditional operators, and assignment operators.

The basic precedence rules to remember are:

• Pointers are the most prioritized, followed by unary operations.

• Multiplication and division (modulo) are performed before addition and subtraction.

• Arithmetic operations are performed before shift operations, and then bitwise operations. Note: 1 << 3 + 2 & 7 is equivalent to (1 << (3 + 2)) & 7.

• Logical operations are calculated last.

Swift operator precedence (from highest to lowest):

Here is a simple example of operator precedence:

import Cocoa

var A = 0

A = 2 + 3 * 4 % 5
print("The value of A is: \(A)")

The output of the above program is:

The value of A is: 4

Example Analysis:

Based on operator precedence, the above program can be broken down into the following steps, equivalent to:

2 + ((3 * 4) % 5)

First step calculation: (3 * 4) = 12, so the expression becomes:

2 + (12 % 5)

Second step calculation: 12 % 5 = 2, so the expression becomes:

2 + 2

At this point, it is easy to see that the result is 4.