Swift Operators
Tags: swift, programming, beginners
Published: 2021-12-26 06:13:53

An operator is a special symbol or phrase that you use to check, change, or combine values.

## Assignment operator
The assignment operator (a = b) initializes or updates the value of a with the value of b:

```swift
let b = 10
var a = 5
a = b
// a is now equal to 10
```

## Arithmetic Operators
Swift supports the four standard arithmetic operators for all number types:

- Addition (+)
- Subtractions (-)
- Multiplication (*)
- Division (/)

Remainder (%) operator works out like how many multiples of b will fit inside a and it returns the value thats left over (remainder)

### unary operators
- unary plus (+) operator
- unary minus (-) operator

## Compound Assignment operator (+=)
Like other programming languages compound assignment operator combines the assignment operator with any other arithmetic operators.

```swift
var a = 5
a += 10 //a = a + 10
print(a) // 15
```
## Comparison operators
Swift supports the following comparison operators and maximum of cases the comparison operators return a boolean value.
- Equal to (==) 
- Not equal to (!=)
- greater than (>)
- lesser than (<)
- greater than or equal to (>=)
- lesser than or equal to (<=)

## Ternary operator (?:)
The ternary conditional operator is a special operator with three parts, which takes the form question ? answer1 : answer2.

The ternary operator is the short form of the below code .
```swift
let a = 10, b = 20
if(a>b) {
print("A is greater")
}else {
print("B is greater")
}

//prints B is greater 

a > b ? print("A is greater") : print("B is greater")

//prints B is greater 
```
## Nil-coalescing operator (??)

The nil-coalescing operator (a ?? b) unwraps an optional a if it contains a value, or returns a default value b if a is nil.
```swift
let a:Int? = nil
let b:Int = a ?? 20
print(b) //prints 20

//this operator is shorthand for

a != nil ? a! : b 

if a != nil {
    print(a!)
}else {
    a = 20
}
print(a!)
 
```
Note : If the value of a is not nil then b is not evaluated this is known as **short-circuit evaluation**

## Range operator
Swift includes several range operators, which are shortcuts for expressing a range of values.

### closed range (a...b)
It defines a range that runs from a to b and it includes the a and b
- The value of a should not be greater than b
```swift
for index in 3...6 {
    print(index)
}
//3 4 5 6
```

### Half-open Range operator (a..<b)
It defines a range that runs from a to b but it does not includes b. It's said to be half-open because it contains the first value but not the final value.
```swift
for index in 3..<6 {
    print(index)
}
//3 4 5 
```
### one-sided range (a...),(...b),(..<b)
The closed range operator has an alternative form for ranges that continues from a range that continues as far as possible in one direction.

## Logical operators
Logical operators modify or combine the Boolean logic values true and false. Swift supports the three standard logical operators found in C-based languages:
- Logical not (!a)
Returns the reverse of the value
- Logical Or (a || b)
Returns true if any of two values are true
- Logical And (a && b)
Returns true if only both values are true