swift语言从刚刚出道时火的不行，到现在逐渐的热度消退。作为Apple官方主推的一种新的编程语言，自从Open Source以来，吸引了一大批牛人投入到开源社区进行讨论。虽然平时在使用swift语言，但是对其很多语言的细节还是不够清晰。同时swift3.0也即将发布，顿时感觉需要对其语法进行重新梳理，整理好这门语言的来龙去脉。放松心情，迎接swift3.0的到来。
本文主要是基于swift2.0版本语法的整理。锻炼自己表达能力，同时记录下自己学习的过程，以备自己复习查询。

hello swift

打印
print("hello swift")

常量和变量

• 常量

let num1: Int = 20
let num2 = 20

• 变量

var num2: Int = 20
var num3 = 20

命名规则：常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符。也不能以数字开头，但是可以在常量与变量名的其他地方包含数字。

当你声明常量或者变量的时候可以加上类型标注(type annotation),说明常量或者变量中要存储的值的类型。如果要添加类型标注,需要在常量或者变量名后面加上一个冒号和空格,然后加上类型名称。

var num: Int
num = 10```

#####枚举
+ 定义枚举
写法1

enum num{
case one, two, three
}

写法2

enum num{
case one,
case two,
case three
}

写法3：定义枚举同时定义类型，默认是整形,后面的值+1。

enum height:Double{
case one = 2.0,
case one = 3.0,
case one = 4.0
}

+ 定义枚举变量

var number1 = num.one
或者
var number2: num = one

当然定义也可以使用常量let
```let number2: num = one```

+ 枚举原始值
print(num.one.rawValue)

#####元组
元组(tuples)把多个值组合成一个复合值。元组内的值可以是任意类型,并不要求是相同类型。

let student = ("小明", 20, 99.0)

取得元组的第一个值

print(student.0)

其他定义方式

let student2 = (name:"小明",age:20,score:99.0)
let (name , age , score) = ("小明", 20, 99.0)
let (name1 , age1 , ) = ("小明", 20, 99.0)//不关心元组中某一个值，可以使用通配符来忽略

#####集合类型：数组，字典，集合

swift中提供数组，字典和集合三种基本的集合类型来存储集合数据。
   > 数组是有序有重复集合
        字典是无序键值对集
        集合是无序无重复的集合
![](http://upload-images.jianshu.io/upload_images/1101711-1aef8e9ccfd6d30b.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

+ 数组（Arrays）

var arr = [1,2,3]
var arr1:Array = [1,2,3]
var arr2:Array<Int> = [1,2,3]
var arr3:[Int] = [1,2,3]
//空数组
var arrEmpty =[]
var arrEmpty1:Array =[]
var arrEmpty2:Array<Int> =[]
var arrEmpty3:[Int] =[]

//不可变数组:
var arr8 = []
//可变数组:
let arr9 = []

// 如果想明确表示数组中存放的是不同类型的数据, 可以使用Any关键字, 表示数组中可以存放不同类型的数据
var arr11:Array<Any> = [1, "lnj", 1.75]

// 数组遍历
var arr1 = [1, 2, 3]
for var i = 0 ; i < arr1.count ; i++
{
print(arr1[i])
}

for number in arr1
{
print(number)
}

for i in 0..<arr1.count
{
print(arr1[i])
}

// 取出数组中某个区间范围的值
var arr2 = [1, 2, 3]
for number in arr2[0..<3]
{
print(number)
}

+ 字典（Dictionarys）

var dict = ["name":"zz", "age":20]
var dict1:Dictionary = ["name":"zz", "age":20]
var dict2:Dictionary<String,AnyObject> = ["name":"zz", "age":20]
var dict3:[String:AnyObject] = ["name":"zz", "age":20]
var dict4:[String:AnyObject] = Dictionary(dictionaryLiteral: ("name", "zz"), ("age", 20))

//不可变数组:
var dict5 = [:]
//可变数组:
let dict6 = [:]

//遍历字典
var dict7 = ["name":"zz", "age":20]
for (key , value) in dict7
{
print("key = (key) value = (value)")
}

var dict8 = ["name":"zz", "age":20]
for key in dict8.keys
{
print("key = (key)")
}

var dict9 = ["name":"zz", "age":20]
for value in dict9.values
{
print("value = (value)")
}

+ 集合（Sets）
当对元素的顺序不太关注或者需要所有的元素只出现一次的时候可以使用集合

//var sess = ["name", "zz", "age","age",2]
//sess的定义是数组的定义
var sess1:Set = ["name", "zz", "age","age",2]
//sess1的定义是使用数组来定义一个set，其中重复的元素会只显示一个,自动忽略其他重复的元素。
var sess2:Set<String> = ["name", "zz", "age","age"]
//sess2的定义是使用数组来定义一个set，其中重复的元素会只显示一个，指定元素为String类型，添加其他类型元素会直接报错。

// 遍历set
for genre in sess1 {
print("(genre)")
}

let sess2:Set = ["name", "zz", "age"]
for genre in sess2.sort() {
print("(genre)")
}
//在sess2中如果中添加了其他了类型的元素，比如整形2。则sort() 方法就不能被调用。
//只能使用sort(isOrderedBefore: (String, String) -> Bool) 方法根据传递的参数自定义排序
//sort() 方法的默认的排序按照字母a_z，数组09,
//如果包含中文此时排序基本没有意义。测试代码
let sess3: Set = ["张三", "李四", "王五", "a小李","三", "四", "五", "小","小李子"]
for genre in sess3.sort() {
print("(genre)")
}
结果：a小李 三 五 四 小 小李子 张三 李四 王五。

//其他排序方法
let constantArray: Set = [5, 1, 6, 4, 2, 3]
let bbbb = constantArray.sort{$0>$1}
print(bbbb)

let constantArray1: Set = [5, 1, 6, 4, 2, 3]
let bbbb1 = constantArray1.sort(>)
print(bbbb1)

let constantArray2: Set = [5, 1, 6, 4, 2, 3]
let bbbb2 = constantArray2.sort { (a, b) -> Bool in
return a > b
}
print(bbbb2)

**set之间的交并集**
![](http://upload-images.jianshu.io/upload_images/1101711-627623e430c9e8d7.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1000)

intersect：返回两个集合中都存在的数据
exclusiveror：返回两个集合各自特有的数据，忽略两个集合中都有的数据
union：返回两个集合中所有数据
subtract：返回不包含右边集合的所有数据
4个方法都把合适数据组织成一个新的集合进行返回。
 
**set之间的比较**
- 使用“是否相等”运算符( == )来判断两个集合是否包含全部相同的值。
    (判断set元素相等还可以使用哈希值，swift中所有的基本数据类型都是可以hash的，哈希值相等可以判断对象相同，如a == b
即a.hashValue == b.hashValue)
- 使用 isSubsetOf(_:) 方法来判断一个集合中的值是否也被包含在另外一个集合中。
- 使用 isSupersetOf(_:) 方法来判断一个集合中包含另一个集合中所有的值。
- 使用 isStrictSubsetOf(_:) 或者 isStrictSupersetOf(_:) 方法来判断一个集合是否是另外一个集合的子集合或者父集合并且两个集合并不相等。
- 使用 isDisjointWith(_:) 方法来判断两个集合是否不含有相同的值。
            let a: Set = ["a", "b", "c", "d", "e"]
            let b: Set = ["a", "b"]
            let c: Set = ["a", "b", "c", "d", "e","f"]
        
            print(b.isSubsetOf(a)) // b是否包含在a中 true
            print(a == b) // a和b是否相等 false
            print(a.isSupersetOf(b)) // a是否包含b所有的值 true
            print(a.isDisjointWith(c))// a和c是否含有不相同的值 false

#####5.字符和字符串
字符和字符串都使用 **“”** 双引号来定义

+字符

var test:Character = "李"
// 双引号中只能有一个字符，不如想“ab”这样定义是错误的。

+字符串
字符是单个字符的集合, 字符串是多个字符的集合, 想要存放多个字符需要使用字符串,使用双引号和+可以拼接字符串

var a = "ab"
var b = "bc"
var str = a + b;
print(str)// abbc

#####运算符
| 运算符 |例|
|--|--|
| 基本运算||
|+| a+b  |
|- | a-b  |
|* | a*b  |
|/ | a/b  |
|++|  number++ |
|-- |  number--   |
| % | print(10 % 3.5)  余数为3 支持对小数取模  |
| 赋值运算 | 不允许连续赋值, 表达式是没有值的. 避免 if (c == 9) 这种情况误写为 if (c = 9)|
| =  |m1 =  20|
| += |m1 += 10|
| -= |m1 -= 10|
| /= |m1 /= 10|
| *= |m1 *= 10|
| %= |m1 %= 5|
| 关系运算|取得值是bool|
|>|m1  > 10|
|<|m1 < 10|
|>= |m1 >= 10|
|<=|m1 <= 10|
|== |m1 == 10|
|!=|m1 != 10|
|?:|m1 == 10 ? 11 : 12 |
| 逻辑运算|只能操作bool类型|
|!    | if !open  |
|&& | if a >10 &&  a < 20 |
| 区间||
|... | 1...5    （1到5包括5 ）|
|..<| 1..<5 （1到4不包括5）|

######\- 和 + 
特殊的关于正负数运算的运算符

let three = 3
let minusThree = -three // minusThree 等于 -3
let plusThree = -minusThree // plusThree 等于 3, 或 "负负3”

######?? 空和运算符
??运算符：(a??b)如果a值不为空，则对a进行强制解包，否则就返回一个默认值b。
运算符有两个条件
  + 1 表达式a必须是一个可选值类型。
  + 2 默认值b的类型必须和a的类型保持一致

let mycolor = "red"
var userDefualColor:String?
var usercolor = userDefualColor?? mycolor

返回结果为red，因为userDefualColor是一个可选值，其的默认值是空。所以返回mycolor 即red。

######溢出运算符
Swift中如果计算结果超出了它的类型能承载的范围，那么就会发生溢出错误，除非你已经使用溢出运算符来进行操作：
溢出加法 &+
溢出减法 &-
溢出乘法 &*
溢出除法 &/
溢出求余 &%

#####可选值
可选值: optionals有两种状态: 
1.有值 2.没有值, 没有值就是nil

//有值
var optionalTest:Int? = 9
//没有值
var optionalTest:Int?
var optionalTest:Int? = nil

// 可选值强制解包，对一个没有值的可选值强制解包会报错。
var result = optionalTest！

// 可选绑定
if let result = optionalTest {
// do something
}

#####注释
以c语言注释非常像

// 这是一个注释

/* 这是一个,多行注释 */

和c语言不一样，swift多行注释可以嵌套

/* 这是第一个多行注释的开头
/* 这是第二个被嵌套的多行注释 */
这是第一个多行注释的结尾 */

#####分号
和大部分的语言不同，在swift语言中并不强调每一行的结束都添加分号**```;```**
当然你也可以添加分号作为一行结束符号,在swift语言也是可以的。
有一种必须添加分号的情况，就是在一行中你想写多个语句。比如

var me1 = 2; var me2 = 4

#####基本数据类型
######整数类型

var intValue1:Int8 = 6
var intValue2:Int16 = 7
var intValue3:Int32 = 8
var intValue4:Int64 = 9

+ Swift 提供了8,16,32和64位的有符号和无符号整数类型。这种按照长度进行划分，更加精确，也更节省内存空间。
+ 默认情况下数据类型分为有符号的和无符号的，也就是说有符号的Int8的范围是（-128 ~ 127）,无符号的UInt8的范围是（0 ~ 255）如果超出了范围编译器会报错误。
+ swift为我们提供了特殊类型Int，它与当前平台的原生字长度相同。
   - 在32位平台上, Int和Int32长度相同。 
   - 在64位平台上, Int和Int64长度相同。
当然也有无符号的特殊类型UInt，和Int一样它也是与当前平台的原生字长度相同。

######浮点类型
Double:表示64位浮点数，精度高，存储数据大，至少有15位
Float:表示32位浮点数，至少有6位

#####类型转换
swift中不允许隐式类型转换，必须使用强制类型转换

/*
var intValue:Int = 10
var doubleValue:Double = intValue
*/
以上语句会报错。
正确写法
var intValue:Int = 10
var doubleValue:Double
doubleValue = Double(intValue)

注意：Double(intValue)并不会修改intValue的值, 而是通过intValue的值生成一个临时的值赋值给doubleValue

#####Bool类型
Swift引入了真正的Bool类型

true
false

#####类型推断
swift是类型安全的。可以清楚的知道代码要处理值的类型，在编译的时候会进行类型检查，如果传递的参数类型不一致，会提示错误。
尽管如此，我们在声明常量或者变量的时候不一定需要显示的指定类型。如果我们没有指定类型，swift会使用类型推断来选择合适的类型。

let anotherPi = 3 + 0.14159
// anotherPi 会被推测为 Double 类型,因为出现了浮点数类型

#####类型别名
typealias AudioSample = UInt16
将UInt16定义别名为AudioSample，然后就可以在任何使用UInt16的地方使用新定义的别名。

#####控制语句
+ if
和常用用法一致

+ switch
switch可以匹配区间和元祖

let count = 3_000_000_000_000
let countedThings = "stars in the Milky Way"
var naturalCount: String
switch count {
case 0:
naturalCount = "no"
case 1...3:
naturalCount = "a few"
case 4...9:
naturalCount = "several"
case 10...99:
naturalCount = "tens of"
case 100...999:
naturalCount = "hundreds of"
case 1000...999_999:
naturalCount = "thousands of"
default:
naturalCount = "millions and millions of"
}
print("There are (naturalCount) (countedThings).")
// 输出 "There are millions and millions of stars in the Milky Way.”

“let somePoint = (1, 1)
switch somePoint {
case (0, 0):
print("(0, 0) is at the origin")
case (_, 0):
print("((somePoint.0), 0) is on the x-axis")
case (0, _):
print("(0, (somePoint.1)) is on the y-axis")
case (-2...2, -2...2):
print("((somePoint.0), (somePoint.1)) is inside the box")
default:
print("0")
// _ 代表可以匹配任何值

+ for
除了常用的for循环样式，for还可以用来循环字符串的字符，元祖和区间

let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
for (animalName, legCount) in numberOfLegs {
print("(animalName)s have (legCount) legs")
}
// spiders have 8 legs
// ants have 6 legs
// cats have 4 legs

for character in "hello"{
print(character)
}

+ while 和repeat while

var a :Int = 1
while a < 10
{
a++
}

repeat
{
a++
}while a < 10

#####函数