# Using Operators in Swift

• Print
This chapter is from the book

## Binary Operators

Binary operators are operators that affect operands, which are the values on either side of the operator. For example, take a + b. In this expression, a and b are operands, and + is the operator. All Binary operators are infix, meaning they are in between two operands.

### Standard Arithmetic Operators

Swift provides the four standard arithmetic operators that are binary operators for all numeric types, which are addition (+), subtraction (-), division (/), and multiplication (*). To use these operators in code, you use them exactly the way you would write them in a math equation:

```let a = 5 + 5 // a equals 10
let b = 3 - 2 // b equals 1
let c = 8.0 / 5.0 // c equals 1.6
let d = 4 * 4 // d equals 16```

### Remainder Operator

Swift includes a remainder operator, annotated by the % sign. In other languages, this operator is called the modulo operator, which has slightly different behavior. Swift calculates the remainder operator by figuring out how many times b evenly divides a, and returns the remainder. In other words, a = (b * multiplier) + remainder, with multiplier being the largest number b could multiply against to not produce a value higher than a.

In languages like C and Objective-C, the modulo operator behaved similarly, but unlike Swift, it could not perform against floating-point numbers; you would get a compiler error as the modulo operator cannot take floating-point numbers as its operands. This is another reason that Swift’s remainder operator is truly a remainder operator, because Swift gives the remainder of what is left over from a - (b * multiplier). Listing 3.1 displays the modulo operator in C.

#### LISTING 3.1 Modulo Operator in C and Objective-C

```int a = 8;
int b = 6;
int c = a % b; // returns 2, as expected
int d = -8;
int e = d % b; // returns -2, as expected```

In C and Objective-C, the modulo operator is pretty straightforward, as long as you’re providing integers. Listing 3.2 displays the remainder operator in Swift, which not only works with integers like C, but can also operate on Double types.

#### LISTING 3.2 Remainder Operator in Swift

```let a = 8
let b = 6
let c = a % b // returns 2, just as in C
let d = 8.0
let e = 2.5
let f = d % e // returns 0.5, Swift allows remainders for Double types```

### The Assignment Operator

There is just one assignment operator in Swift, as in other languages, and that is the equal sign (=). The assignment operator takes the calculated or literal value on the right side of the equal sign and assigns it to the variable or constant on the left side of the equal sign. We have seen the assignment operator many times throughout this book already, and every single line in Listing 3.1 and Listing 3.2 utilizes the assignment operator.

### Compound Assignment Operators

Compound assignment operators in Swift utilize the previously mentioned assignment operator (=), coupled with another operator, to perform a combined effect. Table 3.1 details each operator, what code it is short for, and a description.

#### TABLE 3.1 Compound Assignment Operators

 Operator Example Longer Expression Description += a += b a = a + b Add, then assign -= a -= b a = a - b Subtract, then assign *= a *= b a = a * b Multiply, then assign /= a /= b a = a / b Divide, then assign %= a %= b a = a % b Compute remainder, then assign

Table 3.1 shows some of the basic compound operators. However, there are many more compound operators, all of which are more advanced than the scope of this book, such as bitwise and logical compound operations. For more information on these operators, see the chapter on expressions in The Swift Programming Language, Apple, 2015.

### Comparison Operators

Comparison operators in Swift are similar to those of other programming languages. Each one returns a Boolean value describing whether the expression was true or false. Table 3.2 lists the basic comparison operators.

#### TABLE 3.2 Comparison Operators

 Operator Example Description > a > b Returns true if a is greater than b, else false. < a < b Returns true if a is less than b, else false. >= a >= b Returns true if a is greater than or equal to b, else false. <= a <= b Returns true if a is less than or equal to b, else false. == a == b Returns true if a is equal to b, else false. != a != b Returns true if a is not equal to b, else false.

As with comparison operators, there are other advanced operators. We cannot discuss them all in this book, but we cover two more of them in Hour 10, “Learning About Structs and Classes.”

### Range Operators

Range operators in Swift are denoted by two dots and a left angle bracket (..<) or three dots (...) depending on what type of range you need. There are two types of range operators: half-closed range operators and closed range operators.

A half-closed range operator uses two dots and a left angle bracket to indicate a range of integers from its left-hand operand up to but not including the right-hand operand. The expression 1..<5 defines a range of four integers, 1 through 4, but not including 5. You can also use variables or constants with range operators, such as 1..<a. The half-closed operator is called as such because its range contains its initial value but not the final value.

A closed range operator uses three dots to indicate a range of integers from its left-hand operand up to and including the right-hand operand. The expression -2...2 defines a range of five integers, from -2 to +2. The closed range operator can also use variables or constants as operands, such as a...b. The closed range operator is called closed range because the range is closed on each end by including both operands.

Both half-closed range operators and closed range operators are useful in iterative expressions. Closed range operators are good for ranges where you want both the first and last values of the range to be included. Half-closed range operators are especially good for zero-based lists such as arrays, where the index of the first element is 0, followed by 1, then 2, and so on. Arrays are discussed in more detail in Hour 4, “Working with Collection Types.” Consider the code in Listing 3.3—it illustrates the differences in the two range operators.

#### LISTING 3.3 Different Range Operators

```for a in 1...5 {
print(a)
}
//This closed range prints the following:
//1
//2
//3
//4
//5
let arrayLength = 3
for b in 0..<arrayLength {
print(b)
}
//This half-closed range prints the following:
//0
//1
//2```

### Logical Operators

Swift provides three logical operators, AND (&&), OR(||), and NOT (!). These operators are called logical operators because they evaluate upon and return Boolean value types based on logic. The three logical operators compare the bits inside their given operands, perform the operation against them, and then return the result. These three operators are similar to those you would find in other languages, but we discuss them here if you’re not familiar.

#### Logical AND Operator

The logical AND operator, sometimes referred to as just AND, performs a logical AND operation against both operands and returns the result. Let’s illustrate how AND operates and comes up with a return value. Look at the truth table in Table 3.3.

#### TABLE 3.3 Logical AND Operator Truth Table

 Operand 1 Operand 2 AND Result True True True True False False False True False False False False

Let’s say you’re comparing two Boolean values, a and b, in the following code sample:

```let a = true
let b = false
let c = a && b```

What value does c have? You’re right; c is false. The AND operator is useful when every value in a certain set of conditions needs to be met first before executing an expression or set of expressions. For example, the following code snippet illustrates what use of the AND operator looks like if you were to try to get access to a device’s motion data:

```if CMPedometer.isStepCountingAvailable() && userAcceptedUseOfMotionProcessor {
/* it's now ok to get step data */
} else {
print("cannot get step data")
}```

If step counting is not available (known by the Boolean return value of CMPedometer.isStepCountingAvailable()) or if the user has explicitly stated it’s not okay for us to have access to the device’s motion coprocessor, then we cannot count the user’s steps.

#### Logical OR Operator

The logical OR operator is similar in syntax to the AND operator but behaves slightly differently. The OR operator evaluates two operands and decides whether either one is true or not, no matter which one, and then returns its result. The truth table in Table 3.4 details the OR operator’s behavior.

#### TABLE 3.4 Logical OR Operator Truth Table

 Operand 1 Operand 2 OR Result True True True True False True False True True False False False

The OR operator returns true if either operand in the expression is true. Let’s take another look at a simple code snippet to illustrate OR:

```let a = true
let b = false
let c = a || b```

What is the value of c? Again, you’re right; the value is true. A more realistic example might look something like this:

```if userHasCellularConnectivity || userHasWifiConnectivity {
// assume user has an internet connection, start talking to web service
} else {
// warn user to enable connectivity hardware
}```

In the previous example, if either of the two operands (userHasCellularConnectivity or userHasWifiConnectivity) is true, then the first block of code executes. If neither operand is true, the second block of code executes. We cover conditionals with if statements in Hour 5.

#### Logical NOT Operator

The last logical operator, NOT, as mentioned earlier, simply inverts the value of a Boolean variable or constant. Although not a binary operator, NOT is listed here in the logical operators section for completeness. For example, see Table 3.5 for the truth table illustrating the values resulting from the NOT operator.

#### TABLE 3.5 Logical NOT Operator Truth Table

 Operand NOT Result True False False True

#### Combining Logical Operators

Logical operators can be combined into larger expressions where multiple lines of logic may be required. The expression a && b || !c combines all three logical operators and can be read as “a and b must be true, or not c”. While not required, you can insert parentheses to explicitly state the order of operations you want in your code, such as (a && b) || (!(c && d)).