标签：
原创： 转载请注明出处
Extention
try catch
rxSwift
internal public private
var let
as as? 强转
? !
didSet
#selector
var myLabel : UILable ? //声明全局变量myLabel
基础部分
1.可选类型
2.if 语句以及强制解析
3.隐式解析可选类型
4.错误处理 添加throws关键词来抛出错误消息
5.使用断言进行调试 let age = -3
assert(age >= 0, "A person‘s age cannot be less than zero")
基本运算符
6.空合运算符（Nil Coalescing Operator） a ?? b —>> a != nil ? a! : b
7.闭区间运算符
8.逻辑运算符组合计算 加括号更清晰
9.字符串是值类型（Strings Are Value Types）
10.使用字符（Working with Characters） let catCharacters: [Character] = ["C", "a", "t", "!", "??"]
11.连接字符串和字符 (Concatenating Strings and Characters) —->> +
12.字符串插值 (String Interpolation)
13.字符串字面量的特殊字符 (Special Characters in String Literals)
转义字符\0(空字符)、\\(反斜线)、\t(水平制表符)、\n(换行符)、\r(回车符)、\"(双引号)、\‘(单引号)。
14.字符串索引 (String Indices)
15.数组（Arrays）是有序数据的集。集合（Sets）是无序无重复数据的集。字典（Dictionaries）是无序的键值对的集。
16.访问和修改数组 shoppingList[4...6] = ["Bananas", "Apples"]
17.遍历：同时需要每个数据项的值和索引值，可以使用enumerate()方法来进行数组遍历
集合（Sets）
集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。
注意：
Swift的Set类型被桥接到Foundation中的NSSet类。
18.集合类型语法
Swift 中的Set类型被写为Set<Element>，这里的Element表示Set中允许存储的类型，和数组不同的是，集合没有等价的简化形式。
19.创建和构造一个空的集合 var letters = Set<Character>()
20.用数组字面量创建集合 var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
21.创建一个空字典 var namesOfIntegers = [Int: String]()
22.namesOfIntegers[16] = "sixteen"
// namesOfIntegers 现在包含一个键值对
namesOfIntegers = [:]
// namesOfIntegers 又成为了一个 [Int: String] 类型的空字典
如果上下文已经提供了类型信息，我们可以使用空字典字面量来创建一个空字典，记作[:]（中括号中放一个冒号）：
23.用字典字面量创建字典 var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
24.访问和修改字典 在字典中使用下标语法来添加新的数据项 airports["LHR"] = "London"
25.While 循环
元组（Tuple）
我们可以使用元组在同一个switch语句中测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线（_）来匹配所有可能的值。
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("(\(somePoint.0), \(somePoint.1)) is outside of the box")
}
// 输出 "(1, 1) is inside the box"
Where
case 分支的模式可以使用where语句来判断额外的条件。
26.控制转移语句（Control Transfer Statements）
控制转移语句改变你代码的执行顺序，通过它你可以实现代码的跳转。Swift 有五种控制转移语句：
27.带标签的语句
提前退出
像if语句一样，guard的执行取决于一个表达式的布尔值。我们可以使用guard语句来要求条件必须为真时，以执行guard语句后的代码。不同于if语句，一个guard语句总是有一个else分句，如果条件不为真则执行else分句中的代码。
func greet(person: [String: String]) {
guard let name = person["name"] else {
return
}
print("Hello \(name)")
guard let location = person["location"] else {
print("I hope the weather is nice near you.")
return
}
print("I hope the weather is nice in \(location).")
}
greet(["name": "John"])
// 输出 "Hello John!"
// 输出 "I hope the weather is nice near you."
greet(["name": "Jane", "location": "Cupertino"])
// 输出 "Hello Jane!"
// 输出 "I hope the weather is nice in Cupertino."
28.函数（Functions）
无返回值函数（Functions Without Return Values）
严格上来说，虽然没有返回值被定义，sayGoodbye(_:) 函数依然返回了值。没有定义返回类型的函数会返回特殊的值，叫 Void。它其实是一个空的元组（tuple），没有任何元素，可以写成()。
29.多重返回值函数（Functions with Multiple Return Values）
你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。
30.可选元组返回类型(Optional Tuple Return Types)
如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的（Optional） 元组返回类型反映整个元组可以是nil的事实。你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如(Int, Int)?或(String, Int, Bool)?
func minMax(array: [Int]) -> (min: Int, max: Int)? {
if array.isEmpty { return nil }
var currentMin = array[0]
var currentMax = array[0]
for value in array[1..<array.count] {
if value < currentMin {
currentMin = value
} else if value > currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
31.函数参数名称（Function Parameter Names）
一般情况下，第一个参数省略其外部参数名，第二个以及随后的参数使用其局部参数名作为外部参数名。所有参数必须有独一无二的局部参数名。尽管多个参数可以有相同的外部参数名，但不同的外部参数名能让你的代码更有可读性。
32.指定外部参数名（Specifying External Parameter Names）
你可以在局部参数名前指定外部参数名，中间以空格分隔：
func someFunction(externalParameterName localParameterName: Int) {
// function body goes here, and can use localParameterName
// to refer to the argument value for that parameter
}
注意
如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。
这个版本的sayHello(_:)函数，接收两个人的名字，会同时返回对他俩的问候：
func sayHello(to person: String, and anotherPerson: String) -> String {
return "Hello \(person) and \(anotherPerson)!"
}
print(sayHello(to: "Bill", and: "Ted"))
// prints "Hello Bill and Ted!"
为每个参数指定外部参数名后，在你调用sayHello(to:and:)函数时两个外部参数名都必须写出来。
使用外部函数名可以使函数以一种更富有表达性的类似句子的方式调用，并使函数体意图清晰，更具可读性。
33.忽略外部参数名（Omitting External Parameter Names）
如果你不想为第二个及后续的参数设置外部参数名，用一个下划线（_）代替一个明确的参数名。
func someFunction(firstParameterName: Int, _ secondParameterName: Int) {
// function body goes here
// firstParameterName and secondParameterName refer to
// the argument values for the first and second parameters
}
someFunction(1, 2)
注意
因为第一个参数默认忽略其外部参数名称，显式地写下划线是多余的。
34.默认参数值（Default Parameter Values）
你可以在函数体中为每个参数定义默认值（Deafult Values）。当默认值被定义后，调用这个函数时可以忽略这个参数。
35.可变参数（Variadic Parameters）
一个可变参数（variadic parameter）可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（...）的方式来定义可变参数。
可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。
下面的这个函数用来计算一组任意长度数字的算术平均数（arithmetic mean）：
func arithmeticMean(numbers: Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8.25, 18.75)
// returns 10.0, which is the arithmetic mean of these three numbers
注意
一个函数最多只能有一个可变参数。
35.常量参数和变量参数（Constant and Variable Parameters）
函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。
但是，有时候，如果函数中有传入参数的变量值副本将是很有用的。你可以通过指定一个或多个参数为变量参数，从而避免自己在函数中定义新的变量。变量参数不是常量，你可以在函数中把它当做新的可修改副本来使用。
通过在参数名前加关键字 var 来定义变量参数：
func alignRight(var string: String, totalLength: Int, pad: Character) -> String {
let amountToPad = totalLength - string.characters.count
if amountToPad < 1 {
return string
}
let padString = String(pad)
for _ in 1...amountToPad {
string = padString + string
}
return string
}
let originalString = "hello"
let paddedString = alignRight(originalString, totalLength: 10, pad: "-")
// paddedString is equal to "-----hello"
// originalString is still equal to "hello"
这个例子中定义了一个叫做 alignRight(_:totalLength:pad:) 的新函数，用来将输入的字符串对齐到更长的输出字符串的右边缘。左侧空余的地方用指定的填充字符填充。这个例子中，字符串"hello"被转换成了"-----hello"。
alignRight(_:totalLength:pad:) 函数将输入参数 string 定义为变量参数。这意味着 string 现在可以作为一个局部变量，被传入的字符串值初始化，并且可以在函数体中进行操作。
函数首先计算出有多少字符需要被添加到string的左边，从而将其在整个字符串中右对齐。这个值存储在一个称为amountToPad的本地常量。如果不需要填充（也就是说，如果amountToPad小于1），该函数简单地返回没有任何填充的输入值string。
否则，该函数用pad字符创建一个叫做padString的临时String常量，并将amountToPad个 padString添加到现有字符串的左边。（一个String值不能被添加到一个Character值上，所以padString常量用于确保+操作符两侧都是String值）。
注意
对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。
36.输入输出参数（In-Out Parameters）
变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。
定义一个输入输出参数时，在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。想获取更多的关于输入输出参数的细节和相关的编译器优化，请查看输入输出参数一节。
你只能传递变量给输入输出参数。你不能传入常量或者字面量（literal value），因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数名前加&符，表示这个值可以被函数修改。
注意
输入输出参数不能有默认值，而且可变参数不能用 inout 标记。如果你用 inout 标记一个参数，这个参数不能被 var 或者 let 标记。
下面是例子，swapTwoInts(_:_:) 函数，有两个分别叫做 a 和 b 的输入输出参数：
func swapTwoInts(inout a: Int, inout _ b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
这个 swapTwoInts(_:_:) 函数简单地交换 a 与 b 的值。该函数先将 a 的值存到一个临时常量 temporaryA 中，然后将 b 的值赋给 a，最后将 temporaryA 赋值给 b。
你可以用两个 Int 型的变量来调用 swapTwoInts(_:_:)。需要注意的是，someInt 和 anotherInt 在传入swapTwoInts(_:_:) 函数前，都加了 & 的前缀：
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// prints "someInt is now 107, and anotherInt is now 3"
从上面这个例子中，我们可以看到 someInt 和 anotherInt 的原始值在 swapTwoInts(_:_:) 函数中被修改，尽管它们的定义在函数体外。
注意
输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值，但仍然修改了 someInt和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。
37.使用函数类型（Using Function Types）
在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：
var mathFunction: (Int, Int) -> Int = addTwoInts
这个可以解读为：
“定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数”。
addTwoInts 和 mathFunction 有同样的类型，所以这个赋值过程在 Swift 类型检查中是允许的。
现在，你可以用 mathFunction 来调用被赋值的函数了：
print("Result: \(mathFunction(2, 3))")
// prints "Result: 5"
有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样：
mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
// prints "Result: 6"
就像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推断其函数类型：
let anotherMathFunction = addTwoInts
// anotherMathFunction is inferred to be of type (Int, Int) -> Int
38.函数类型作为参数类型（Function Types as Parameter Types）
你可以用(Int, Int) -> Int这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现留给函数的调用者来提供。
下面是另一个例子，正如上面的函数一样，同样是输出某种数学运算结果：
func printMathResult(mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "Result: 8"
printMathResult(_:_:_:) 函数的作用就是输出另一个适当类型的数学函数的调用结果。它不关心传入函数是如何实现的，它只关心这个传入的函数类型是正确的。这使得 printMathResult(_:_:_:) 能以一种类型安全（type-safe）的方式将一部分功能转给调用者实现。
39.函数类型作为返回类型（Function Types as Return Types）
你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型。
func stepForward(input: Int) -> Int {
return input + 1
}
func stepBackward(input: Int) -> Int {
return input - 1
}
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
return backwards ? stepBackward : stepForward
}
你现在可以用 chooseStepFunction(_:) 来获得两个函数其中的一个：
var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function
一个指向返回的函数的引用保存在了 moveNearerToZero 常量中。
40.嵌套函数（Nested Functions）
这章中你所见到的所有函数都叫全局函数（global functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数（nested functions）。
默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
func stepForward(input: Int) -> Int { return input + 1 }
func stepBackward(input: Int) -> Int { return input - 1 }
return backwards ? stepBackward : stepForward
}
标签：
原文地址：http://www.cnblogs.com/Jenaral/p/5479015.html
