1 变量和常量

• 常量&变量的使用原则：
  为保证数据的安全性尽量先用 let，只有需要改变的时候才使用 var

 let 常量: 常量的值一旦设定就不能改变
 var 变量: 变量的值可以随意更改

• 定义常量的格式：

声明符号 常量名称: 类型标注
let number: Int // 特点: 一旦设定就不能改变

 let number: Int = 10
 number = 20 //不可修改常量的值

• 定义变量格式：

 *声明符号 变量名称: 类型标注
 var number: Int
 *特点: 变量的值可以随意更改
 *注意: 一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型
 var number: Int = 10
 number = 20 //可修改变量的值

• 类型推断
  编译器可以在编译代码的时候自动推断出表达式的类型。(其它语言是没有类型推断)，原理很简单，只要检查你赋的值即可。如果没有指定表达式的类型, 也没有赋予初始值, 编译器会报错(type annotation missing in pattern)。

let number1 = 10
var number2 = 20.1
// 注意点： 如果没有指定表达式的类型, 也没有赋予初始值, 编译器会报错

• 类型安全
  Swift 是一个类型安全（type safe）的语言, 它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。

let number: Int = 10.1 //类型不匹配

这可以让你在开发的时候尽早发现并修复错误。swift 对数据类型要求异常严格, swift 中任何时候，都不会做 隐式转换，如果要对不同类型的数据进行计算，必须显示类型转换。

let number1 = 10
let number2 = 10.1
// let sum = number7 + number8 //类型不匹配，无法进行计算
// 必须进行类型转换
let sum = let sum = Double(number1) + number2
let sum1 = number1 + Int(number2)

注意：

• 结合数字类常量和变量不同于结合数字类字面量。字面量8可以直接和字面量3.1415926相加，因为数字字面量本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。

// 字面量之间运算可以是不同类型
let sum2 = 10 + 10.1

• Double和CGFloat也需要转换

let point = CGPoint(x: 10.10, y: 20.20)
let temp = point.x
let sum = double(point.x) + temp

• 常量和变量的命名
  • 你可以用任何你喜欢的字符作为常量和变量名，包括 Unicode 字符

let 🐶 = "狗"
let 你好 = “你好世界”

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

let `Int` = 10
// 无论如何，你应当避免使用关键字作为常量或变量名，除非你别无选择。

2 元组（tuples）

元组（tuples）把多个值组合成一个复合值，将多个相同或者不同类型的值用一个小括号括起来就是一个元祖，元组内的值可以是任意类型，并不要求是相同类型，作为函数返回值时，元组非常有用。

let http404Error = (404, "Not Found")

元组的访问：

• 你可以分解表的内容到单独的常量或变量，你再像往常一样访问：

let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// Prints "The status code is 404"
print("The status message is \(statusMessage)")
// Prints "The status message is Not Found"

• 使用从零开始索引号访问元组的各个元素值：

print("The status code is \(http404Error.0)")
// Prints "The status code is 404"
print("The status message is \(http404Error.1)")
// Prints "The status message is Not Found"

• 你还可以制定元素名称去命名并且访问一个元组：

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

3 可选类型（Optionals）

可选类型表示变量可以有值, 也可以没有值。C 和 Objective-C 中并没有可选类型这个概念。

• 格式: Optional<类型> 或 在类型后面加上?号。由于可选类型在Swift中随处可见, 所以系统做了一个语法糖, 在类型后面加上?

var number: Optional<Int>
number = 10
var serverResponseCode: Int? = 404

• 可选类型的取值是一个枚举(None 没有值 Some 有值)。Swift中只有可选类型才可以赋值为nil。

var serverResponseCode: Int? = 404
// serverResponseCode contains an actual Int value of 404
serverResponseCode = nil
// serverResponseCode now contains no value

• 如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为nil。

var surveyAnswer: String?
// surveyAnswer is automatically set to nil

注意：
nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。
Swift 的nil和 Objective-C 中的nil并不一样。在 Objective-C 中，nil是一个指向不存在对象的指针, 所以Objective-C只有对象类型才能被设置为nil(基本类型不行)。在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为nil，不只是对象类型。

解包：

• 强制解析（forced unwrapping）
  Swift中可选类型的值不能当做普通类型的值来使用,如果想使用可选类型的值必须进行解包操作。只需要在变量/常量后面加上! 就可以解包，解包代表着告诉系统, 该变量/常量中一定有值。

var serverResponseCode: Int?
serverResponseCode = 404
print (serverResponseCode!)

注意:
1.init? 构造函数,?表示不一定能够实例化出对象;
2.!表示告诉编译器一定有值, 编译能够通过, 如果运行时没有值就会直接崩溃
3.在Swift开发中, 尽量不要使用强制解包, 不安全

• 可选绑定（optional binding）
  不需要考虑url是否有值, 能进入{}一定有值；不仅可以用来判断可选类型中是否有值，同时可以将可选类型中的值赋给一个常量或者变量, 可选绑定可以用在if和while语句中。

let url = NSURL(string: "http://www.baidu.com")
if let temp = url {
    // code...
    // temp的作用域只在这个"{}"里面
}

if let firstNumber = Int("4"), secondNumber = Int("42") where firstNumber < secondNumber {
    print("\(firstNumber) < \(secondNumber)")
}

注意：
if语句中的变量/常量（temp）的作用域为{}中。

• guard
  guard语句是在Swift 2.0中引进的，它是用途是在未满足某个条件时，提供一个退出的路径。

func test(){
    let value1: Int? = 10
    let value2: Int? = 20
    let value3: Int? = 30
    let value4: Int? = 40
    
    guard let temp1 = value1 else{
        return
    }
    guard let temp2 = value2 else{
        return
    }
    guard let temp3 = value3 else{
        return
    }
    guard let temp4 = value4 else{
        return
    }
    let sum = temp1 + temp2 + temp3 + temp4
    print(sum)
}
test()
// prints 100

注意：
guard中的变量/常量 可以在guard后面使用（作用域);
guard一般用于避免使用强制拆包, 优化代码结构

• 隐式解析可选类型（implicitly unwrapped optionals）
  有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。 隐式解析可选类型, 并不需要每次都使用解析来获取可选值, 一个隐式解析可选类型其实就是一个普通类型，但是可以被当做非可选类型来使用。

let FshButton: UIButton!

注意：
如果一个变量之后可能变成nil的话请不要使用隐式解析可选类型。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。

var doubleValue: Double!
doubleValue = 3.14
doubleValue = nil
print(doubleValue)

报错原因是编译器检测到隐式解析可选类型在赋值为nil。

总结一下：

//可选类型（强制解包，不推荐）
let intValue: Int?
intValue = 10
print(intValue)
print(intValue!)

if intValue != nil {
    print(intValue!)
}

// 可选绑定
if let temp = intValue {
    print(temp)
}

//隐式解析可选类型
var doubleValue: Double!
doubleValue = nil
doubleValue = 3.14
print(doubleValue)