Swift 是一门开发 iOS, macOS, watchOS 和 tvOS 应用的新语言。然而，如果你有 C 或者 Objective-C 开发经验的话，你会发现 Swift 的很多内容都是你熟悉的。
swift swift2
Swift 包含了 C 和 Objective-C 上所有基础数据类型，Int 表示整型值；Double和 Float表示浮点型值；Bool是布尔型值；String是文本型数据。 Swift 还提供了三个基本的集合类型，Array，Set和Dictionary
就像 C 语言一样，Swift 使用变量来进行存储并通过变量名来关联值。在 Swift 中，广泛的使用着值不可变的变量，它们就是常量，而且比 C 语言的常量更强大。在 Swift 中，如果你要处理的值不需要改变，那使用常量可以让你的代码更加安全并且更清晰地表达你的意图。
除了我们熟悉的类型，Swift 还增加了 Objective-C 中没有的高阶数据类型比如元组（Tuple）。元组可以让你创建或者传递一组数据，比如作为函数的返回值时，你可以用一个元组可以返回多个值
Swift 还增加了可选（Optional）类型，用于处理值缺失的情况。可选表示 “那儿有一个值，并且它等于 x ” 或者 “那儿没有值” 。可选有点像在 Objective-C 中使用 nil ，但是它可以用在任何类型上，不仅仅是类。可选类型比 Objective-C 中的 nil 指针更加安全也更具表现力，它是 Swift 许多强大特性的重要组成部分。
Swift 是一门类型安全的语言，这意味着 Swift 可以让你清楚地知道值的类型。如果你的代码需要一个 String ，类型安全会阻止你不小心传入一个 Int 。同样的，如果你的代码需要一个 String，类型安全会阻止你意外传入一个可选的 String 。类型安全可以帮助你在开发阶段尽早发现并修正错误
常量和变量
常量和变量把一个名字和制定类型的指联系起来，比如把"name" 和 "Edison"联系起来
声明常量和变量
let声明常量，var声明变量
var helleStr : NSString = "hello"
var i = 0, b=9, c = "nihao"
注意：如果你的代码中有不需要改变的值，
请用let把它声明成常量
类型标注
当你声明常量或者变量的可以添加直接直接添加类型
比如
var nameStr : NSString
var helleStr : NSString = "hello"
这样就给常量或者变量声明的属性，表示这个变量储存的是制定类型的值
一般来说我们很少需要写类型标注，如果你声明常量或者变量的时候初始化一个值，swift可以推断出这个常量或者变量的类型
常量和变量的命名
swift允许你有你任何你喜欢的字符座位常量和变量名，包括unicode编码
let 🐶二 = "dog"
let 天涯 = "tianya"
常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符。也不能以数字开头，但是可以在常量与变量名的其他地方包含数字
一旦你将常量或者变量声明为确定的类型，你就不能使用相同的名字再次进行声明，或者改变其存储的值的类型。同时，你也不能将常量与变量进行互转
输出常量和变量
print(helleStr)
print("hellstr:\(helleStr) tianya:\(天涯)")
分号
与大部分编程不同，swift并不强制要求在每句代码后都得加上分号，但是有一种情况下，是必须要加的，就是在同一行写多句独立的代码
var intA = 3 ; print(intA)
整数
整数就是没有小数部分的数字，比如 42 和 -23 。整数可以是 有符号（正、负、零）或者 无符号（正、零）。
Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是UInt8，32位有符号整数类型是 Int32 。就像 Swift 的其他类型一样，整数类型采用大写命名法
Int
一般来说，你不需要专门指定证书的长度，swift提供了一个特殊的整数类型Int，长度与当前平台的原生长度一样
- 在32位平台上，
Int与Int32长度一样 - 在64位平台上，
Int与Int64长度一样
除非你需要特定长度的整数，一般来说使用 Int 就够了。这可以提高代码一致性和可复用性。即使是在32位平台上，Int 可以存储的整数范围也可以达到 -2,147,483,648 ~ 2,147,483,647 ，大多数时候这已经足够大了
UInt
Swift 也提供了一个特殊的无符号类型 UInt，长度与当前平台的原生字长相同
浮点数
浮点数是有小数部分的数字，比如3.14159,0.2,-7.456
浮点数比整数表示的范围更大，可以储存比Int更大或者更小的数字，swift也提供了两种浮点数
- Double
表示64位浮点数，当你需要存储很大或者很高精度的浮点数时请使用此类型 - Float
表示32位浮点数。精度要求不高的话可以使用此类型
Double精确度很高，至少有15位数字，而Float只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围，在两种类型都匹配的情况下，将优先选择 Double
类型安全和类型推断
Swift 是一个类型安全（type safe）的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个String，你绝对不可能不小心传进去一个Int
由于 Swift 是类型安全的，所以它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误
当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推断（type inference）来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可
因为有类型推断，和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成
当你声明常量或者变量并赋初值的时候类型推断非常有用。当你在声明常量或者变量的时候赋给它们一个字面量（literal value 或 literal）即可触发类型推断。（字面量就是会直接出现在你代码中的值，比如 42 和 3.14159 。）
例如，如果你给一个新常量赋值 10 并且没有标明类型，Swift 可以推断出常量类型是 Int ，因为你给它赋的初始值看起来像一个整数
let intValue = 10
同理，如果你没有给浮点字面量标明类型，Swift 会推断你想要的是 Double
let douValue = 4.675
当推断浮点数的类型时，Swift 总是会选择 Double 而不是Float
如果表达式中同时出现了整数和浮点数，会被推断为 Double 类型：
let value = 10+7.78
数值型字面量
整数字面量可以被写作
- 一个十进制数，没有前缀
- 一个二进制数，前缀是
0b - 一个八进制数，前缀是
0o - 一个十六进制数，前缀是
0x
浮点字面量可以是十进制（没有前缀）或者是十六进制（前缀是 0x ）,小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。十进制浮点数也可以有一个可选的指数（exponent)，通过大写或者小写的 e 来指定；十六进制浮点数必须有一个指数，通过大写或者小写的 p 来指定
如果一个十进制数的指数为 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
数值型类型转换
通常来讲，即使代码中的整数常量和变量已知非负，也请使用Int类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推断
只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据
整数转换
不同整数类型的变量和常量可以存储不同范围的数字。Int8类型的常量或者变量可以存储的数字范围是-128~127，而UInt8类型的常量或者变量能存储的数字范围是0~255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错
由于每种整数类型都可以存储不同范围的值，所以你必须根据不同情况选择性使用数值型类型转换。这种选择性使用的方式，可以预防隐式转换的错误并让你的代码中的类型转换意图变得清晰
要将一种数字类型转换成另一种，你要用当前值来初始化一个期望类型的新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量twoThousand是UInt16类型，然而常量one是UInt8类型。它们不能直接相加，因为它们类型不同。所以要调用UInt16(one)来创建一个新的UInt16数字并用one的值来初始化，然后使用这个新数字来计算
let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)
整数和浮点数转换
整数和浮点数的转换必须显式指定类型：
let intC = 33
let floatB = 4.67
let doubleC = Double(intC) + floatB
类型别名
类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名
当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据：
typealias AudioSample = UInt16
定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名：
var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound 现在是 0
本例中，AudioSample被定义为UInt16的一个别名。因为它是别名，AudioSample.min实际上是UInt16.min，所以会给maxAmplitudeFound赋一个初值0。
布尔值
Swift 有一个基本的布尔（Boolean）类型，叫做Bool。布尔值指逻辑上的值，因为它们只能是真或者假。Swift 有两个布尔常量，true 和 false：
let boolA = true
let boolB = false
boolA 和 boolB 的类型会被推断为 Bool，因为它们的初值是布尔字面量。就像之前提到的 Int 和 Double 一样，如果你创建变量的时候给它们赋值 true 或者 false，那你不需要将常量或者变量声明为 Bool 类型。初始化常量或者变量的时候如果所赋的值类型已知，就可以触发类型推断，这让 Swift 代码更加简洁并且可读性更高
当你编写条件语句比如if语句，布尔值就很有作用
if boolA {
print("YES")
}else{
print("NO")
}
元组
元组(tuples) 把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型
你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。只要你想，你可以创建一个类型为 (Int, Int, Int) 或者 (String, Bool) 或者其他任何你想要的组合的元组。
你可以将一个元组的内容分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：
let (name,age,height) = ("Edison",13,177)
print(name,age,height)
还可以只通过下标来访问元组的单个元素
let faceId = ("good",144)
let (face,weight) = faceId
print("\(faceId.0) -- \(faceId.1)")
你可以在定义元组的时候给单个元素命名
let tupleName = (eName:"edison",eAge:14)
print("enmae=\(tupleName.eName) age=\(tupleName.eAge)")
作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个 (Int, String) 元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用
可选类型
使用可选类型(optionals)来处理可能确实的情况，可选类型表示：
- 有值，等于x
- 没有值
注意
c和oc中并没有可选类型这个概念，最接近这个概念，是oc中的一个特性(一个方法要么返回对象，要么返回nil，nil表示确实一个合法对象，但这只对oc对象有作用，对c，结构体都不能用，对于这些类型，Objective-C 方法一般会返回一个特殊值（比如NSNotFound）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断)，然而，Swift 的可选类型可以让你暗示任意类型的值缺失，并不需要一个特殊值
let的可选项没有初始化，var的可选项初始值为nil
来看一个例子。Swift 的 Int 类型有一种构造器，作用是将一个 String 值转换成一个 Int 值。然而，并不是所有的字符串都可以转换成一个整数。字符串 "123" 可以被转换成数字 123 ，但是字符串 "hello, world" 不行。
下面的例子使用这种构造器来尝试将一个 String 转换成 Int：
let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"
因为该构造器可能会失败，所以它返回一个可选类型（optional）Int，而不是一个 Int。一个可选的 Int 被写作 Int? 而不是 Int。问号暗示包含的值是可选类型，也就是说可能包含 Int 值也可能不包含值。（不能包含其他任何值比如 Bool 值或者 String 值。只能是 Int 或者什么都没有。）
nil
你可以给可选变量赋值为nil来表示它没有值：
var value: Int? = 404
// value 包含一个可选的 Int 值 404
value = nil
// value 现在不包含值
注意
nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型
如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为 nil
注意
Swift 的 nil 和 Objective-C 中的 nil 并不一样。在 Objective-C 中，nil 是一个指向不存在对象的指针。在 Swift 中，nil 不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为 nil，不只是对象类型
if语句以及强制解析
你可以使用哥if语句和nil比较来判断一个可选值是否包含值
你可以使用“相等”(==)或“不等”(!=)来执行比较。
如果可选类型有值，它将不等于 nil：
var oStr = "oStr"
var a = Int(oStr)
if a != nil {
print("a有值")
}else{
print("a无值")
}
//结果是a无值
当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它
var oStr = "123"
var a = Int(oStr)
if a != nil {
print("a有值\(a!)")
}else{
print("a无值")
}
但是如果用! 来强制解析不存在对可选值，就会出错
var oStr = "oStr"
var a = Int(oStr)
print("a有值\(a!)")
// unexpectedly found nil while unwrapping an Optional value
这个奔溃就是强行解包一个nil值的变量
注意：
使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前，一定要确定可选包含一个非nil的值
可选绑定
使用可选绑定(optional binding)来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量
可选绑定可以用在 if 和 while 语句中，这条语句不仅可以用来判断可选类型中是否有值，同时可以将可选类型中的值赋给一个常量或者变量
像下面这样在 if 语句中写一个可选绑定：
if let constantName = someOptional {
statements
}
你可以像上面这样使用可选绑定来重写 possibleNumber 这个
if let actualNumber = Int(possibleNumber) {
print("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
} else {
print("\'\(possibleNumber)\' could not be converted to an integer")
}
这段代码可以被理解为：
“如果 Int(possibleNumber) 返回的可选Int 包含一个值，创建一个叫做 actualNumber 的新常量并将可选包含的值赋给它。”
如果转换成功，actualNumber常量可以在 if 语句的第一个分支中使用。它已经被可选类型 包含的 值初始化过，所以不需要再使用 ! 后缀来获取它的值。在这个例子中，actualNumber 只被用来输出转换结果。
你可以在可选绑定中使用常量和变量。如果你想在if语句的第一个分支中操作 actualNumber 的值，你可以改成if var actualNumber，这样可选类型包含的值就会被赋给一个变量而非常量
你可以包含多个可选绑定或多个布尔条件在一个if语句中，只要使用逗号分开就行。只要有任意一个可选绑定的值为nil，或者任意一个布尔条件为false，则整个if条件判断为false，这时你就需要使用嵌套if 条件语句来处理，如下所示：
if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber && secondNumber < 100 {
print("\(firstNumber) < \(secondNumber) < 100")
}
// 输出 "4 < 42 < 100"
if let firstNumber = Int("4") {
if let secondNumber = Int("42") {
if firstNumber < secondNumber && secondNumber < 100 {
print("\(firstNumber) < \(secondNumber) < 100")
}
}
}
// 输出 "4 < 42 < 100"
注意： 在
if条件语句中使用常量和变量来创建一个可选绑定，仅在if语句的句中(body)中才能获取到值
隐式解析可选类型
如上所述，可选类型暗示了常量或者变量可以“没有值”。可选可以通过if 语句来判断是否有值，如果有值的话可以通过可选绑定来解析值
有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值
这种类型的可选状态被定义为隐式解析可选类型
把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）来声明一个隐式解析可选类型
当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中
一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型 String 和隐式解析可选类型 String 之间的区别：
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要感叹号来获取值
let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // 不需要感叹号
你可以把隐式解析可选类型当做一个可以自动解析的可选类型。你要做的只是声明的时候把感叹号放到类型的结尾，而不是每次取值的可选名字的结尾
如果你在隐式解析可选类型没有值的时候尝试取值，会触发运行时错误。和你在没有值的普通可选类型后面加一个惊叹号一样
你仍然可以把隐式解析可选类型当做普通可选类型来判断它是否包含值：
if assumedString != nil {
print(assumedString)
}
// 输出 "An implicitly unwrapped optional string."
你也可以在可选绑定中使用隐式解析可选类型来检查并解析它的值：
if let definiteString = assumedString {
print(definiteString)
}
// 输出 "An implicitly unwrapped optional string."
如果一个变量之后可能变成nil的话请不要使用隐式解析可选类型。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。
使用断言进行调试
你可以使用swift标准库assert(_:_:file:line:) ,函数来写一个断言。向这个函数传入一个结果为 true 或者 false 的表达式以及一条信息，当表达式的结果为 false 的时候这条信息会被显示
let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// 因为 age < 0，所以断言会触发
在这个例子中，只有 age >= 0 为 true 时，即 age 的值非负的时候，代码才会继续执行。如果 age 的值是负数，就像代码中那样，age >= 0 为false，断言被触发，终止应用。
