01、Swift基础运算

1、变量和常量

1.1 变量

在Swift里面，使用var来定义各种不同类型的变量：

var name = "lichangan"

1.2 常量

在Swift里面，使用’’‘let’’'来定义各种不同类型的常量

let sex = "male"

1.3 Type Inference / annotation

Type Inference: Swift编译器会根据我们为变量的赋值自动推导变量的类型。

Type annotation: 我们在定义变量的时候，如果不确定变量的初始值，通过var Name:Type来指定变量类型。

2、数据类型

2.1 整数

2.1.1 整数类型

Swift一共定义了8种不同的整数类型：

Int8、Int16、Int32、Int64
UInt8、UInt16、UInt32、UInt64

通常情况下，我们不会再直接在代码中使用这些具体的整数类型，我们只使用Int来定义有符号整数，使用UInt来定义无符号整数。Swift编译器会根据目标编译平台，把Int或UInt转换成对应的整数类型。

例如：

 在我们的64位平台上，我们分别使用min和max方法，来查看Int和Int64可以表达的数值范围：
 Int.min   // -9223372036854775808
 Int.max   // 9223372036854775807

 Int64.min // -9223372036854775808
 Int64.max // 9223372036854775807
 
 通过上面的对比，我们就能发现，Int和Int64，它们可以表达的数值范围，是一样的。

2.1.2 整数的常用表达方式

let fifteenInDecimal = 15 //十进制
let fifteenInHex = 0xF //十六进制
let fiftenInOctal = 0o17 //八进制
let fifteenInBinary = 0b1111 //二进制

//在数字中添加分隔符
let million = 1_000_000

2.2 浮点数

Float: 最多表达6位精准的浮点数
Double: 至少可以表达15位精度的浮点数

var oneThirdInFloat : Float = 1/3
var oneThirdInDouble : Double = 1/3

如果没有明确的需求，我们应该统一使用Double来定义浮点数

2.3 和数字有关的类型推断(Type Inference)

在Swift里面，我们使用一个整数，编译器会把它推导成Int,使用一个浮点数，编译器会把它推导成Double。

使用type(of:)来查看一个变量的类型

var three = 3
type(of:three) //Int.Type

var zeroPointForteen = 0.14
type(of:zeroPointForteen) //Double.Type

在Swift里面，我们可以把不同类型数字的字面值直接运算。

var sum = 3 + 0.14

但是我们不同把不同数字类型的变量直接运算。

var sum = three + zeroPointForteen  //报错

当对变量进行算数运算的时候，所有变量的类型必须是相同的，如果变量类型不同，我们必须明确将其中的一些变量进行类型转

var sum = Double(three) + zeroPointForteen

2.4字符串

在C语言中，String是一个长度固定的字符数组，但是在Swift中String已经不再是一个集合类型了，但是我们仍然可以用像操作集合一样操作Swift中的String。

2.4.1获取前缀

方法一：
let name = "lichangan"
let beginIndex = name.startIndex
let endIndex = name.index(beginIndex, offsetBy: 2)
var firstName = name[beginIndex ..< endIndex] //li Substring.Type

方法二：
firstName = name.prefix(2) //li Substring.Type

方法三：
let endIndex = name.index(name.startIndex, offsetBy: 2)
name.prefix(upTo: endIndex) //li Substring.Type

方法四：
let throughName = name.prefix(through: endIndex) //lic
throughName.dropLast() //li

2.4.2获取后缀

方法一：
var subname = name.suffix(7) //changan Substring.Type

方法二：
let beginIndex = name.index(name.startIndex, offsetBy: 2)
subname = name.suffix(from: beginIndex) //changan Substring.Type

2.4.3遍历字符串中的每一个字符

在Swift3.0中的写法
for (index,value) in name.characters.enumerated() {
    print("\(index):\(value)")
}

Swift4.0以及之后的写法
for (index,value) in name.enumerated() {
    print("\(index):\(value)")
}

2.4.4插入内容

Swift3.0中的写法
if let index = mixStr.characters.index(of: "很") {
    mixStr.insert(contentsOf: " 3.0".characters, at: index)
    // "Swift 3.0很有趣"
}

Swift4.0以及之后的写法
var mixStr = "Swift很有趣"
if let index = mixStr.firstIndex(of: "很"){
    mixStr.insert(contentsOf: "3.0", at: index)
    // "Swift 3.0很有趣"
}

2.4.5基于Range的查找和替换

Swift 3.0的写法
if let cnIndex = mixStr.characters.index(of: "很") {
    // 2. Replace a specific range
    mixStr.replaceSubrange(
        cnIndex ..< mixStr.endIndex, 
        with: " is interesting!")
    // Swift 3.0 is interesting!
}

Swift4.0以及之后的写法
if let cnIndex = mixStr.firstIndex(of: "很"){
    mixStr.replaceSubrange(cnIndex ..< mixStr.endIndex, with: " is interesting!")
}

2.4.6截取子串

Swift3.0的写法
let swiftView = mixStr.characters.suffix(12).dropLast()
String(swiftView) // interesting

Swift4.0以及之后的写法
let swiftView = mixStr.suffix(12).dropLast()
String(swiftView) // interesting Substring.Type
先用suffix截掉了头部的"Swift 3.0 is"，再用dropLast方法去掉了末尾的“!”

2.4.7分割字符串

Swift3.0的写法
var str = "lichangan is coder;"
let strViews = str.characters.split(separator: " ")//["lichangan","is","coder;"]  Array<Substring>.Type
strViews.map(String.init) //Array<String>.Type

Swift4.0以及之后的写法
var str = "lichangan is coder;"
let strViews = str.split(separator: " ")//["lichangan","is","coder;"]  Array<Substring>.Type
let strArr = strViews.map(String.init) //Array<String>.Type

2.4.8字符串数组转换为字符串

let str = strArr.joined(separator: " ")

2.5 元组 Tuple

很多时候，我们需要把多个不同类型的值，打包成一个单位处理，使用(value1, value2, value3...)来定义元组。

2.5.1 定义元组

let success = (200,"HTTP OK")
let fileNotFound = (code:404,message:"File not found")
var redirect : (Int,String) = (302,"temporary redirect")

2.5.2 访问元组元素

print(success.0)  //200
print(fileNotFound.code) // 404

//把一个元组的值，一一对应拆分到不同的变量上面
var (successCode,successMessage) = success
print(successCode) //200

successCode = 201 //successCode被修改为201，但是无法修改原来success里面的值。
print(success) //(200, "HTTP OK")

//如果我们只是想对应到Tuple中特定的成员，而忽略其它成员，我们可以使用下划线'_'来代表那些不需要被对应的成员。

let (_,message) = success
print(message) //HTTP OK

2.5.3 元素比较

当我们比较两个Tuple类型的变量时，要遵循下面的规则：
1、只有元素个数相同的Tuple变量之间，才能进行比较。
2、当Tuple中元素个数相同时，比较是按照Tuple中元素的位置从前向后依次进行的：
（1）如果Tuple中，相同位置的两个元素相等，则继续比较下一个位置的两个元素，并根据第一个同一位置不相等的两个元素的大小关系，确定两个Tuple变量的关系；
（2）如果两个Tuple中所有位置的元素都相等，则两个Tuple变量相等；

2.6 常用操作符

2.6.1 赋值操作

let a = 20
var b = 30

2.6.2 基本算术运算操作符

let total = a + b
let sub = a - b
let mul = a * b
let div = a / b
let mod = a % b
//浮点数取余
8.truncatingRemainder(dividingBy: 2.5)

2.6.3 复合运算操作符

b += 10
b -= 10
b *= 10
b /= 10
b %= 10
Swift不会把数字自动转换成Bool类型。在需要Bool值的地方，你必须明确使用一个Bool变量。
Swift 3中不再支持自增（++）和自减（--）操作符，使用它们的前缀和后缀版本都会得到一个编译器错误。因此，需要+1/-1的时候，只能使用b += 1和b -= 1来实现。

2.6.4 比较操作符

let isEqual = sum == 10
let isNotEqual = sum != 10
let isGreater = sum > 10
let isLess = sum < 10
let isGe = sum >= 10
let isLe = sum <= 10

//Swift还支持两个用于比较对象引用的操作符：Identity operator，它们用来判断两个操作数是否引用同一个对象
//===
//!==

//三元操作符
let isSumEqualToTen = isEqual ? "YES" : "No"

2.6.5逻辑运算符

let logicalNot = !isEqual //非
let logicalAnd = isNotEqual && isLess //与
let logicalOR = isGreater || (isLess && isLe) //或

//??操作符  如果opt是一个optional,当其不为nil时，就是用optional变量自身的值，否则，就是用??后面的"默认值"

3、类型别名

类型别名是一个为已存在类型定义的可选择的名字
你可以私用关键字typealias定义一个类型的别名

typealias AudioSample = UInt8
let sample:AudioSample = 32