Swift2.2 学习笔记(八) ___基础部分

• 基础部分
• 常量和变量
• 声明常量和变量
• 常量和变量必须在使用前声明，用let来声明常量，用var来声明变量

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

可以在一行中用多个常量或者多个变两，用逗号隔开

var x = 0,y = 1, z = 2

• 类型标注
• 当声明常量或者变量的时候可以加上类型标注，说明常量或者变量中要存储的值的类型。
• 如果要添加类型标注，需要在常量或者变量名后面假山过一个冒号和空格，然后加上类型名称。

var welcomeMessage: String  //声明中的冒号代表着“是...类型”

welcomeMessage 变量现在可以被设置成任意字符串

welcomeMessage = "Hello"
var red, green, blue:Double

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

let π = 3.14159
let 你好 = "你好世界"
let ���� = "dogcow"

var friendlyWelcomt = "Hello"
friendlyWelcomt = "Bonjour!"

整数范围

let minValue = UInt8.min  
//minValue为0， 是UInt8 类型的最小值
let maxValue = UInt8.max  
//maxValue为255， 是UInt8 类型的最大值

• Int
• 在 32 位平台上,Int 和 Int32 长度相同。
• 在 64 位平台上,Int 和 Int64 长度相同。
  *
• UInt
• 在 32 位平台上,UInt 和 UInt32 长度相同。
• 在 64 位平台上,UInt 和 UInt64 长度相同。
• 尽量不要使用 UInt,除非你真的需要存储一个和当前平台原生字长相同的无符号整数。
  *
• 浮点数
• 浮点数是有小数部分的数字
• Double 表示 64 位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型
• Float 表示 32 位浮点数。精度要求不高的话可以使用此类型
• Double 精确度很高,至少有 15 位数字,而 Float 最少只有 6 位数字。选择哪个类型取决于你的代码需要处理的值的范围。

元祖(tuples)把多个值组成一个复合值。元祖内的值可以使任意类型，并不要求是相同类型。

类型安全和类型推测

 let meaningOfLife = 42
// meaningOfLife 会被推测为 Int 类型
let pi = 3.14159
//pi 会被推测为 Double 类型
//当推测浮点数的类型时,Swift 总是会选择 Double 而不是 Float。

• 数值型字面量
• 一个十进制数,没有前缀
• 一个二进制数,前缀是 0b
• 一个八进制数,前缀是 0o
• 一个十六进制数,前缀是 0x

// 整数转换
//let cannotBeNegative: UInt8 = -1
// UInt8 类型不能存储负数,所以会报错

//let tooBig: Int8 = Int8.max + 1
//Int8 类型不能存储超过最大值的数,所以会报错

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

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

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pii = Double(three) + pointOneFourOneFiveNine
// pi equals 3.14159, and is inferred to be of type Double
let intergerPi = Int(pii)

类型别名

typealias AudioSample = UInt16

定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名

var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound 现在是 0

布尔值

let orangesAreOrange = true
let turnipsAreDelicious = false

当便携条件语句的时候，布尔值非常有用

if turnipsAreDelicious {
    print("Mmm,tasty turnips")
} else {
    print("Eww,turnips are horrible")
}
// Prints "Eww, turnips are horrible."

• 元祖
• 把多个值组合成一个复合值。元组内可以使用任意类型，并不要求是相同类型

let http404Error = (404,"Not Found")    
// http404Error 的类型是 (Int, String),值是 (404, "Not Found")

• 把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。
• 可以将一个元组的内容分解（decompose）成单独的常量和变量

let (statusCode,statusMessage) = http404Error
print("The status code is \(statusCode)")
//prints:"The status code is 404\n"
print("The status message is \(statusMessage)")
//prints:"The status code is 404\n"

如果只需要一部分元祖值，分解的之后可以把要忽略的部分用下划线（_）标记

let (justTheStatusCode,_) = http404Error
print("The status code is \(justTheStatusCode)")
//prints:"The status code is 404\n"

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

let http200Status = (statusCode:200,description:"OK")
//给元组中的元素命名后，你可以通过名字来获取这些元素的值
print("The status code is \(http200Status.statusCode)")
//prints:http200Status.description
print("The status message is \(http200Status.description)")
//prints:"The status message is OK\n"

• 可选
• 使用可选(optionals)来处理值可能缺失的情况。
• 有值，等于x
• 或者 没有值

将一个 String 转换成 Int:

// 将一个 String 转换成 Int:
 let possibleNumber = "123"
 let convertedNumber = Int(possibleNumber)

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

serverResponseCode = nil
// serverResponseCode now contains no value

var survryAnswer:String?
// survryAnswer 设置默认值为nil

在oc中，nil是一个指向不存在对象的指针
在Swift中 ,nil不是指针，它是一个确定的值，表示值缺。

• if 语句以及强制解析
• 使用if语句来判断一个可选是否包含值。如果可选有值，结果是true。如果没有值，结果是false。
• 当你确定可选包确实含值之后，在在选名字后面加一个惊叹号(!)来获取值。

if convertedNumber != nil {
    print("convertedNumber contains some integer value")
}

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

• 可选绑定
• 使用可选绑定来判断可选是否包含值，如果包含就把值赋给一个临时常量或者变量

if let actualNumber = Int(possibleNumber) {
    print("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
} else {
    print("\'\(possibleNumber)\' could not be converted to an integer")
}
//prints:"'123' has an integer value of 123\n"


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

隐式解析可选
- 把想要用做可选的类型后面的问号（String?）改成感叹号（String！）来声明一个隐式解析可选.
- 一个隐式解析可选启示就是一个普通的可选，但是可以被当做非可选来使用，并不需要没次都适用解析来获取可选值

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

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

仍然可以把隐式解析可选当做普通可选来判断它是否包含值

if assumedString != nil {
    print(assumedString)
}

if let definiteString = assumedString {
    print(definiteString)
}
//prints:"An implicitly unwrapped optional string.\n"

• 断言
• 在代码中出发一个断言(assertion)来结束代码运行并通过调试来找到值缺失的原因
• 如果条件判断为true，代码运行会继续进行。 false，代码运行停止，应用被终止。

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