基本语法

• 声明常量（constants）用let，声明变量（variables）用var，声明函数（functions）用func。
  类型修饰采用后置语法：
  声明常量和变量时用冒号指示类型，自带初值时类型修饰可省略，其类型由编译器根据初值自行推导。
  声明函数时用箭头指示返回类型，有返回值时返回类型不可省略。
  

  	常量	变量	函数（有返回值）	函数（无返回值）
  Swift	let i = 10 let i: Int = 10	var i = 10 var i: Int = 10	func f(n: Int) -> Int {return n + 1}	func f(n: Int) -> () {} func f(n: Int) -> Void {} func f(n: Int) {}
  C#	const int i = 10; readonly int i = 10;	var i = 10; int i = 10;	int f(int n){return n + 1;} int f(int n) => n + 1;	void f(int n) {}
  C++	const auto i = 10; const int i = 10; constexpr auto i = 10; constexpr int i = 10;	auto i = 10; int i = 10;	int f(int n) {return n + 1;} auto f(int n) -> int {return n + 1;} auto f(int n) {return n + 1;}	void f(int n) {} auto f(int n) -> void {} auto f(int n) {}

• 字符串插值（string interpolation）的语法形式为 \(表达式)。

  	字符串插值
  Swift	let x = 10,y = 20 let s = "x=\(x),y=\(y)"
  C#	var x = 10,y = 20; var s = $"x={x},y={y}";

• 关于操作符，Swift语言中有一些新的操作符：封闭区间，半开区间以及身份比较操作符。另外，在Swift中，赋值运算符不返回值。
  

  	封闭区间	半开区间
  Swift	0...4	0..<4
  C#	Enumerable.Range(0,5)	Enumerable.Range(0,4)
  Java	IntStream.rangeClosed(0,4)	IntStream.range(0,4)

  	值比较	引用比较
  Swift	a == b	a === b
  C#	Object.Equals(a,b) a.Equals(b) a == b	Object.ReferenceEquals(a,b) a == b
  Java	a.equals(b)	a == b

• 数据结构方面，数组，字典以及元组有特殊语法。数组用中括号，字典用中括号加冒号，元组用小括号。

  	数组	字典	元组
  Swift	let a = [1,2,3] let a = [Int]()	let d = [1:"a",2:"b"] let d = [Int: String]()	let t = (1,"a")
  Python	a = [1,3] a = []	d = {1:"a",2:"b"} d = {}	t = (1,"a")

• 传统流程控制方面，表示分支的有if,guard和switch，
  表示循环的有for-in,for,while以及repeat-while，
  表示跳转的有continue,break,fallthrough,return和throw。

元组（Tuples）

• 元组是多个值的组合，是一种匿名的结构体。
• 元组类型本身没有名字，但是成员可以有名字。
• 元组的类型由成员的类型决定，成员的名字不影响元组的类型。
• 访问元组的成员可以通过模式匹配，也可以通过指定成员的序号或名字。
• 单一类型可以被视为只包含一个成员的元组。
• 不包含任何成员的元组类型记作 ()，其类型与Void同义。

// http404Error的类型是 (Int,String)
let http404Error = (404,"Not Found")
// 通过模式匹配来访问元组的成员
let (statusCode,statusMessage) = http404Error
let (justTheStatusCode,_) = http404Error
// 通过指定成员的序号来访问元组的成员
print("The status code is \(http404Error.0)")
// http200Status的类型编译期为 (statusCode: Int,description: String)，运行期为(Int,String)。
let http200Status = (statusCode: 200,description: "OK")
// 通过指定成员的名字来访问元组的成员
print("The status message is \(http200Status.description)")

可选值（Optionals）

• 可选值：一种可能没有值的可空类型，声明语法为 类型？，拆包（取出可选值中包含的值）语法为 可选值变量！。
• 隐式拆包可选值（implicitly unwrapped optionals）：一种假定总是有值的可空类型，声明语法为 类型！，引用可选值变量自动拆包，无需加！。
• 可选绑定（optional binding）：在if语句中强制拆包的语法形式。
• 可选链（optional chaining）：通过可选值调用其属性，方法的语法形式。

// 可选值
var possibleString: String?
let forcedString: String = possibleString!
if possibleString != nil {}
// 可选绑定
if let definiteString = possibleString {}
// 可选绑定 可选链
if let definiteString = possibleString?.lowercaseString {}
// 隐式拆包可选值
var assumedString: String! = "abc"
let implicitString: String = assumedString
if assumedString != nil {}
// 可选绑定
if let definiteString = assumedString {}

流程控制（Control Flow）

• for,while以及repeat-while（由do-while改名而来）循环继承自传统的C语言，for-in循环用于遍历序列。

  // 遍历区间
  for index in 1...5 {}
  for _ in 1..<3 {}
  // 遍历数组
  let names = ["Anna","Alex","Brian","Jack"]
  for name in names {}
  // 遍历字典
  let numberOfLegs = ["spider": 8,"ant": 6,"cat": 4]
  for (animalName,legCount) in numberOfLegs {}
  // 遍历字符串
  for ch in "Hello" {}
  // 传统计数循环
  for var index = 0; index < 3; ++index {}
  // 循环变量也可以在循环之前声明
  var index: Int
  for index = 0; index < 3; ++index {}
  

• if ... else if ... else结构继承自传统的C语言。
  guard ... else结构用于表达提前退出（early exit）这种惯用法（检测输入，如不符合要求提早退出函数）。
  Swift语言中的switch语句与传统C语言有很大不同：
  缺省情况下不掉入下一个case，可以同时指定多个值，可以匹配区间，可以对元组作模式匹配，也可以为值绑定添加条件过滤。

  // 提前退出
  func greet(person: [String: String]) {
      guard let name = person["name"] else {return}
  }
  

函数（Functions）

• 函数的参数有外部名（external name）和内部名（local name）。
  外部名如果存在（不为下划线时）调用方必须指定，内部名在函数内使用。
  语法形式为 func 函数名(外部名1 内部名1: 类型1,外部名2 内部名2: 类型2 ...)
  缺省形式为 func 函数名(内部名1: 类型1,外部名2兼内部名2: 类型2 ...)
  即第一个参数缺省无外部名，其余参数缺省外部名与内部名相同。

  	缺省形式	完整形式	最简形式
  被调用方	func f(la: Int,eb: Int){ la ... eb ... }	func f(ea la: Int,eb lb: Int){ la ... lb ... }	func f(la: Int,_ lb: Int){ la ... lb ... }
  调用方	f(1,eb: 2)	f(ea: 1,eb: 2)	f(1,2)

• 函数形参缺省为只读的in参数，即函数内部参数不可修改。
  可写的in形参须加上var修饰，此时函数内部参数可以修改，但修改对于调用方不可见，即参数传递方式为传值。
  inout形参加上inout修饰，此时函数内部对参数的修改对调用方可见，即参数传递方式为传引用。
  

  传值还是传引用	传值	传值	传引用	传引用
  关键字	只读in参数	（可读可写）in参数	out参数	inout参数
  Swift	无	var	／	inout
  C#	／	无	out	ref

• 函数的参数可以有缺省值。
• 函数是一等公民。可以作为函数的参数，也可以成为函数的返回值。

  	函数的类型（有返回值）	函数的类型（没有返回值）
  Swift	(Int,Int) -> Bool	(Int,Int) -> Void
  C#	Func<int,int,bool>	Action<int,int>
  C++	function<bool(int,int)>	function<void(int,int)>

• 函数可以嵌套。
• 变长参数。最多只能有一个。函数内部该参数被视为数组。

  	变长参数
  Swift	func avg(numbers: Double...) -> Double {}
  C#	double Avg(params double[] numbers) {}
  Java	double avg(double... numbers) {}

闭包（Closures）

let names = ["Chris","Ewa","Barry","Daniella"]
func backwards(s1: String,s2: String) -> Bool {
    return s1 > s2
}
// 把函数当作闭包
var reversed = names.sort(backwards)
// 闭包表达式（closure expressions）
reversed = names.sort({ (s1: String,s2: String) -> Bool in
    return s1 > s2
})
// 单行闭包
reversed = names.sort( { (s1: String,s2: String) -> Bool in return s1 > s2 } )
// 根据上下文推导参数和返回值的类型
reversed = names.sort( { s1,s2 in return s1 > s2 } )
// 单一表达式闭包
reversed = names.sort( { s1,s2 in s1 > s2 } )
// 缩写参数名
reversed = names.sort( { $0 > $1 } )
// 操作符函数
reversed = names.sort(>)
// 尾闭包（trailing closure）
reversed = names.sort() { $0 > $1 }