Swift基础语法（一）

本篇作为Swift的第一篇，主要简述Swift中的基础数据类型

变量和常量（Constants&Variables）

Swift中用let声明常量，常量在初次赋值后不能再被改变
Swift中用var声明常量，常量在初次赋值后可以被更改
语法
```
let pi: Double = 3.14159
var variableNumber: Int = 1_000__000
```
注：Swift中可以用下划线_分隔大数字，增加人类可读性，数量和位置随意。 下划线 _ 还有占位符的作用，代表忽略该项，后面会用到

类型转换（Type conversion）

将待转量用小括号括起来再在前面加上想要转成的类型即可：如 Int(doubleNumber)
Swift类型要求非常严格，将一个类型的值赋给另一个类型的变量时编译器会报错
同样，在两种不同类型的操作数做算数操作时，必须手动强制转换为同一类型变量，否则报错。这和C++的向高精度自动转换有区别
语法
```
var integer: Int = 100
var decimal: Double = 12.5
var sum = integer + Int(decimal)
```

元组（Tuples）

多个成组或多个相关的元素可以声明为元组

用.访问元组中的元素，如果没有指定索引值，则默认为从0开始的数字索引

语法

//默认索引值的元组，从0开始
let coordinates: (Double, Int) = (2.1, 3)
let x: Int = coordinates.0
let y: Int = coordinates.1

//定义索引值的元组
let coordinates3D: (x: Int, y: Int, z: Int) = (2, 3, 1)
let x: Int = coordinates3D.x
let y: Int = coordinates3D.y
let z: Int = coordinates3D.z
let (x, y, z) = coordinates3D  //同上三句

类型推导（Type inference）

Swift具有类型推导特性，在声明变量时可以省略类型声明，系统会自动判断变量的类型
在Xcode中按住option单击或三指点击未声明类型的变量可以查看系统推导的类型
语法
```
let typeInferredInt = 10
```

操作符（Operations）

Swift的算数操作符和其他语言相似：+ - * / % << >> += -=……
比较操作符：== != > < >= <=……
布尔类型（Bool）及逻辑操作符：&& || !

用小括号()设定操作优先级

语法

let add = 2 + 6
let subtract = 10 - 2
let multiply = 2 * 4
let divide = 24 / 3
let modulo = 11.6 % 1.2  //0.8  Swift可以对小数求余
let shiftLeft = 1 << 3   //位移操作将十进制数的二进制形式位移后再返回十进制结果

字符串（Strings）

Character类型存储单一字符，String类型用来存储一串字符
字面量（string literal）：用双引号括起来的字符
串接（Concatenation）：+ += 可以用来连接多个字符串
插入（Interpolation）：在字面量双引号中用\(插入内容)插入内容

== 符可以用作字符串判等，> < 用作字符串比较时依据字母表序位置先后判断结果

语法

let message: String = "Hello"
let exclamationMark: Character = "!"
let sentence = message + String(exclamationMark)  //"Hello!"

let name = "Qiao"
let sayHi = "Hello my name is \(name)!"

let guess = "dog"
let dogEqualsCat = guess == "cat"  //false
let order = "cat" < "dog"          //true

控制语句（Control flow）

if if - else if - else if - else
三元控制符：(<CONDITION>) ? <TRUE VALUE> : <FALSE VALUE>
switch <CONDITION> case: case: default:

模式匹配（pattern matching）：let-where 语法

语法

let number = 10
switch (number) {
  case let x where x % 2 == 0:
      print("Even")
  default:
      print("Odd")
 }

//部分匹配（partial matching）
let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)
switch (coordinates) {
  case (0, 0, 0): // 1
      print("Origin")
  case (_, 0, 0): // 2
      print("On the x-axis.")
  case (0, _, 0): // 3
      print("On the y-axis.")
  case (0, 0, _): // 4
      print("On the z-axis.")
  default:        // 5
      print("Somewhere in space")
 }

//保留对应值的部分匹配
let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)
switch (coordinates) {
  case (0, 0, 0):
      print("Origin")
  case (let x, 0, 0):
      print("On the x-axis at x = \(x)")
  case (0, let y, 0):
      print("On the y-axis at y = \(y)")
  case (0, 0, let z):
      print("On the z-axis at z = \(z)")
  case (let x, let y, let z):
      print("Somewhere in space at x = \(x), y = \(y), z = \(z)")
 }

let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)
switch (coordinates) {
  case (let x, let y, _) where y == x:
      print("Along the y = x line.")
  case (let x, let y, _) where y == x * x:
      print("Along the y = x^2 line.")
  default:
  break
 }

范围（Ranges）

闭区间（closed range）： ...

开区间（half-open range）： ..<

语法

let closedRange   = 0...5  //范围从0到5，包括5
let halfOpenRange = 0..<5  //范围从0到4，不包括5

循环（Loops）

for-in
while
repeat-while：类似于其他语言的do-while
用 break 退出循环， continue 继续下一次循环

标签语句（Labeled statements）：和 continue 配合使用，可以使程序跳到指定语句，类似C中的 goto

语法

//for循环
for <VARIABLE> in <RANGE> {
    <LOOP CODE>
}

//while循环
while <CONDITION> {
    <LOOP CODE>
}

//repeat-while循环
repeat {
    <LOOP CODE>
} while <CONDITION>

//标签语句
var sum = 0

rowLoop: for row in 0..<8 {
    columnLoop: for column in 0..<8 {
        if row == column {
            continue rowLoop
        }
        sum += row*column
    }
}

函数（Functions）

用 func 关键字声明函数
可以在第二个或后续参数标签前指明一个外部标签，在调用时可以使代码更为简洁
返回值用 -> 接在函数声明后面，可以返回元组
Swift的参数传递是值传递（pass-by-value），在传入参数前做一次拷贝，函数体内可以看成是let，内部改变不会影响外部，如果要用引用传参（pass-by-reference）需要在参数前加 inout 关键字，声明为引用传参的函数在调用时参数前要加 &,以指明这是引用方式

函数可以作为变量传递声明时类似于 var function: (Int, Int) -> Int

语法

func 函数名(第一个参数标签: 参数类型, 指定的参数外部标签 参数标签: 参数类型 = 参数默认值) -> 函数返回值  {
    函数体
    return 返回值
}

闭包（Closures）

可以理解为匿名函数

闭包可以“捕获”作用域内的变量，任何对其改变都会在闭包内外收到影响

语法

//闭包声明
var multiplyClosure: (Int, Int) -> Int  //和函数类型的变量基本一致
//闭包赋值
multiplyClosure = { (a: Int, b: Int) -> Int in
    return a * b
}
//闭包使用
let result = multiplyClosure(4, 2)      //result=8

//闭包简化语法
//如果只有一句表达式，可以省略return
//利用类型推倒机制，在已经声明过的前提下可以省略返回类型和参数类型
//参数列表：参数可以用从0开始的序列引用
multiplyClosure = {
    $0 * $1
}

//尾闭包语法（trailing closure syntax）
//当一个闭包作为函数的最后一个参数时, 尾闭包可以化简代码
//原来
operateOnNumber(4, 2, operation: {
    $0 + $1
})
//尾闭包
operateOnNumber(4, 2) {
    $0 + $1
})

可选类型（Optional）

Nil代表空（absence of value）
很多语言用哨兵值（Sentinel values）代表空值，例如0代表没有，但是容易引起歧义，对于这个0 不同人有不同理解，因此Swift引入和Optionals类型
Optional可以被类比为一个盒子，它可以包含一个值，也可以为空，用 ? 声明：var errorCode: Int?
Optional强制拆包（force unwrapping）：用 ! 跟在可选类型变量后。一般不推荐这种做法，强制拆包会，如果值为空，可能会引起运行时crash
if let binding：这种方式较为安全的存取Optional

nil coalescing：当拆包一个Optional为nil时，用 ?? 指定默认值

语法

//一次拆包多个值
let authorName: String? = "Qiao"
let authorAge: Int? = 30
if let name: String = authorName,
        age: Int = authorAge {
          print("The author is \(name) who is \(age) years old.")
     } else {
          print("No author or no age.")
}

//nil coalescing
var result: Int = optionalInt ?? 0

Written on April 22nd , 2016 by 乔黎博

Feel free to share!