Swift: Operators: Unary Plus Operator, Compound Assignment Operators

Unary Plus Operator

The unary plus operator (+) is a prefix operator, which means that it is placed before the operand it operates on. It is used to force a value to be positive. This is useful for values that may be negative or zero.

The unary plus operator can be used on any type of numeric value, including integers, floating-point numbers, and booleans. It can also be used on the result of an expression.

Here are some examples of how to use the unary plus operator:

// Force the value of an integer variable to be positive 

var number: Int = -10 

number = +number // number is now equal to 10 




// Force the value of a floating-point variable to be positive 

var decimal: Double = -3.14 

decimal = +decimal // decimal is now equal to 3.14 




// Force the value of a boolean variable to be positive 

var isTrue: Bool = false 

isTrue = +isTrue // isTrue is now equal to true 




// Force the result of an expression to be positive 

let difference = 10 - 5 

let positiveDifference = +difference // positiveDifference is now equal to 5

The unary plus operator is not often used, but it can be useful in some cases. For example, it can be used to ensure that a value is always positive, even if it may be negative or zero. This can be useful for writing code that is more robust and reliable.

Here are some examples of when it might be useful to use the unary plus operator:

To ensure that a value is always positive when it is used as a divisor:

func divide(dividend: Int, divisor: Int) -> Int { 

 return dividend / +divisor 

}

This function will ensure that the divisor is always positive, even if it is passed a negative value. This prevents the function from crashing if a negative divisor is passed in.

To ensure that a value is always positive when it is used as an index:

func getElement(at index: Int) -> Int { 

 return array[index] 

}

This function will ensure that the index is always positive, even if it is passed a negative value. This prevents the function from crashing if a negative index is passed in.

Overall, the unary plus operator is a powerful tool that can be used to write more robust and reliable Swift code. However, it is important to use it sparingly, as it is not often necessary.

Compound assignment operators

Compound assignment operators combine an assignment operation with an arithmetic or bitwise operation. This can be useful for writing more concise and efficient code.

The following table shows the most common compound assignment operators in Swift:

Operator	Description
+=	Addition
-=	Subtraction
*=	Multiplication
/=	Division
%=	Remainder

Compound assignment operators can be used on any type of numeric value, including integers, floating-point numbers, and booleans.

Here are some examples of how to use compound assignment operators:

// Increment the value of a variable by 1 

var number: Int = 10 

number += 1 // number is now equal to 11 




// Decrement the value of a variable by 1 

number -= 1 // number is now equal to 10 




// Multiply the value of a variable by 2 

number *= 2 // number is now equal to 20 




// Divide the value of a variable by 2 

number /= 2 // number is now equal to 10 




// Calculate the remainder of dividing a variable by 2 

number %= 2 // number is now equal to 0

Compound assignment operators can also be used on the result of an expression. For example, the following code increments the value of the variable number by the result of the expression 10 + 5:

var number: Int = 10 

number += 10 + 5 // number is now equal to 15

Compound assignment operators can be a useful tool for writing code that is more concise and efficient. However, it is important to use them carefully, as they can be difficult to read and understand if they are not used correctly.

Here are some tips for using compound assignment operators effectively:

• Use them to simplify common arithmetic operations. For example, instead of writing the following code:

var number: Int = 10 

number = number + 1

You could simply write the following code:

var number: Int = 10 

number += 1

• Use them to avoid repeating yourself. For example, instead of writing the following code:

var number: Int = 10 

number += 5 

number += 5

You could simply write the following code:

var number: Int = 10 

number += 5 * 2

• Use them to write code that is more readable and understandable. For example, the following code is more readable and understandable than the following code:

// This code is less readable and understandable 

var number: Int = 10 

number = number - 5 

number = number - 5 




// This code is more readable and understandable 

var number: Int = 10 

number -= 5 * 2

Overall, compound assignment operators are a powerful tool that can be used to write more concise, efficient, and readable Swift code. However, it is important to use them carefully, as they can be difficult to read and understand if they are not used correctly.

<

>

Previous: Swift: Operators - Assignment, Arithmetic, Remainder, Unary Minus

Next: Swift: Operators: Comparison Operators, Ternary Conditional Operator, Nil-Coalescing Operator