学习Swift5.1官方文档记录（一）—— Basic Operator

前言

该文档为本人学习SWIFT5.1官方文档过程中将觉得需要记录的点以及测试过程中遇到的问题进行记录的文档，目的在于学后有空能够温故而知新。
本人是一名刚学习SWIFT一个多月的小菜鸟，所以若在记录过程中存在错误还望各位大佬见谅。

1、一元，二元，三元运算符

一元运算符：运算符作用于一个对象，如 +a(返回原值，起标记作用)，-a，!a，c!
二元运算符：运算符作用于两个对象，如 a+b , a-b 等
三元运算符：运算符作用于三个对象，只有一个，即 a ? b : c

2、赋值运算符（Assignment Operator）

Swift不同于C和Object-C，它的赋值运算符是没有返回值的。

if x = y {
	//不合法的，因为 x = y 没有返回值
}

C中的赋值运算符返回的是左边的地址，来个小插曲，如下：

#include <stdio.h>
int main()
{
    int t = 4;
    printf("%d, %d, t = %d\n", (t*=2), (t-=2), t);
    return 0;
}

由于C中赋值运算符返回左边的地址，所以三个值是一致的，又因为printf的压栈
是从右到左的（计算顺序从右到左），所以
输出结果：4，4，t=4

3、带负值的取余计算

a % b 等价于
a = ( b * multiplier ) + reminder 
b * multiplier 尽可能接近 a
如：
1. -9 % 2 
	2 * multiplier 尽可能接近-9, 得multiplier = -4
	-9 = -8 + -1 , 即余数reminder = -1
2. -30 % -8
	-8 * multiplier 尽可能接近 -30，得multiplier = 4
	-30 = -32 + 2, 即余数reminder = 2

4、复合赋值运算符

复合赋值运算符如 a += 3 等价于 a = a + 3 ，实质上也是一个赋值运算符
已知赋值运算符是无返回值的，所以以下写法是错误的：
let b = a += 2

5、比较运算符中的元组比较

元组比较前提

元组比较的前提是两个元组元素个数相同且对应类型相同。如：
(1,"2",3) 和 (2,"4") 无法进行比较，因为元素个数不同。
(1,"2",3) 和 (2,"4","5")无法进行比较，因为第三个元素类型不相同。
注：
1、BOOL类型无法进行比较 (1,true) > (0,false) 会报错
2、SWIFT提供的元组比较只能比较7个元素以内的元组，元素个数>=7则无法进行
比较，需要自定义比较运算符。

元组比较规则

元组比较规则是：
比较两个元组位置相同的元素，若返回true则停止后续的比较，返回结果。
若返回false则继续比较后续的比较，直至返回true或全部比较完毕。如：
(2,"B",3.5) > (3,"A",2.2)
1. 2 > 3 为false，继续比较；
2. "B" > "A" 为true，返回true，停止比较。
字符串比较规则：
1、按字符ASCII码进行比较
2、若相等则继续比较，否则返回比较结果
3、若字符串长度不相等且前面一截字符串都相等，则长度较长的字符串为较大者
如：
1、"A" > "B" 实际上是 65 > 66 为 false
2、"ABCD" > "ACC"  A相等，继续比较，B < C 所以返回 false
3、"abCd1" > "abCd"  abCd都相等，长度前者较长，所以返回 true
ASCII码大小 ：1-9 < A-Z < a-z

6、三元运算符与空合运算符(??)

三元运算符

三元运算符为 question ? answer1 : answer2 
以我的理解，三元运算符可以等价于调用一个函数：

func test<T>(Bool: question,T: answer1,T: answer2) -> T {
		if question {
			return answer1
		}else{
			return answer2
		}
}

所以：
1、answer1与answer2类型必须一致，否则会提示错误。
2、可以将三元运算符赋值给一个变量或常量，如

	var b = 4
	var a = b > 3 ? "b大于3" : "b小于或等于3"
	var c = test(question: b > 3,answer1: "b大于3",answer2: "b小于等于3")
	print(a)
	print(c)
	输出结果：
	b大于3
	b大于3

空合运算符

     空合运算符 a ?? b,其中a是可选类型<T>,b是类型T或可选类型<T>
     作用是若 a 有值、不是nil,则返回 a!，若a无值即a=nil，则返回b
     a ?? b 等价于
     a != nil ? a! : b

进行一番测试：

var str:String? = "abc"
var str1 = str ?? nil
print(str1)

原本以为输出结果应该是 abc 无疑，结果输出的是
Optional(“abc”)，有点意思，继续进行测试：

var str:String? = "abc"
var str1 = str ?? nil
var str2 = str ?? "none"
print(str1)
print(str2)
输出结果：
Optional("abc")
abc

得出结论：
空合运算符 a ?? b ，当a有值时若b是可选类型则a不会进行解包，若b不是可选类型则a会进行解包。
那么这是为什么呢？在上面提的三元运算符的等价函数中加上类型判断，并进行测试如下：

	func test<T>(Bool: condition,T: param1,T: param2) -> T {
		if type(of:param1) == String.self{
			print("param1 is String")
		}
		if type(of:param1) == Optional<String>.self{
			print("param1 is Optional")
		}
		if type(of:param2) == String.self{
			print("param2 is String")
		}
		if type(of:param2) == Optional<String>.self{
			print("param2 is Optional")
		}
			if condition{
				return param1
			}else{
				return param2
			}
	}
	var optStr:String? = "a"
	test(condition: true,param1:optStr,param2:"a")
	输出:
	param1 is Optional
	param2 is Optional
	test(condition: true,param1:optStr!,param2:optStr)
	输出:
	param1 is Optional
	param2 is Optional
	test(condition: true,param1:optStr!,param2:"b")
	输出:
	param1 is String
	param2 is String
	

param1和param2都是T类型，也就是说SWIFT在做类型推断时若两者中其中有一个是Optional<B>类型，一个是B类型，那么会将T推断为Optional<B>类型，那么为啥要这么推断呢？可以这么理解：Optional<B>可以向下兼容B，所以就导致了以上出乎我意料之中的结果。

回想一下空合运算符的意义在于若某一可选类型没值时给定一个初始值，确保其属于于解包后的类型，设计的初衷就不会给b传一个可选类型。所以我分析这么多实际上也没啥意义~

7、范围运算符（Range Operators）

范围运算符是表示一个范围内所有值的捷径。
a...b 表示 [a,b] 如 0...2 代表 0,1,2
a..<b 表示 [a,b) 如 0..<2 代表 0,1
若已经知道一个范围的最小值a和最大值b，那么可以省略a或省略b,对于...甚至
可以两端都省略。
如已知数组下标最小值是0，最大值是count-1，那么可以这么写：

	var arr = ["a","b","c","d"]
	for param in arr[...2]{
		print(param)
	}
	输出 a b c
	for param in arr[2...]{
		print(param)
	}
	输出 c d
	for param in arr[...]{
		print(param)
	}
	输出 a b c d
	for param in arr{
		print(param)
	}
	输出 a b c d
	for param in arr[..<]{ //报错
	}

范围运算符并不只能应用于遍历中，还可以赋值给一个变量或常量，可以用来判断
一个变量是否处于某个范围内，如

	var element = 101
	let range = 100...200
	if range.contains(element){
		...
	}