↓ Skip to main content
Shen-Chih Hsu

[From C# to Swift] 02. Basic Operators

From C# to Swift Swift C#
Table of Contents

Learning Swift from a C# Perspective

Swift : Basic Operators

Terminology and Basics
#

1. Core Concepts
#

  • Concept Explanation: Swift operators are categorized as Unary, Binary, and Ternary. These concepts are the same as in most C-family languages. The objects being operated on are called Operands.
  • Key Syntax: Unary (-a), Binary (a + b), Ternary (a ? b : c)
  • Official Note: None

2. Example Analysis
#

Source Code:

let i = 1 + 2
if enteredDoorCode && passedRetinaScan { ... }

Logic Explanation: + is a binary operator that adds 1 and 2. && is a logical AND operator used to combine two Boolean values.

3. C# Developer’s Perspective
#

Concept Mapping: C# possesses these same three categories of operators; the basic classification is identical.

C# Comparison Code:

int i = 1 + 2;
if (enteredDoorCode && passedRetinaScan) { ... }

Key Difference Analysis:

  • Syntax: Basically identical.
  • Behavior: No significant differences.

Assignment Operator
#

1. Core Concepts
#

  • Concept Explanation: Uses = to initialize or update the variable on the left with the value on the right. Swift’s assignment operator has an important safety feature: it does not return a value.
  • Key Syntax: =
  • Official Note:

If the right side of the assignment is a tuple with multiple values, its elements can be decomposed into multiple constants or variables at once.

2. Example Analysis
#

Source Code:

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

var (x, y) = (1, 2)
// x is equal to 1, y is equal to 2

if x = y {
    // This is invalid because x = y does not return a value
}

Logic Explanation: This code demonstrates basic assignment and Tuple destructuring assignment. The most important part is the final block: the Swift compiler will report an error, preventing the common mistake where a developer intends to write == (comparison) but accidentally writes = (assignment).

3. C# Developer’s Perspective
#

Concept Mapping: Corresponds to C# = assignment. However, assignment expressions in C# return a value (the value that was assigned).

C# Comparison Code:

int b = 10;
int a = 5;
a = b;

// C# 7.0+ supports Tuple deconstruction
(int x, int y) = (1, 2);

// In C#, this is legal in certain cases (though the compiler might warn, or if used in a while loop)
// if (x = y) { ... } // Compiles if x and y are bool

Key Difference Analysis:

  • Syntax: The Tuple destructuring syntax let (x, y) = (1, 2) is very concise, similar to C#’s (var x, var y) = (1, 2).
  • Behavior: Trap Alert! In C#, the expression a = b results in the value of b, allowing chained assignments like a = b = c. In Swift, assignment does not return a value, so a = b = c is illegal, and if x = y results in a compilation error. This is a design choice to prevent bugs.

Arithmetic Operators
#

1. Core Concepts
#

  • Concept Explanation: Swift supports standard arithmetic operations (+, -, *, /). Unlike C/C++, Swift does not allow value overflow by default. If a calculation result exceeds the type’s range, the program will report an error (Crash) rather than silently truncating.
  • Key Syntax: +, -, *, /, String concatenation
  • Official Note:

Unlike the arithmetic operators in C and Objective-C, the Swift arithmetic operators don’t allow values to overflow by default. You can opt in to value overflow behavior by using Swift’s overflow operators (such as &+).

2. Example Analysis
#

Source Code:

1 + 2       // equals 3
5 - 3       // equals 2
2 * 3       // equals 6
10.0 / 2.5  // equals 4.0
"hello, " + "world"  // equals "hello, world"

Logic Explanation: Demonstrates basic integer and floating-point arithmetic, as well as using + for string concatenation.

3. C# Developer’s Perspective
#

Concept Mapping: Corresponds to C# arithmetic operators.

C# Comparison Code:

int sum = 1 + 2;
double div = 10.0 / 2.5;
string str = "hello, " + "world";

Key Difference Analysis:

  • Syntax: Completely identical.
  • Behavior: Memory Management and Safety. C# int operations in a default unchecked context will overflow (Wrap around) without error unless explicitly placed in a checked block. Swift, by default, acts like a checked context; overflow causes a Runtime Error. To allow overflow like C#’s default behavior, Swift requires specific overflow operators like &+, &-, &*.

Remainder Operator
#

1. Core Concepts
#

  • Concept Explanation: Calculates a % b, determining how many multiples of b fit inside a and returning the remaining part.
  • Key Syntax: %
  • Official Note:

The remainder operator (%) is also known as a modulo operator in other languages. However, strictly speaking, Swift’s behavior for negative numbers is that of a remainder rather than a modulo operation.

2. Example Analysis
#

Source Code:

9 % 4    // equals 1
-9 % 4   // equals -1

Logic Explanation: 9 = (4 x 2) + 1, so the remainder is 1. -9 = (4 x -2) + (-1), so the remainder is -1. The rule in Swift is that the sign of a % b matches the sign of a.

3. C# Developer’s Perspective
#

Concept Mapping: The % operator in C# is also a Remainder Operator, not a mathematical Modulo.

C# Comparison Code:

int r1 = 9 % 4;   // 1
int r2 = -9 % 4;  // -1

Key Difference Analysis:

  • Behavior: Swift and C# behave identically regarding this point; both return the remainder for negative numbers (the result follows the sign of the dividend).

Unary Minus / Plus Operator
#

1. Core Concepts
#

  • Concept Explanation: - toggles the sign of a numeric value; + returns the value itself (usually exists for symmetry).
  • Key Syntax: -, +

2. Example Analysis
#

Source Code:

let three = 3
let minusThree = -three       // -3
let plusThree = -minusThree   // 3
let minusSix = -6
let alsoMinusSix = +minusSix  // -6

Logic Explanation: Directly operates on the sign of the value.

3. C# Developer’s Perspective
#

Concept Mapping: Fully corresponds to C# unary operators.

C# Comparison Code:

int three = 3;
int minusThree = -three;

Key Difference Analysis:

  • Behavior: No difference.

Compound Assignment Operators
#

1. Core Concepts
#

  • Concept Explanation: Combines an operation with assignment, such as +=.
  • Key Syntax: +=, -=, *=, /=
  • Official Note:

The compound assignment operators don’t return a value. For example, you can’t write let b = a += 2.

2. Example Analysis
#

Source Code:

var a = 1
a += 2
// a is now 3

Logic Explanation: a += 2 is equivalent to a = a + 2.

3. C# Developer’s Perspective
#

Concept Mapping: C# also has +=.

C# Comparison Code:

int a = 1;
a += 2;
// int b = (a += 2); // This is legal in C#!

Key Difference Analysis:

  • Behavior: To reiterate, Swift’s += does not return a value, whereas C#’s += returns the result of the operation. Therefore, you cannot use it as part of a larger expression in Swift as you can in C#.

Comparison Operators
#

1. Core Concepts
#

  • Concept Explanation: Used to compare two values, returning a Bool (true or false). Swift supports Tuple comparison (for Tuples with fewer than 7 elements).
  • Key Syntax: ==, !=, >, <, >=, <=, ===, !==
  • Official Note:

Swift also provides two identity operators (=== and !==), which you use to test whether two object references both refer to the same object instance. The Swift standard library includes tuple comparison operators for tuples with fewer than seven elements.

2. Example Analysis
#

Source Code:

1 == 1   // true
(1, "zebra") < (2, "apple")   // true (because 1 < 2)
(3, "apple") < (3, "bird")    // true (3 equals 3, and apple is less than bird)

Logic Explanation: Tuple comparison proceeds “left to right”. Once an element is found to be unequal, the comparison result of that element determines the result for the entire Tuple.

3. C# Developer’s Perspective
#

Concept Mapping: C# comparison operators. === corresponds to C#’s Object.ReferenceEquals.

C# Comparison Code:

bool result = 1 == 1;
// C# 7.3+ supports Tuple `==` and `!=`, but `<` `>` do not directly support Tuple comparison
var t1 = (1, "zebra");
var t2 = (2, "apple");
// bool tupleComp = t1 < t2; // Compile error, C# Tuple does not directly support <

Key Difference Analysis:

  • Syntax: Swift’s === used for Reference Type pointer comparison is more concise than C#’s Object.ReferenceEquals(a, b).
  • Behavior: Swift natively supports size comparison (<, >) for Tuples. C# Tuples (ValueTuple) currently only support == and !=; comparing magnitude requires calling CompareTo or implementing custom logic.

Ternary Conditional Operator
#

1. Core Concepts
#

  • Concept Explanation: question ? answer1 : answer2. If question is true, return answer1; otherwise, return answer2.
  • Key Syntax: ? :

2. Example Analysis
#

Source Code:

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight equals 90

Logic Explanation: This is a concise if-else expression, suitable for single-line assignments.

3. C# Developer’s Perspective
#

Concept Mapping: Fully corresponds to C#’s ? : operator.

C# Comparison Code:

int contentHeight = 40;
bool hasHeader = true;
int rowHeight = contentHeight + (hasHeader ? 50 : 20);

Key Difference Analysis:

  • Behavior: No difference.

Nil-Coalescing Operator
#

1. Core Concepts
#

  • Concept Explanation: a ?? b. If Optional a has a value, it unwraps and uses it; if it is nil, it uses the default value b.
  • Key Syntax: ??
  • Official Note:

If the value of a is not nil, the value of b is not evaluated. This is known as short-circuit evaluation.

2. Example Analysis
#

Source Code:

let defaultColorName = "red"
var userDefinedColorName: String?   // defaults to nil
var colorNameToUse = userDefinedColorName ?? defaultColorName
// colorNameToUse is set to "red"

Logic Explanation: This is a very elegant way to handle Optionals, avoiding verbose if let blocks or ternary operators.

3. C# Developer’s Perspective
#

Concept Mapping: Corresponds to C#’s Null-coalescing operator ??.

C# Comparison Code:

string defaultColor = "red";
string? userColor = null;
string colorToUse = userColor ?? defaultColor;

Key Difference Analysis:

  • Syntax: Completely identical. Swift targets the Optional type, while C# targets Nullable Reference Types or Nullable Value Types.

Range Operators
#

1. Core Concepts
#

  • Concept Explanation: Swift provides special operators to express ranges of values.
    • Closed Range a...b: Includes a and b.
    • Half-Open Range a..<b: Includes a but does not include b.
    • One-Sided Ranges a... or ...b: Extends as far as possible in one direction.
  • Key Syntax: ..., ..<

2. Example Analysis
#

Source Code:

// Closed Range
for index in 1...5 { ... } // 1, 2, 3, 4, 5

// Half-Open Range
for i in 0..<count { ... } // 0 to count-1

// One-Sided Range (used for array slicing)
for name in names[2...] { ... } // From index 2 to the end

Logic Explanation: Closed ranges are often used when both ends are needed; Half-open ranges are particularly suitable for traversing 0-based array indices.

3. C# Developer’s Perspective
#

Concept Mapping: C# 8.0 introduced Range syntax ...

C# Comparison Code:

// C# Range is mainly used for indexing and slicing, less commonly used directly in foreach loops (requires Enumerable.Range)
string[] names = { "A", "B", "C", "D" };

// Swift: names[2...]
var slice = names[2..]; 

// Swift: 1...5 (C# has no direct corresponding loop syntax, usually uses a for loop)
// foreach (var i in 1..5) // C# does not support this syntax
foreach (var i in Enumerable.Range(1, 5)) { ... }

Key Difference Analysis:

  • Syntax:
    • Swift’s Closed Range is ...; C#’s Range is ...
    • Swift’s Half-Open Range is ..<; C#’s .. is inherently half-open (Exclusive end).
  • Behavior: Swift’s Range is a core type (ClosedRange<T>, Range<T>) that can be used directly in for-in loops, switch pattern matching (case 1...10:), and array slicing. C#’s Range (System.Range) is currently mainly used for array/Span slicing and cannot be thrown directly into a foreach loop.

Logical Operators
#

1. Core Concepts
#

  • Concept Explanation: Combines Boolean logic values.
  • Key Syntax: !a (NOT), a && b (AND), a || b (OR)
  • Official Note:

Swift logical operators && and || are left-associative.

2. Example Analysis
#

Source Code:

if !allowedEntry { ... }
if enteredDoorCode && passedRetinaScan { ... }
if hasDoorKey || knowsOverridePassword { ... }

Logic Explanation: Supports short-circuit evaluation: for &&, if the first part is false, the second is not evaluated; for ||, if the first part is true, the second is not evaluated.

3. C# Developer’s Perspective
#

Concept Mapping: Fully corresponds to C# logical operators.

C# Comparison Code:

if (!allowedEntry) { ... }
if (enteredDoorCode && passedRetinaScan) { ... }

Key Difference Analysis:

  • Behavior: No difference. Both support short-circuit evaluation. It is worth noting that Swift encourages using parentheses () to clarify the precedence of complex expressions, which is also a good habit in C#.