Basics
Swift提供了自己的所有C和Objective-C基本类型。包括Int来对应整数。Double和Float对应浮点值。Bool对应Boolean值，和String对应文本数据。swift同样提供了强有力的版本对应两个主要的集合类型，Array和Dictionary。
除了常见的类型，swift引进了Objective-C里没有的先进类型。这些包括可以使你建立和归类那些值的元组。元组可以从一个函数中返回多个值就像一个单独的复合的值。(Double, Double, Double)
swift还引入了optional类型，可以处理一个缺省的类型。可选或者表示“这是一个值，它等价于XXX”或者表示“这里没有一个值”。可选就像在Objective-C使用一个nil型的指针，但是他们可以使任意类型，不仅仅是类(例如基础类型)。可选比Objective-C中中的指向nil的指针更安全和更有表现力，他是swift最强大的功能的核心所在。(String?)
optional可以看出swift是一个类型安全的语言。它帮助你去明确你代码中使用的值的类型。如果你的代码中存在String，类型安全的机制会帮助你防止把它当成一个Int使用。这可以帮助你在开发工程中尽早的找到和修复错误。
Declaring Constants and Variables
你还可以一行声明多个变量：
var x = 0.0, y = 0.0, z = 0.0
如果变量有初始值就可以不用declare的时候声明类型，如果没有初始赋值就需要声明用于存储哪种类型变量哦：
var welcomeMessage: String
变量和常量的名称是唯一的，且声明以后你不能修改数据类型。
可以用reserve keyword命名但是需要用``来包围，强烈不推荐哦：
var `switch` = "hhh"
打印变量可以println（带换行）或print（不带换行）：
println("The current value of friendlyWelcome is \(friendlyWelcome)")
Comments可以多行嵌套哦~
C语言是酱紫的/* Comments*/
/* this is also a comment,
but written over multiple lines */
swift拓展了可以多行嵌套（成对即可）：
/* this is the start of the first multiline comment
/* this is the second, nested multiline comment */
this is the end of the first multiline comment */
这个写法是不是感觉再也不用担心在写//注释的时候里面多写了/或是/了。嵌套多行注释使你注释掉大块的代码快速方便，即使代码已经包含多行注释。
swift是不需要分号换行的哦除非你想在一行写多个语句：
let cat = ""; println(cat)
Integers
整数就是没有小数部分的数字，比如42和-23。整数可以是有符号（正、负、零）或者无符号（正、零）。
Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是UInt8，32位有符号整数类型是Int32。就像 Swift 的其他类型一样，整数类型采用大写命名法。
Integer Bounds
let minValue=UInt8.min // minValue is equal to 0, and is of type UInt8
let maxValue=UInt8.max // maxValue is equal to 255, and is of type UInt8
返回的值就是UInt8的类型，可以直接用哦
Int
一般来说，你不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型Int，长度与当前平台的原生字长相同，除非你需要特定长度的整数，一般来说使用Int就够了。这可以提高代码一致性和可复用性。即使是在32位平台上，Int可以存储的整数范围也可以达到-2,147,483,648~2,147,483,647，大多数时候这已经足够大了。
UInt
和Int一样也是和平台的默认字长一致，但是一般除了一定要特殊声明一个和默认字长一致的unsigned的时候（可能是由于范围不够之类的），都是用Int比较好。
Floating-Point Numbers
Double至少有15位的小数，Float有小6位的小数部分，根据精度的需求来使用相应的类型。
Type Safety and Type Inference
Swift 是一个类型安全（type safe）的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个String，你绝对不可能不小心传进去一个Int。
如果你没有显式指定类型，Swift 会使用类型推断（type inference）来选择合适的类型。
如果你没有给浮点字面量标明类型，Swift 会推断你想要的是Double，当推断浮点数的类型时，Swift 总是会选择Double而不是Float。
Numeric Literals
数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量：
let paddedDouble=000123.456
let oneMillion=1_000_000
let justOverOneMillion=1_000_000.000_000_1
Numeric Type Conversion
通常来讲，即使代码中的整数常量和变量已知非负，也请使用Int类型。只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。
Integer Conversion
不同整数类型的变量和常量可以存储不同范围的数字。Int8类型的常量或者变量可以存储的数字范围是-128127，而UInt8类型的常量或者变量能存储的数字范围是0255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：
let cannotBeNegative:UInt8=-1
// UInt8 cannot store negative numbers, and so this will report an error
// UInt8 类型不能存储负数，所以会报错
let tooBig:Int8=Int8.max+1
// Int8 cannot store a number larger than its maximum value, and so this will also report an error
// Int8 类型不能存储超过最大值的数，所以会报错
要将一种数字类型转换成另一种，你要用当前值来初始化一个期望类型的新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量twoThousand是UInt16类型，然而常量one是UInt8类型。它们不能直接相加，因为它们类型不同。所以要调用UInt16(one)来创建一个新的UInt16数字并用one的值来初始化，然后使用这个新数字来计算：
let twoThousand:UInt16=2_000
let one:UInt8=1
let twoThousandAndOne=twoThousand+UInt16(one)
SomeType(ofInitialValue)是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，UInt16有一个构造器，可以接受一个UInt8类型的值，所以这个构造器可以用现有的UInt8来创建一个新的UInt16。注意，你并不能传入任意类型的值，只能传入UInt16内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型）。
Integer and Floating-Point Conversion
如果不先转换three为double，是不允许int + double的哦~
let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
注意
let PI = 3 + 0.14159是不会报错的，因为3没有一个确认的类型，但上面的three已经被推断为int了。
如果float转int，会直接截掉小数部分：
let integerPi = Int(pi)
Type Aliases
类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。
当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据：
typealias AudioSample=UInt16
var maxAmplitudeFound=AudioSample.min
Booleans
Swift防止了在需要使用Bool类型的地方使用了非布尔值，下面的例子会报告一个编译时错误：
let i=1
if i {
// this example will not compile, and will report an error
// 这个例子不会通过编译，会报错
}
下面是可以正常编译的：
let i=1
if i ==1 {
// this example will compile successfully
// 这个例子会编译成功
}
Tuples（元组）
元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。
例如(404, "Not Found")是一个描述HTTP 状态码（HTTP status code）的元组。(404, "Not Found")元组把一个Int值和一个String值组合起来表示 HTTP 状态码的两个部分：一个数字和一个人类可读的描述。这个元组可以被描述为“一个类型为(Int, String)的元组”。
你可以将一个元组的内容分解成单独的常量和变量，然后你就可以正常使用它们了：
let (statusCode, statusMessage) = http404Error
println("The status code is \(statusCode)")
// prints "The status code is 404"
println("The status message is \(statusMessage)")
// prints "The status message is Not Found"
如果你只需要部分值，不需要全部分解，可以用_来忽略不要的：
let (justTheStatusCode, _) = http404Error
println("The status code is \(justTheStatusCode)")
// prints "The status code is 404"
或者你还可以用index来访问元组元素：
println("The status code is \(http404Error.0)")
// prints "The status code is 404"
println("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"
作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个(Int, String)元组来描述是否获取成功。但是元组只适合短期的简单数据哦，如果很复杂的数据，或者需要一个比较大的scope还是需要做成class的哦。
Optionals
使用可选类型（optionals）来处理值可能缺失的情况。可选项表示两种可能性：有一个值，您可以解开可选值以访问该值，或者根本没有值。
最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回nil，nil表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。
对于这些类型，Objective-C 方法一般会返回一个特殊值（比如NSNotFound）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选类型可以让你暗示任意类型的值缺失，并不需要一个特殊值。
let possibleNumber="123"
let convertedNumber=Int(possibleNumber)
// convertedNumber is inferred to be of type "Int?", or "optional Int"
nil
你可以给可选变量赋值为nil来表示它没有值:
var serverResponseCode:Int? =404
serverResponseCode=nil
nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。
如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为nil：var surveyAnswer:String?
Swift 的nil和 Objective-C 中的nil并不一样。在 Objective-C 中，nil是一个指向不存在对象的指针。在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为nil，不只是对象类型。
If Statements and Forced Unwrapping
你可以使用if语句和nil比较来判断一个可选值是否包含值。你可以使用“相等”(==)或“不等”(!=)来执行比较。
当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值（如果用！强制解析nil的可选变量会crash哦）。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析（forced unwrapping）：
if convertedNumber!=nil{
print("convertedNumber has an integer value of\(convertedNumber!).")
}
// Prints "convertedNumber has an integer value of 123."
注意不可以酱紫哦：
if convertedNumber {
// 需要一个bool表达式，不可以按OC的那种缩写if (object)，需要if(object != nil)
}
Optional Binding
可选绑定可以用于判断optional类型是不是nil，并且如果不为nil，将把值放入新的变量来让block里面使用，常结合if或者while：
if let constantName = someOptional {
// 使用constantName即可
}
例如上面的判断可以重写为：
if let actualNumber = possibleNumber.toInt() {
println("\(possibleNumber) has an integer value of \(actualNumber)")
} else {
println("\(possibleNumber) could not be converted to an integer")
}
Implicitly Unwrapped Optionals
有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。
这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）来声明一个隐式解析可选类型。
一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型String和隐式解析可选类型String之间的区别：
let possibleString:String? ="An optional string."
let forcedString:String=possibleString!// requires an exclamation mark
// 需要感叹号来获取值
let assumedString:String! ="An implicitly unwrapped optional string."
let implicitString:String=assumedString// no need for an exclamation mark
// 不需要感叹号
这样其实就是在声明的时候告诉编译器这个是永远有值的，使用的时候就不用每次都用!来解包了，类似让编译器自动给你加个!，你仍然可以把隐式解析可选类型当做普通可选类型来判断它是否包含值~
只要这个变量有可能是nil最好不要用XXX!哦还是XXX?来声明比较好
Assertions
可选类型可以让你判断值是否存在，你可以在代码中优雅地处理值缺失的情况。然而，在某些情况下，如果值缺失或者值并不满足特定的条件，你的代码可能没办法继续执行。这时，你可以在你的代码中触发一个断言（assertion）来结束代码运行并通过调试来找到值缺失的原因。
Debugging with Assertions
断言会在运行时判断一个逻辑条件是否为true。从字面意思来说，断言“断言”一个条件是否为真。你可以使用断言来保证在运行其他代码之前，某些重要的条件已经被满足。如果条件判断为true，代码运行会继续进行；如果条件判断为false，代码执行结束，你的应用被终止。
你可以使用全局assert(_:_:file:line:)函数来写一个断言。向这个函数传入一个结果为true或者false的表达式以及一条信息，当表达式的结果为false的时候这条信息会被显示：
let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
如果不需要信息就忽略后面的string说明就好：
assert(age>=0)
当代码使用优化编译的时候，断言将会被禁用，例如在 Xcode 中，使用默认的 target Release 配置选项来 build 时，断言会被禁用。
When to Use Assertions
当条件可能为false时使用断言，但是最终一定true你的代码才能继续运行。
断言的适用情景：
整数类型的下标索引被传入一个自定义下标实现，但是下标索引值可能太小或者太大。
需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
一个可选值现在是nil，但是后面的代码运行需要一个非nil值。
断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。
