swift第一章

swift中添加的类型:Tuple(元组类型)，能够让你创建或者传递一组数据。

比方作为函数的返回值时。你能够用一个元组能够返回多个值。









swift中还添加了可选(Optional)类型，用于处理值缺失的情况。

可选表示“那儿有一个值，而且它等于X”或者“那儿没有值”。

可选有点像在OC中使用nil。可是它能够用在不论什么类型上，不不过类。

可选类型比OC中的nil指针更加安全也更具表现力。













常量和变量必须在使用前声明

常量：let  maxnum = 10

变量：var currentnum = 50

      var x = 0.0, y = 0.0, z = 0.0













类型标注：

var welcomeMessage: String

    welcomeMessage = "Hello swift"

注意：一般来说你非常少须要写类型标注。

假设你在声明常量或者变量的时候赋了一个初始值，

Swift能够判断出这个常量或者变量的类型，请參考类型安全和类型判断。

在上面的样例中，没有给welcomeMessage赋初始值，

所以变量welcomeMessage的类型是通过一个类型标注指定的，

而不是通过初始值判断的。

常量和变量的命名

你能够用不论什么字符作为常量和变量名字

let n = 3.14

let 你好 = "你好 swift"

let ????

= "swift good"

注意：常量与变量不能包括数学符号，箭头，保留的(或者非法的)Unicode码。

连线与制表符。

也不能以数字开头，可是能够在常量与变量名的其他地方包括数字

















注意：假设你须要使用与Swift保留keyword同样的名称作为常量或者变量名，

你能够使用反引號（`）将keyword包围的方式将其作为名字使用。

不管怎样。你应当避免使用keyword作为常量或变量名，除非你别无选择。





















能够更改值

var feiendly = "Hello!"

    friendly = "swift++!"   OK





let lan = "swift+"

    lan = "swift++"      error编译器会报错

















输出常量和变量

printfIn(常量或者变量名)  输出的内容会在最后换行

print(常量或者变量名)     输出的内容不会在最后换行

printIn("this is a string!")





















占位符输出

var name = "Tom"

printIn("the named is \(name)")





















凝视：

单行凝视：//

多行凝视：/*凝视内容*/

多行凝视中包括多行凝视/* /**/ */

















swift每条语句后面能够写也能够不写";",可是一种情况必须写：在同一行内

写多条独立的语句。

let cat = "???

";printIn(cat)

















整数：

范围：let minValue = Uint8.min Uint8类型最小值0

      let maxValue = Uint8.max Uint8类型最大值255





int

一般来说。你不须要指定整数的长度。swift提供了一个特殊的整数类型int，

长度与当前平台的原生字长同样

-在32位平台上，Int和Int32长度同样

-在64位平台上，Int和Int64长度同样





UInt

swift也提供了一个特殊的无符号类型UInt，长度与当前平台的原生字长同样

-在32位平台上，UInt和UInt32长度同样

-在64位平台上，UInt和UInt64长度同样

尽量不用UInt：统一使用Int能够提高代码的可复用性，

              避免不同类型数字之间的转换，

              而且匹配数字的类型猜測





浮点数

有小数部分的数字。20.36,0.35

double表示64位浮点数

float 表示32位浮点数

注意：Double准确度非常高，至少有15位数字。而Float最少仅仅有6位数字。

选择哪个类型取决于你的代码须要处理的值的范围。

类型猜測

let meaningOf = 42

meaningOf被猜測成int类型

let pi = 3.14159

pi被猜測成double类型

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





假设表达式中同一时候出现了整数和浮点数，会被猜測为Double类型：

let mun = 3+3.14159





















数值类型转换

let two:UInt16 = 2;

let one:Uint8 = 1;

let onetwo = two+UInt16(one)





整数和浮点数转换

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

let three = 3

let point = 0.259

let pi = Double(three)+point





let inter = Int(point)





















类型别名:就是给现有类型定义一个名字。（typelias）

typelias audio = UInt16

var maxAmp = audio.min

















布尔值

swift有两个布尔敞亮，true或者false

let one = true;

let two = flase;





if one

{

   printIn("this is true!");

}

else

{

   printIn("this is false!");

}









let i = 1

if i

{

   ////程序会报错

}





let i=1

if i==1

{

   ////程序不会报错

}

















元组

把多个值组合成一个符合值。元组内的值能够是随意类型，

并不要求是同样类型。

let httpError = (404,"Not Found")

能够描写叙述为一个类型为(int,string)的元组。

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

然后你就能够正常使用它们了：

let (statusCode,statusMessage) = httpError

printIn("the status code is\(statusCode)")

printIn("the status message is\(statusMessage)")





假设你仅仅须要一部分元组值。

分解的时候能够把要忽略的部分用下划线（_）标记：

let (statusCode,_) = httpError

printIn("ths status code is\(statusCode)")





此外。你还能够通过下标来訪问元组中的单个元素，下标从零開始：

printIn("the status code is\(httpError.0)")

printIn("the status Message is\(httpError.1)")





你能够在定义元组的时候给单个元素命名：

let http200 = (statusCode:200,description:"OK")

printIn("the status code is\(http200.statusCode)")

printIn("the description is\(http200.description)")





















可选

使用可选来处理值可能缺失的情况。





注意：C 和 Objective-C 中并没有可选这个概念。

最接近的是 Objective-C 中的一个特性。

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

然而。这仅仅对对象起作用——对于结构体，

主要的 C 类型或者枚举类型不起作用。

对于这些类型。Objective-C 方法通常会返回一个

特殊值（比方NSNotFound）来暗示值缺失。

这样的方法如果方法的调用者知道并记得对特殊值进行推断。

然而。Swift 的可选能够让你暗示随意类型的值缺失。并不须要一个特殊值。





以下的样例使用toInt方法来尝试将一个String转换成Int

let Number1 = "123"

let converNum = Number.toInt()

由于toInt方法可能会失败，所以它返回一个可选的（optional）Int，

而不是一个Int。

一个可选的Int被写作Int?而不是Int。

问号暗示包括的值是可选，也就是说可能包括Int值也可能不包括值。

（不能包括其它不论什么值比方Bool值或者String值。仅仅能是Int或者什么都没有。）

















if语句以及强制解析

你能够使用if语句来推断一个可选是否包括值。

假设可选有值。结果是true，假设没有值，结果是false。

当你确定可选包确实含值之后。

你能够在可选的名字后面加一个感叹号(!)来获取值。

这个惊叹号表示“我知道这个可选有值，请使用它。

”这被称为可选值的强制解析（forced unwrapping）：

if converNum

{

    printIn("\(Numner1) has an value\(converNum!)")

}

else

{

    printIn("\(Number1) can not be conver to int")

}

注意：使用!来获取一个不存在的可选值会导致执行时错误。

使用!来强制解析值之前，一定要确定可选包括一个非nil的值。

















可选绑定

使用可选绑定（optional binding）来推断可选是否包括值，

假设包括就把值赋给一个暂时常量或者变量。

可选绑定能够用在if和while语句中来对可选的值进行推断并把值赋给一个

常量或者变量。

if let anNum = Number1.toInt()

{

    printIn("\(Numner1) has an value\(anNum)")

}

else

{

    printIn("\(Number1) can not be conver to int")

}

这段代码能够被理解为： 

“假设Number1.toInt返回的可选Int包括一个值，

创建一个叫做anNum的新常量并将可选包括的值赋给它。” 

假设转换成功，anNum常量能够在if语句的第一个分支中使用。

它已经被可选包括的值初始化过。所以不须要再使用!后缀来获取它的值。

在这个样例中。anNumber仅仅被用来输出转换结果。

















nil

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

var serverRes:Int? = 404

serverRes = nil

注意：nil不能用于非可选的常亮和变量。

假设你的代码有常亮或者变量须要处理值缺失的情况，请把它们声明为可选类型。

假设你声明一个可选常亮或者变量可是没有复制，它们会自己主动被设置为nil

var sur:String?

//sur = nil





注意：Swift 的nil和 Objective-C 中的nil并不一样。

在 Objective-C 中，nil是一个指向不存在对象的指针。

在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。

不论什么类型的可选都能够被设置为nil，不仅仅是对象类型。

隐式解析可选

这样的类型的可选被定义为隐式解析可选（implicitly unwrapped optionals）。

把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）

来声明一个隐式解析可选。

let possA:String? = "this is 强制解析须要!取值"

printIn(possA!)





let possB:String! = "this is 隐式转换不须要!"

printIn(possB)

你能够把隐式解析可选当做一个能够自己主动解析的可选。

你要做的仅仅是声明的时候把感叹号放到类型的结尾，

而不是每次取值的可选名字的结尾。





注意：假设你在隐式解析可选没有值的时候尝试取值。会触发执行时错误。

和你在没有值的普通可选后面加一个惊叹号一样。

你任然能够把隐式解析可选当做普通可选来推断它是否包括值

if possB

{

    printIn(possB)

}





你也能够在可选绑定中使用隐式解析可选来检查并解析它的值：

if let defindes = possB

{

    printIn(defindes)

}

注意：假设一个变量之后可能变成nil的话请不要使用隐式解析可选。

假设你须要在变量的生命周期中推断是否是nil的话，请使用普通可选类型。

























断言

可选能够让你推断值是否存在，你能够在代码中优雅地处理值缺失的情况。

然而，在某些情况下，假设值缺失或者值并不满足特定的条件，

你的代码可能并不须要继续运行。

这时，你能够在你的代码中触发一个断言（assertion）来结束代码执行

并通过调试来找到值缺失的原因。





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，断言被触发，

结束应用。













何时使用断言

当条件可能为假时使用断言，可是终于一定要保证条件为真，

这样你的代码才干继续执行。





断言的适用情景：

- 整数的附属脚本索引被传入一个自己定义附属脚本实现。

  可是下标索引值可能太小或者太大。(自己的理解是数组越界)





- 须要给函数传入一个值，可是非法的值可能导致函数不能正常运行。





- 一个可选值如今是nil。可是后面的代码执行须要一个非nil值。









注意：

断言可能导致你的应用终止执行，

所以你应当细致设计你的代码来让非法条件不会出现。

然而，在你的应用公布之前。有时候非法条件可能出现，

这时使用断言能够高速发现问题。