# Swift Programming

## Swift Operators

In this article, you’ll learn everything about different types of operators in Swift programming language, their syntax and how to use them with examples.

Operators are special symbols that perform operations on variables and values. For example,

``print(5 + 6)   // 11``

Here, `+` is an operator that adds two numbers: 5 and 6.

## Types of Operators

Here’s a list of different types of Swift operators that you will learn in this tutorial.

1. Arithmetic operators
2. Assignment Operators
3. Comparison Operators
4. Logical Operators
5. Bitwise Operators
6. Other Operators

## 1. Swift Arithmetic Operators

Arithmetic operators are used to perform mathematical operations like addition, subtraction, multiplication, etc. For example,

``var sub = 10 - 5 // 5``

Here, `-` is an arithmetic operator that subtracts two values or variables.

Operator Operation Example
`+` Addition `5 + 2 = 7`
`-` Subtraction `4 - 2 = 2`
`*` Multiplication `2 * 3 = 6`
`/` Division `4 / 2 = 2`
`%` Modulo `5 % 2 = 1`

### Example 1: Arithmetic Operators in Swift

``````var a = 7
var b = 2

print (a + b)

// subtraction
print (a - b)

// multiplication
print (a * b)``````

Output

```9
5
14```

In the above example, we have used

• `+` to add `a` and `b`
• `-` to subtract `b` from `a`
• `*` to multiply `a` and `b`

/ Division Operator

The `/` operator performs division between two numbers. However, if two numbers are integers, we will only get the quotient. For example,

``````// returns quotient only
7 / 2 = 3``````

If we use the `/` operator with floating-point numbers, we will get the actual result. For example,

``````// perform division
7.0 / 3.0 = 3.5``````

% Modulo Operator

The modulo operator `%` computes the remainder. For example,

``print(9 % 4)     // 1``

Note: The `%` operator can only be used with integers.

## 2. Swift Assignment Operators

Assignment operators are used to assign values to variables. For example,

``````// assign 5 to x
var x = 5``````

Here, `=` is an assignment operator that assigns `5` to `x`. Here’s a list of different assignment operators available in Swift.

Operator Name Example
`=` Assignment Operator `a = 7`
`+=` Addition Assignment `a += 1 // a = a + 1`
`-=` Subtraction Assignment `a -= 3 // a = a - 3`
`*=` Multiplication Assignment `a *= 4 // a = a * 4`
`/=` Division Assignment `a /= 3 // a = a / 3`
`%=` Remainder Assignment `a %= 10 // a = a % 5`

### Example 2: Assignment Operators

``````// assign 10 to a
var a = 10

// assign 5 to b
var b = 5

// assign the sum of a and b to a
a += b      // a = a + b

print(a)``````

Output

`15`

## 3. Swift Comparison Operators

Comparison operators compare two values/variables and return a boolean result: `true` or `false`. For example,

``````var a = 5, b =2
print (a > b)      // true``````

Here, the `>` comparison operator is used to compare whether `a` is greater than `b` or not.

Operator Meaning Example
`==` Is Equal To `3 == 5` gives us false
`!=` Not Equal To `3 != 5` gives us true
`>` Greater Than `3 > 5` gives us false
`<` Less Than `3 < 5` gives us true
`>=` Greater Than or Equal To `3 >= 5` give us false
`<=` Less Than or Equal To `3 <= 5` gives us true

### Example 3: Comparison Operators

``````var a = 5, b = 2

// equal to operator
print(a == b)

// not equal to operator
print(a != b)

// greater than operator
print(a > b)

// less than operator
print(a < b)

// greater than or equal to operator
print(a >= b)

// less than or equal to operator
print(a <= b)``````

Output

```false
true
true
false
true
false```

Note: Comparison operators are used in decision-making and loops. We’ll discuss more of the comparison operator in later tutorials.

## 4. Swift Logical Operators

Logical operators are used to check whether an expression is `true` or `false`. They are used in decision-making. For example,

``````var a = 5, b = 6
print((a > 2) && (b >= 6))    // true``````

Here, `&&` is the logical operator AND. Since both `a > 2` and `b >= 6` are `true`, the result is `true`.

Operator Example Meaning
`&&` a && b Logical AND:
`true` only if both the operands are `true`
`||` a || b Logical OR:
`true` if at least one of the operands is `true`
`!` !a Logical NOT:
`true` if the operand is `false` and vice-versa.

### Example 4: Logical Operators

``````// logical AND
print(true && true)      // true
print(true && false)     // false

// logical OR
print(true || false)      // true

// logical NOT
print(!true)                  // false``````

Output

```true
false
true
false```

## 5. Swift Bitwise Operators

In Swift, bitwise operators are used to perform operations on individual bits.

Operator Description
`&` Binary AND
`|` Binary OR
`^` Binary XOR
`~` Binary One’s Complement
`<<` Binary Shift Left
`>>` Binary Shift Right

`? :` Ternary Operator – returns value based on the condition `(5 > 2) ? "Success" : "Error" // Success`
`??` Nil-Coalescing Operator – checks whether an optional contains a value or not `number ?? 5`
`...` Range Operator – defines range containing values `1...3 // range containing values 1,2,3`