➽01基本操作符

Posted 2021-10-30 itzyjr

赋值运算符

let b = 10// let表明b是个常量
var a = 5// var表明a是个变量
a = b// a is now equal to 10
//可以元组赋值
let (x, y) = (1, 2)// x is equal to 1, y is equal to 2

if x == y {
	// do something
}

算术运算符

1 + 2// equals 3
5 - 3// equals 2
2 * 3// equals 6
10.0 / 2.5// equals 4.0

"hello, " + "world"// equals "hello, world"

余数运算符

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

一元负运算符

let three = 3
let minusThree = -three// equals -3
let plusThree = -minusThree// equals 3

一元正运算符

let minusSix = -6
let alsoMinusSix = +minusSix// equals -6

复合赋值运算符

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

复合赋值运算符不返回一个值，所以这样用法是错误的：let b = a += 2

比较运算符

1 == 1// true
2 != 1// true
2 > 1// true
1 < 2// true
1 >= 1// true
2 <= 1// false

let name = "world"
if name == "world" {
	print("hello, world")// printed
} else {
	print("I'm sorry \\(name), but I don't recognize you")
}

可以比较两个元组(tuples)。最终比较结果的规律可从如下示例看出：

(1, "zebra") < (2, "apple")// true。因1<2(true)，后面的不用比较了，结果直接为true
(3, "apple") < (3, "bird")// true。因为3==3，所以要比较下一项，"apple"<"bird"(true)，所以最终结果为true
(4, "dog") == (4, "dog")// true

可以比较两个类型(String,Int)的元组，因为String和Int值都可以使用<运算符进行比较。相反，两个类型的元组(String,Bool)不能与<运算符进行比较，因为<运算符不能应用于Bool值。

("blue", -1) < ("purple", 1)// OK,true
("blue", false) < ("purple", true)// Error, < 不能用于比较Boolean值

Swift标准库包括用于少于7个元素的元组的元组比较运算符。要将元组与七个或更多元素进行比较，必须自己实现比较运算符。

三元条件运算符

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

nil-合并运算符
如果可选a包含值，则nil合并运算符(a ?? b)将其展开；如果a为nil，则返回默认值b。表达式a始终是可选类型。表达式b必须与存储在a中的类型匹配。

【变量名?】这个对象还没赋值，可能为空。如果在后面的某个函数中复制了就不会为空了，所以要给个?
【变量名!】这个对象已经初始化了。在声明后立即初始化。

nil合并运算符是以下代码的简写：
a != nil ? a! : b
上面的代码使用三元条件运算符和强制展开(a!)在a不是nil时访问a中包装的值，否则返回b。nil合并操作符提供了一种更优雅的方式，以简洁易读的形式封装此条件检查和展开。

如果a的值为非nil，则不计算b的值。这就是所谓的短路评估。

下面的示例使用nil合并运算符在默认颜色名称和可选的用户定义颜色名称之间进行选择：

let defaultColorName = "red"
var userDefinedColorName: String?// 默认为nil
// userDefinedColorName是nil，所以colorNameToUse设置为默认的"red"
var colorNameToUse = userDefinedColorName ?? defaultColorName

userDefinedColorName = "green"
// userDefinedColorName不是nil，所以colorNameToUse设置为"green"
colorNameToUse = userDefinedColorName ?? defaultColorName

范围运算符
闭合范围：
闭合范围运算符(a…b)定义从a到b的范围，包括值a和b。a的值不得大于b。

for index in 1...5 {
	print("\\(index) times 5 is \\(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

半开范围：
半开范围运算符(a..<b)定义了从a到b的范围，但不包括b。说它是半开的，因为它包含它的第一个值，但不包含它的最终值。与闭合范围运算符一样，a的值不得大于b。如果a的值等于b，则结果范围将为空。

let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
	print("Person \\(i + 1) is called \\(names[i])")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack

单边范围：

for name in names[2...] {
	print(name)
}
// Brian
// Jack

for name in names[...2] {
	print(name)
}
// Anna
// Alex
// Brian

for name in names[..<2] {
	print(name)
}
// Anna
// Alex

单边范围可以用于其他上下文，而不仅仅是在下标中。不能在忽略第一个值的单边范围内迭代，因为不清楚迭代应该从哪里开始。您可以在忽略其最终值的单边范围内进行迭代；但是，由于范围无限地继续，请确保为循环添加显式结束条件。您还可以检查单边范围是否包含特定值，如下面的代码所示。

let range = ...5
range.contains(7)// false
range.contains(4)// true
range.conatains(-1)// true

逻辑运算符
逻辑非!：

let allowedEntry = false;
if !allowedEntry {
	print("ACCESS DENIED")// printed
}

逻辑与&&：

let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
    print("Welcome!")
} else {
    print("ACCESS DENIED")// printed
}

逻辑或||：

let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
    print("Welcome!")// printed
} else {
    print("ACCESS DENIED")
}

联合各种逻辑运算符：

if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
    print("Welcome!")// printed
} else {
    print("ACCESS DENIED")
}

&&优先及大于||，为了代码更可读，可用括号括起来：

if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
    print("Welcome!")// printed
} else {
    print("ACCESS DENIED")
}