上一篇：造物之初
当前篇：基础运算
下一篇：控制流

运算符

运算符是用来表示某个运算的特殊符号，在数学中用 +，-，×，÷ 来表示四则运算，而在编程中，我们用 +，-，*，/ 来表示四则运算

运算符分为一元运算符，二元运算符，三元运算符

• 一元运算符操作单一对象，例如 -a 表示取 a 的相反数，!a 表示 a 的逆值（Bool 类型才有逆值）

• 二元运算符操作两个对象，它位于两个操作对象之间，例如 2 + 3，四则运算都是二元运算符

• 三元运算符操作三个对象，Swift只有一个三元运算，那就是 （a ? b : c），这样的运算叫做三目运算或者条件运算，它的意思就是：如果 a 为 true，那么就取 b ，否则取 c

Swift 中一个符号在不同的情况下可能表示不同的意义，比如 - 号可以表示一元运算的相反数，也可以表示二元运算的减，我们会在后面看到 ? 和 ! 在不同的情况下也有不同的意义

赋值运算

我们接触的第一个运算符就是赋值运算符 =

let b: Int = 10
var a: Int = 5
a = b
// a 现在等于 10

程序员经常会在代码中写上一下注释方便阅读，双斜杠就是一种注释，注释不会被编译，仅仅用来阅读，常见的注释还有 ///注释 和 /** 注释*/

算术运算

四则运算我们已经了解了，还有一个求余运算符 % （这里不是百分号的意思）

let a: Int = 9 % 4   //a等于1
let b: Int = -9 % 4  //b等于-1

let a: Int = 5
let b: Int = 2
let c = b / a    //c等于2

在计算机中，5 / 2 并不等于 2.5 ，因为计算机严格地按照类型来赋值，四则运算中只允许出现相同类型的数值，a 和 b 都是 Int ，计算结果自然也是 Int ，既然是 Int ，那么 2.5 的小数就没了，如果我们想要得到准确的值，需要使用类型转换

let a: Int = 5
let b: Int = 2
let c = Double(b) / Double(a)    //c等于2.5

使用 Double 类型进行运算，得到的结果是 Double型，这样才能保证得到准确结果，请注意一定不要写成下面这样

let a: Int = 5
let b: Int = 2
let c = Double(b / a)    //c等于2.0

这样写的意思就变成了，b / a 得到整数 2 ，让将结果 2 转换为 Double 类型，就是 2.0 了

所以在做四则运算的时候一定要注意类型转换，至于怎么转换，要看我们需要精确的结果还是粗略的结果

组合赋值运算

如果我们要把运算结果赋值给自己，可以按常规方式这样写

var a: Int = 2  //声明一个变量a，并给a初始值为2
a = a + 1  //用a的值加1，得到的结果赋值给a，现在a的值是3

这里需要跟我们平常的思维区别开来，a + 1 不是指 a 的值加1，a就等于2了，a + 1 仅仅表示用 a 的值和 1 进行加法运算，我们需要把这个运算结果赋给一个变量或常量才有意义

下面我们用更加简洁的组合赋值运算符来表示

var a: Int = 2  //声明一个变量a，并给a初始值为2
a += 1     //a更新为a本身的值加1，现在a等于3
a -= 1     //a更新为a本身的值减1，现在a又等于2
a *= 2     //a等于a乘以2，现在是4
a /= 2     //a等于a除以2，现在是2

比较运算

• 等于（a == b）
• 不等于（a != b）
• 大于（a > b）
• 小于（a < b）
• 大于等于（a >= b）
• 小于等于（a <= b）

比较运算符的结果为 Bool 类型

在计算机中，= 表示赋值，== 表示比较

条件语句

比较运算多用于条件语句 if else，属于控制流的知识，详细内容在下一节课中学习，这里先提一个

let todayIsSingleDay = true
if todayIsSingleDay {
    //单号开保时捷
    print("Drive Porsche")
} else {
    //双号开玛莎拉蒂
    print("Drive Maserati")
}

如果 if 之后的条件成立，就执行之后的大括号中的代码，不成立则执行 else 之后的大括号中的代码

我们又认识了一个新的符号 {} ，大括号也是今后我们用的最多的符号之一，它表示 域 的意思

//假设最外层是域0
let todayIsSingleDay = true
if todayIsSingleDay {
    //假设这里是域1
    let car = "Porsche"
    print("Drive \(car)")
} else {
    //假设这里是域2
    //在域2中并没有找到car的定义，编译失败
    print("Drive \(car)")
}

//假设最外层是域0
let todayIsSingleDay = true
let car = "Maserati"
if todayIsSingleDay {
    //假设这里是域1
    let car = "Porsche"
    print("Drive \(car)")//在域1中找到了car的定义，因此这里的car表示"Poreshe"
} else {
    //假设这里是域2
    print("Drive \(car)")//在域2中没有找到了car的定义，但是在外层的域0中找到了car，因此这里的car表示"Maserati"
}

程序按照自下而上的优先原则寻找某个标识，先使用本域中的定义，本域中没有，就使用父域中的定义，父域中没有，就使用爷爷域中的定义，这样一直往上寻找，如果一直找不到定义，就无法通过编译

当程序越来越复杂后，我们的代码会被一块一块的拆分开，就可能会存在命名冲突，就像一个学校如果人多了自然会有重名的，如果你在教室里叫小明，肯定是优先指向本班的小明，如果本班没有小明，那就会指向年级的小明，年级没有小明，就自然指向学校的小明

逻辑运算

也就是我们数学里的 与或非 逻辑，只不过运算符不一样， a && b 表示逻辑与， a || b 表示逻辑或，!a 表示逻辑非，它们可以单个使用，也可以组合使用，逻辑非优先级最高，逻辑与和逻辑或优先级相同，在组合运算中，优先级高的优先计算，优先级相同的按左右顺序依次计算

let beautiful = true
let smart = true
let warmHearted = true
if beautiful && smart && warmHearted {
    //三个条件都满足，你就是完美的人
    print("You are perfect")
}

let hasCar = true
let hasHouse = false
let hasYan = false
//有房有车或者有颜值
let hasWife = hasCar && hasHouse || hasYan

为了方便理解，我们可以在组合运算中加上括号

let hasCar = true
let hasHouse = false
let hasYan = false
//有房有车或者有颜值，这里的括号并不改变优先级，只是方便了理解
let hasWife = (hasCar && hasHouse) || hasYan

如果需要调整运算优先级，就必须加括号

let hasCar = true
let hasHouse = false
let hasYan = false
//有车并且有房或者有颜值
let hasWife = hasCar && (hasHouse || hasYan)

自动类型推断

有没有发现我们的代码写着写着就少了一个东西，我们声明常量变量时把类型声明省略掉了，这是一种省略写法，如果我们直接在声明语句中赋值，可以不写类型声明，编译器会帮我们判断类型

let a = 1       // a 推断为 Int 类型
let b = 3.14    // b 推断为 Double 类型
let c = true    // c 推断为 Bool 类型
let d = "abc"   // d 推断为 String 类型

上一篇：造物之初
当前篇：基础运算
下一篇：控制流