Swift 基础部分

http://www.swift51.com/swift4.0/index.html

• 常量和变量

常量的值一旦设定就不能改变，而变量的值可以随意更改。

• 声明常量和变量

let a = 1
var b = 2

在一行中声明多个常量或者多个变量，用逗号隔开：

let a = 1, b = 2, c = 3

• 类型标注（type annotation）

var a: String 

一行中定义多个同样类型的变量，用逗号分割，在最后一个变量名之后添加类型标注

 var apple, banbana, orange: String 

• 常量和变量的命名

常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符。也不能以数字开头，但是可以在常量与变量名的其他地方包含数字。
注意：
如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号（`）将关键字包围的方式将其作为名字使用。

• 输出常量和变量

用 print(_:separator:terminator:)函数来输出当前常量或变量的值

separator 和 terminator 参数具有默认值
不想换行，可以传递一个空字符串给 terminator

print(someValue, terminator:"")

• 注释

1.  //       2. /* */       3. /*   /* */   */   

• 分号
  同一行内写多条独立的语句

 let cat = "????"; print(cat)

• 整数

整数可以是 有符号（正、负、零）或者 无符号（正、零）

• 整数范围

let minValue = UInt8.min  // minValue 为 0，是 UInt8 类型
let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型

• Int

在32位平台上，Int 和 Int32 长度相同。
在64位平台上，Int 和 Int64 长度相同。

存储的整数范围也可以达到 -2,147,483,648 ~ 2,147,483,647

• UInt

在32位平台上，UInt 和 UInt32 长度相同。
在64位平台上，UInt 和 UInt64 长度相同。

注意：
尽量不要使用UInt，统一使用Int可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推断，

• 浮点数

Double表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。
Float表示32位浮点数。精度要求不高的话可以使用此类型。

注意：
Double精确度很高，至少有15位数字，而Float只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围，在两种类型都匹配的情况下，将优先选择 Double。

• 类型安全和类型推断（type safe）

当推断浮点数的类型时，Swift 总是会选择 Double 而不是Float。

• 数值型字面量

一个十进制数，没有前缀
一个二进制数，前缀是0b
一个八进制数，前缀是0o
一个十六进制数，前缀是0x

let decimalInteger = 17
let binaryInteger = 0b10001       // 二进制的17
let octalInteger = 0o21           // 八进制的17
let hexadecimalInteger = 0x11     // 十六进制的17

如果一个十进制数的指数为 exp，那这个数相当于基数和10^exp的乘积：

1.25e2 表示 1.25 × 10^2，等于 125.0。
1.25e-2 表示 1.25 × 10^-2，等于 0.0125。

如果一个十六进制数的指数为exp，那这个数相当于基数和2^exp的乘积：

0xFp2 表示 15 × 2^2，等于 60.0。
0xFp-2 表示 15 × 2^-2，等于 3.75。

下面的这些浮点字面量都等于十进制的12.1875：

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

数值类字面量可以增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量：

let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1

• 数值型类型转换

尽量使用Int类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推断。

• 整数转换

整数类型都可以存储不同范围的值，所以你必须根据不同情况选择性使用数值型类型转换。

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)

• 数整数和浮点数转换

整数和浮点数的转换必须显式指定类型：

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine

• 类型别名（type aliases）

typealias otherName = String

• 布尔值

布尔值指逻辑上的值，有两个布尔常量，true 和 false。

• 元组（tuples）

元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。
定义：

let http404Error = (404, "Not Found")

将一个元组的内容分解（decompose）成单独的常量和变量

let (statusCode, statusMessage) = http404Error

分解的时候可以把要忽略的部分用下划线（_）标记

let (justTheStatusCode, _) = http404Error

通过下标来访问元组中的单个元素，下标从零开始

print("The status code is \(http404Error.0)")

可以在定义元组的时候给单个元素命名

let http200Status = (statusCode: 200, description: "OK")
print("The status code is \(http200Status.statusCode)")

• 可选

一个方法要不返回一个对象要不返回nil，nil表示“缺少一个合法的对象”。

let possibleNumber = "hello"
let convertedNumber = Int(possibleNumber)
返回nil

• nil

你可以给可选变量赋值为nil来表示它没有值

var serverResponseCode: Int? = 404
// serverResponseCode 包含一个可选的 Int 值 404
serverResponseCode = nil
// serverResponseCode 现在不包含值

注意：
nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。
如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为 nil：

var surveyAnswer: String?
// surveyAnswer 被自动设置为 nil

注意：
Swift 的 nil 和 Objective-C 中的 nil 并不一样。在 Objective-C 中，nil 是一个指向不存在对象的指针。在 Swift 中，nil 不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为 nil，不只是对象类型。

• if 语句以及强制解析

可以使用 if 语句和 nil 比较来判断一个可选值是否包含值。你可以使用“相等”(==)或“不等”(!=)来执行比较。

if convertedNumber != nil {
    print("convertedNumber has an integer value of \(convertedNumber!).")
}

• 可选绑定（optional binding）

if let a = b {
print（a）
}

可以包含多个可选绑定或多个布尔条件在一个 if 语句中，只要使用逗号分开就行。只要有任意一个可选绑定的值为nil，或者任意一个布尔条件为false，则整个if条件判断为false

if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber && secondNumber < 100 {
   print("\(firstNumber) < \(secondNumber) < 100")
}
// 输出 "4 < 42 < 100"

• 隐式解析可选类型（implicitly unwrapped optionals）

第一次赋值之后就可以确定之后一直有值的时候，建议使用隐式解析可选类型

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要感叹号来获取值

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString  // 不需要感叹号

注意：
如果你在隐式解析可选类型没有值的时候尝试取值，会触发运行时错误。和你在没有值的普通可选类型后面加一个惊叹号一样。

• 错误处理（error handling）

func makeASandwich() throws {
    // ...
}

do {
    try makeASandwich()
    eatASandwich()
} catch SandwichError.outOfCleanDishes {
    washDishes()
} catch SandwichError.missingIngredients(let ingredients) {
    buyGroceries(ingredients)
}

• 断言和先决条件

标准库的 assert(::file:line:) 函数来写一个断言。向这个函数传入一个结果为 true 或者 false 的表达式以及一条信息，当表达式的结果为 false 的时候这条信息会被显示

let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// 因为 age < 0，所以断言会触发

可以使用 assertionFailure(_:file:line:)函数来表明断言失败了

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age > 0 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than zero.")
}

可以使用全局 precondition(::file:line:) 函数来写一个先决条件。向这个函数传入一个结果为 true 或者 false 的表达式以及一条信息，当表达式的结果为 false 的时候这条信息会被显示

precondition(index > 0, "Index must be greater than zero.")
}

可以调用　precondition(::file:line:)方法来表明出现了一个错误