同：
一、基础
同：
1常量和变量
2数据类型和数据类型转换
3别名
不同：
1可选类型optional
2BOOL类型
3元组类型
4断言Assertion
二、基本操作符
同：
1赋值和算术运算及取余
2自增自减
3比较运算和三元条件
4逻辑运算符
不同：
1闭区间和半开区间 ...和..<
2选并操作符 a??b
三、字符和字符串
四、集合类型
NSArray和NSDictionary
五、控制流
for in 循环
for 循环
switch case
if
while 和 do while
不同：
where关键字是为了进行帅选。。。
例子：
/* 蛇棋 */
let 总棋格 = 25
var 棋盘 = [Int](count: 总棋格 + 1,repeatedValue: 0)
var 当前棋格 = 0
var 色子 = 0
// 云梯 前进步数
棋盘[03] = +08
棋盘[06] = +11
棋盘[09] = +09
棋盘[10] = +02
//蛇
棋盘[14] = -10
棋盘[19] = -11
棋盘[22] = -02
棋盘[24] = -08
while (当前棋格 < 总棋格 ){
//
if (++色子 == 7){
色子 = 1
}
print("色子现在是\(色子)")
当前棋格 += 色子
if(当前棋格 < 棋盘.count){
var 前进步数 = 棋盘[当前棋格]
当前棋格 += 前进步数
if 前进步数 > 0{
print("恭喜遇到云梯，前进\(前进步数)步")
}else if (前进步数 < 0){
print("倒霉遇到蛇头，倒退\(-前进步数)步")
}
}
}
print("Game over")
转移控制语句：continue；break；fallthrough;return
continue：结束上一个循环，继续下一个循环。用在while循环中；break，既可以用在while循环中，也可以用在switch中。
fallthrough:switch语句默认是遇到case,就跳出这个语句。但是我如果遇到一个case匹配，想继续执行下一语句，这时候就使用fallthrough；
六、函数（OC管函数叫方法）
a 定义和调用
func treat(xiaobo: String) -> String{ //函数定义,1个参数
let hello = "欢迎你！\(xiaobo)"
return hello
}
print("treat(小波，欢迎你)") //调用
b形式参数与返回值（多参和无参）
func legth(start:Int, end:Int) -> Int{ //多参
return end - start
}
print(legth(1, end: 100))
//----------------------------
func haha() -> String{ //无参
return "小波是大帅哥"
}
print(haha())
c 形式参数与返回值（无返回值）return +不调用定义的。
d 形式参数与返回值（多返回值）
func 取极值(整数组:[Int]) -> (Int,Int){ //多返回值
var 最大值 = 整数组[0]
var 最小值 = 整数组[0]
for 组员 in 整数组[1..<整数组.count] {
if 组员 > 最大值 {
最大值 = 组员
}else if 组员 < 最小值 {
最小值 = 组员
}
}
return (最大值,最小值)
}
let (max,min) = 取极值([-20,343,99824,-2345,11,88])
max
min
e 形式参数与返回值（可选元组返回）
func 取极值(整数组:[Int]) -> (max :Int, min :Int)?{ //可选元组返回
if 整数组.isEmpty { //对空值进行一个判断
return nil
}
var 最大值 = 整数组[0]
var 最小值 = 整数组[0]
for 组员 in 整数组[1..<整数组.count] {
if 组员 > 最大值 {
最大值 = 组员
}else if 组员 < 最小值 {
最小值 = 组员
}
}
return (最大值,最小值)
}
if let 临时整数组 = 取极值([-20,0,343,99824,-2345,11,88]){
print("最大值是\(临时整数组.max),最小值是\(临时整数组.min)")
}
f本地参数和外部参数，参数默认值
g 可变参数 var
h变量参数 就是在定义函数的时候加上var,把参数变为可变参数，只能在函数体中的变量
I In-Out参数，改变函数体以外的变量
var a = 3
var b = -100
func 交换值( inout a:Int, inout b:Int){
let 临时值 = a
a = b
b = 临时值
}
交换值(&a, b: &b)
J函数类型(参数和返回值组成)
func printHell0（）{ //没有返回值，没有参数
}
func printHell0（a:Int, b: Int）->Int{//返回值整型，参数整型
return a + b
}
K 函数类型作为常量和变量
func 两个数相加（a:Int, b: Int）->Int{//返回值整型，参数整型
return a + b
}
var 临时 = 两个数相加
print （“\(临时(2,5))”）
L函数类型作为参数
func 相乘函数（a:Int, b: Int）->Int{//返回值整型，参数整型
return a * b
}
func 显示相乘结果(a:Int, b: Int,相乘函数：(Int,Int)->Int){
let 结果 = 相乘函数（a,b）
print...
}
显示相乘结果(2,5,相乘函数相乘函数相乘函数 相乘函数xxxxjdbdsbvcsdbcksb)
M函数类型作为返回类型，当做另外一个函数的返回类型:两个箭头代表一个函数是另外一个函数的返回类型
N嵌套函数 把一个函数放在一个大的函数里面，就是嵌套函数。
总结：函数：全局函数和嵌套函数，函数也是闭包，即是一种特殊形式的闭包。
七、闭包（OC没有闭包的概念）即一个代码块
1定义和表现形式
概念：无名无姓，能捕获的一个表达式、
写法言简意赅
2sorted函数
let 城市 = ["Beijing","New york","Paris","Shenzhen","Shanghai"]
func 字母靠后(字符串1: String, 字符串2: String) -> Bool {
return 字符串1 > 字符串2
}
var 新城市 = sorted(城市,字母靠后)
3闭包表达式语法和单行间接返回
let 城市 = ["Beijing","New york","Paris","Shenzhen","Shanghai"]
func 字母靠后(字符串1: String, 字符串2: String) -> Bool {
return 字符串1 > 字符串2
}
var 新城市 = sorted(城市,{(字符串1,字符串1)-> Bool in
return 字符串1 > 字符串2})
//单行间接返回
let 城市 = ["Beijing","New york","Paris","Shenzhen","Shanghai"]
func 字母靠后(字符串1: String, 字符串2: String) -> Bool {
return 字符串1 > 字符串2
}
var 新城市 = sorted(城市,{(字符串1,字符串1)-> Bool in 字符串1 > 字符串2})
4操作符函数：更简洁，简化
let 城市 = ["Beijing","New york","Paris","Shenzhen","Shanghai"]
func 字母靠后(字符串1: String, 字符串2: String) -> Bool {
return 字符串1 > 字符串2
}
var 新城市 = sorted(城市,>)
5挂尾闭包
把闭包整体移动到函数尾巴去，就叫挂尾闭包。
6值捕获
闭包可以捕获。累加器的例子。
八、枚举
1定义和语法
enum 方向 {
case 东
case 南
case 西
case 北
}
var 穷游之歌 = 方向.东
穷游之歌 = .北
2switch语句匹配
3 关联值
4原始值