基本運算子

運算子是檢查、改變、合併值的特殊符號或語句。像是加號+就是將兩個數相加 (let number = 1 + 2)。

指派運算子

a = b表示將右邊的b指派給左邊的a，如下：

let b = 10
var a = 5
// 將 b 指派給左邊的 a
a = b
// 現在 a 等於 10

// 你也可以直接指派元組 會直接分解為多個常數或變數
let (x, y) = (1, 2)
// 現在 x 為 1, y 為 2

數值運算子

Swift 中所有數值型別都支援基本的四則運算，加 +、減 -、乘 *、除 / 。

var c = 1 + 2 // c 等於 3
var d = 7 - 2 // d 等於 5
var e = 3 * 2 // e 等於 6
var f = 10.0 / 2.5 // f 等於 4.0

加法運算子也可以用於字串的合併：

let firstString = "Hello, "
let secondString = "world."
let finalString = firstString + secondString

// 印出：Hello, world.
print(finalString)

後面章節會介紹更多字串的操作。

餘數運算

餘數運算( a % b )是計算b的多少倍剛剛好可以容入a，返回多出來的那部分，也就是餘數。

a = (b * 倍數) + 餘數

以下的例子為9 = (4 * 2) + 1，9等於4乘上倍數2再加上餘數1。返回的值就是餘數，也就是1。

var oneNumber = 9 % 4
print(oneNumber) // 餘數等於 1

Swift 比較特別的一點是，浮點數也可以取餘數：

var anotherNumber = 8.0 % 2.5 // 8.0 = (2.5 * 3.0) + 0.5
print(anotherNumber) // 餘數等於 0.5

一元負號

數值的正負號可以使用前綴-（即一元負號）來切換：

let number1 = 3
var anotherNumber1 = -number1 // 為 -3
var finalNumber1 = -anotherNumber1 // 為 3

一元正號

一元正號+則是不做任何改變地回傳數值。

let number2 = -6
var anotherNumber2 = +number2 // 為 -6

複合指派運算子

Swift 提供一個簡潔的方式，將數值運算與指派運算合併，像是+=，很多時候可以簡化程式，如下：

var n = 3
n += 2 // 這行等同於 n = n + 2 的簡寫
print(n) // 現在 n 等於 5

// 其他數值運算子也是一樣
n -= 4 // n = n - 4 , 現在 n 等於 1
n *= 10 // n = n * 10 , 現在 n 等於 10
n /= 2 // n = n / 2 , 現在 n 等於 5
n %= 2 // n = n % 2 , 現在 n 等於 1

比較運算子

將兩個數值作比較，並返回這個比較是否成立的布林值，即返回true或是false，以下是常用的比較運算。

  • 等於（a == b）
  • 不等於（a != b）
  • 大於（a > b）
  • 小於（a < b）
  • 大於等於（a >= b）
  • 小於等於（a <= b）
1 == 1 // 返回 true 因為 1 等於 1
2 != 1 // 返回 true 因為 2 不等於 1
2 > 1 // 返回 true 因為 2 大於 1
1 < 2 // 返回 true 因為 1 小於2
1 >= 1 // 返回 true 因為 1 大於等於 1
2 <= 1 // 返回 false 因為 2 不小於等於 1

常用於條件語句，像是if條件：

var i = 1
if i == 1 {
    print("Yes, it is 1 .")
} else {
    print("No, it is not 1 .")
}

// 因為 i 等於 1, 返回 true, 所以會印出：Yes, it is 1 .

後面章節會正式介紹 if 的使用方法。

當元組中的值可以比較時，你也可以用比較運算子來比較它們的大小。像是Int和String型別的值可以比較，所以元組(Int, String)也可以被比較。而Bool不能比較，所以內含布林值型別的元組不能被比較。

元組比較大小會依序由左到右逐個比較，直到有兩個值不相等為止。而如果所有值都相等，則會將這一對元組稱為相等的。例子如下：

// true 因為 1 小於 2
(1, "zebra") < (2, "apple")

// true 因為 3 等於 3,但是 apple 小於 bird
(3, "apple") < (3, "bird")

// true 因為 4 等於 4,dog 等於 dog
(4, "dog") == (4, "dog")
Hint
  • Swift 在比較元組的成員時，限制最多只能比較六個成員，如果有七個或七個以上成員則無法比較。

三元運算子

這是一個簡潔的條件式運算：問題 ? 答案1 : 答案2。問題需要返回一個是否成立的布林值，表示true或false，如果為true，則是返回答案1，反之如果為false，則是返回答案2。也就是下列寫法的簡寫：

if 問題 {
    答案1
} else {
    答案2
}

以下是個例子：

var score = 25
if score < 60 {
    score = score + 50
} else {
    score = score + 20
}

print(score) // 現在 score 等於 75

後面章節會正式介紹 if 的使用方法。

使用三元運算子可以簡化成下面這樣：

var newScore = 25
newScore = newScore + (newScore < 60 ? 50 : 20)

空值聚合運算子

前面章節介紹過的可選型別， Swift 提供一個簡潔的使用方法：a ?? b。先判斷a是否為nil，如果a有值，不是nil，就會解析a並返回，但如果a為nil，則返回預設值b。也就是下面這個寫法的簡寫：

a != nil ? a! : b

這裡用到前面提到的三元運算子，如果a不等於nil，則強制解析a並返回，否則就返回b。以下為一個例子：

let defaultColor = "red"
var userDefinedColor: String? // 未指派值 所以預設為 nil
var colorToUse = userDefinedColor ?? defaultColor
// 未指派值給 userDefinedColor ,所以會返回 defaultColor
// 這邊即印出：red
print(colorToUse)

// 反之如果有指派值
var userAnotherDefinedColor: String? = "green"
var anotherColorToUse = userAnotherDefinedColor ?? defaultColor
// 這邊即印出：green
print(anotherColorToUse)

區間運算子

Swift 提供兩個方便表達一個區間的值的運算子。

閉區間運算子

表示方式為：a...b，定義一個包含從a到b(包括a和b)的所有值的區間。b必須大於等於a。

// 1...5 代表的就是 1,2,3,4,5 這五個數字
for index in 1...5 {
    print("\(index) * 5 = \(index * 5)")
}
// 依序印出
// 1 * 5 = 5
// 2 * 5 = 10
// 3 * 5 = 15
// 4 * 5 = 20
// 5 * 5 = 25

後面章節會正式介紹 for-in 的使用方法，這邊先理解為是一個會依照規則依序執行動作的語法。

半開區間運算子

表示方式為：a..<b，定義一個從a到b但不包括b的區間。b必須大於等於a，但當a等於b時，則不會有值。

// 1..<5 代表的就是 1,2,3,4 這四個數字 不包括 5
for index in 1..<5 {
    print("\(index) * 5 = \(index * 5)")
}
// 依序印出
// 1 * 5 = 5
// 2 * 5 = 10
// 3 * 5 = 15
// 4 * 5 = 20

邏輯運算子

Swift 支援三個標準邏輯運算，常與條件式合用。

  • 邏輯非（!a）
  • 邏輯且（a && b）
  • 邏輯或（a || b）

a及b都是邏輯布林值，且皆會返回一個邏輯布林值，即true或是false。

邏輯非

!a對一個布林值取相反值，即將true變false，或是將false變true。這是一個前綴運算子，且不加空格，例子如下：

let isOn = false
if !isOn {
    print("It is on .")
}

邏輯且

a && b表示只有當a跟b都為true時，才會返回true，否則如果a或b其中一個為false，就會返回false，如下：

let isOpen = true
let isMorning = false
if isOpen && isMorning {
    print("Success !")
} else {
    print("Failure !")
}
// 因為其中一個為 false 所以會返回 false
// 即印出：Failure !

邏輯或

a || b表示只要a跟b其中一個值為true時，就會返回true，除非a和b皆為false，才會返回false，如下：

let isSunday = true
let isWeekday = false
if isSunday || isWeekday {
    print("Success !")
} else {
    print("Failure !")
}

// 因為其中一個為 true 就會返回 true
// 即印出：Success !

括號優先

以上介紹很多運算子，當一個運算式太複雜時，可以使用括號()來標示清楚，同時也用來表明優先級(如同傳統學習數學計算一樣，括號括起來的部份要優先計算)。例子如下：

// 數值運算
// 先乘除後加減 所以 number 等於 13
var number = 3 + 2 * 5
// 括號括起來的優先 所以 someNumber 等於 25
var someNumber = (3 + 2) * 5

// 邏輯運算
let itIsOpen = false
let isWeekend = true
let isMonday = true

// 由左至右依序判斷
if itIsOpen && isWeekend || isMonday {
    print("Success !")
} else {
    print("Failure !")
}
// 先作"邏輯且"判斷 itIsOpen && isWeekend 會返回 false
// 再與後面的 isMonday 作"邏輯或"的判斷 會返回 true
// 所以這邊會印出：Success !

// 括號有優先權
if itIsOpen && (isWeekend || isMonday) {
    print("Success !")
} else {
    print("Failure !")
}
// 括號優先 所以先做"邏輯或"判斷 isWeekend || isMonday 會返回 true
// 再與前面的 itIsOpen 作"邏輯且"的判斷 會返回 false
// 所以這邊會印出：Failure !

範例

本節範例程式碼放在 ch1/basic_operators.playground

results matching ""

    No results matching ""