Swift 基础部分(一)

基础部分

Swift的类型是在C和Objective-C的基础上改进，Int是整型，Double和Float是浮点型，Bool是布尔型，String是字符串，Array和Dictionary是集合，还有一些其他语言没有的比如元组，元组可以创建或传递一组数据，比如作为函数的返回值，可以用元组来返回多个值
Swift增加了可选类型（Optional），用于处理值的缺省情况，类似OC中的nil，可以用在任何类型上，不仅是类
Swift是一个类型安全的语言，可选(Optional)就是很好的例子，可让你清楚的知道一个值的类型，如果期望得到一个String，类型安全会阻止你以外的传入一个Int，并且可以在开发的时候就发现这种错误

Swift增加了可选类型（Optional），用于处理值的缺省情况，类似OC中的nil，可以用在任何类型上，不仅是类
Swift是一个类型安全的语言，可选(Optional)就是很好的例子，可让你清楚的知道一个值的类型，如果期望得到一个String，类型安全会阻止你以外的传入一个Int，并且可以在开发的时候就发现这种错误

1.常量和变量

变量和常量在使用前必须先定义，变量使用var定义，常量使用let定义，常量的值一旦设定不能再改变，而变量可以多次赋值

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

以上例子中，看定义的名称大约也可以猜出来是什么意思了，定义一个不可变的常量，表示最大的登录尝试次数，定义一个变量，表示当前已经尝试过的登录次数
也可以在一行中定义多个变量或常量

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

2.类型标注

可以在定义常量或变量的时候提供一个类型标注，指明所定义的值是什么类型的，在变量或常量后面添加一个冒号，其次是类型名称，以下是定义了一个变量，类型是字符串String类型

var welcomeMessage: String

然后这个字符串变量又可以随意赋其他的值了

welcomeMessage = "Hello"

一般来说添加类型注释是比较少用的，如果你在定义的时候提供了一个初始值，那编译器就会识别定义的变量或常量的类型，而不需要再指定
变量名或常量名可以使用unicode字符

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

虽然说可以使用unicode来定义，但也要遵守一些规则，不能使用数学运算符，箭头，代码点还有一些什么畸形的符号什么的（保留的或非法的Unicode码），也不能以数字开头

一旦确定了一个常量或变量的类型，就不能再用相同的名字再定义了，或存储不同类型的值，也不能把变量改为常量，也不能把常量改为变量
变量可以再赋一个相同类型的值，而常量一旦设定就不能再改变了

var friendlyWelcome = "Hello!"
friendlyWelcome = "Bonjour!"
// friendlyWelcome is now "Bonjour!"
let languageName = "Swift"
languageName = "Swift++"
// this is a compile-time error - languageName cannot be changed

使用println方法打印，就像Objective-C里的NSLog，使用反斜线和小括号显示变量

println("This is a string")
println("The current value of friendlyWelcome is \(friendlyWelcome)")

注释，跟其他类型语言的注释一样，自己体会

// this is a comment
/* this is also a comment,
but written over multiple lines */
/* 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 */

分号，分号在这里已经不是必须的了，不过也要分清场合，如果你要在一行写多个语句，分号就不能省了

let cat = "cat"; println(cat)

3.整数

整数就是没有小数部分的数字，可以使有符号（正、负、零）和无符号（正、零）
Swift提供了8、16、32和64位的有符号和无符号整数类型，分别命名为Uint8,UInt16,UInt32,UInt64

整数范围

访问不同类型的min和max属性来获取相应类型的最小和最大值

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

Int

Swift提供一个特殊的整数类型Int，长度根据当前系统的字长相同，不需专门指定，在32位平台上，Int长度和Int32相同，在64位平台上，Int长度和Int64相同，Int32的存储范围为 -2147483648~2147483647

UInt

无符号类型，但尽量不要用，除非真的需要存储一个跟当前平台字长相同的无符号整数，推荐使用Int

浮点数

有小数部分的数字，浮点类型比整数类型表示的范围更大，Swfit有两种：Double，表示64位浮点数，精度至少有15位，当需要存储很大或者精度很高的浮点数时使用，Float，表示32位浮点数，只有6为数字的精度

4.类型安全和类型推测

Swift是类型安全的语言，可让你清楚的知道代码需要处理的值得类型，如果代码需要一个String，绝不可能传入Int，如果遇到不匹配就会报错，在开发的时候就可以看到
如果没有显示指定类型，Swift会使用类型推测来选择合适的类型，编译器会根据你赋的值来自动推测表达式的类型
举例如果给一个常量赋值42但没有标明类型，Swift会推出类型是Int

let meaningOfLife = 42
// meaningOfLife is inferred to be of type Int

如果没有给浮点数标明类型，Swift会推出类型是Double，当推测浮点数时，优选选择Double而不是Float

let pi = 3.14159
// pi is inferred to be of type Double
let anotherPi = 3 + 0.14159
// anotherPi is also inferred to be of type Double

5.进制表示法

以下是用十进制、二进制、八进制和十六进制来表示17

let decimalInteger = 17
let binaryInteger = 0b10001       // 17 in binary notation
let octalInteger = 0o21           // 17 in octal notation
let hexadecimalInteger = 0x11     // 17 in hexadecimal notation

6.Numberic Type Conversion 数值类型转换

Integer Conversion整数的转换

每种数值类型能表示的数字范围是不一样的，Int8能表示的范围是-128到127之间，UInt8能表示的范围为0到255之间，如果赋的值与数值类型不一致将会在编译的时候报错

let cannotBeNegative: UInt8 = -1
// UInt8 cannot store negative numbers, and so this will report an error
let tooBig: Int8 = Int8.max + 1
// Int8 cannot store a number larger than its maximum value,
// and so this will also report an error

因为每个数值类型都可以存储不同范围的值，所以必须在转换的时候指定一个数值类型，以防止转换错误

以下例子中，2000是UInt16类型，1是UInt8类型，如果想要两数相加操作，需要把把他们转换为同一种类型

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

Integer and Floating-Point Conversion 整数和浮点数之间的转换

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

在这里，3由Int型转换为Double型，这样两种类型相同才能相加，否则编译不通过
反过来，浮点数转换为整数会丢失精度

let integerPi = Int(pi)
// integerPi equals 3, and is inferred to be of type Int

7.Type Aliased 类型别名

类似linux中的alias，可以给类型取别名，给类型取别名后就可以直接使用它的属性

typealias AudioSample = UInt16
var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound is now 0

8.Booleans 布尔类型

let orangesAreOrange = true
let turnipsAreDelicious = false

if turnipsAreDelicious {
    println("Mmm, tasty turnips!")
} else {
   println("Eww, turnips are horrible.")
}
// prints "Eww, turnips are horrible."


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
}

9.Tuples 元组

元组相当于一个key对应多个value，把多个值组合成一个复合值，value的类型可以是不同的

let http404Error = (404, "Not Found")
// http404Error is of type (Int, String), and equals (404, "Not Found")
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"

也可以使用下标代替元组的值，下标从0开始

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")
println("The status code is \(http200Status.statusCode)")
// prints "The status code is 200"
println("The status message is \(http200Status.description)")
// prints "The status message is OK"

作为函数返回值，元组非常有用，相比只能返回一个类型的值比起来，元组能让函数返回值更丰富

10.Optional 可选

使用Optional来处理值可能缺失的情况，一个方法要么返回一个对象，要么返回nil，但这只对对象起作用，对结构体、基本C类型或者枚举类型不起作用，OC方法一般会返回一个特殊值表示值的缺失，然而Swift的Optional可让你暗示任意值的缺失，而不需要特殊的值
例子：String有个toInt的方法将String类型转换为Int类型，但是toInt方法可能会失败，所以返回的是一个Optional的Int，而不是一个Int，Optional的Int写作 Int? 问号表示包含的值是可选的，可能有值也可能为空

let possibleNumber = "123"
let convertedNumber = possibleNumber.toInt()
// convertedNumber is inferred to be of type "Int?", or "optional Int"

if语句以及强制解析
用if语句判断一个Optional是否包含值，当确定Optional是有值的时候，在后面加叹号 ! 来获取这个值，表示我切确的知道这是有值的，被成为强制解析，但是获取一个不存在的Optional的值的话会导致运行时错误，请一定确认Optional包含一个非nil的值才使用 !

if convertedNumber {
   println("\(possibleNumber) has an integer value of \(convertedNumber!)")
} else {
   println("\(possibleNumber) could not be converted to an integer")
}
// prints "123 has an integer value of 123"

可选绑定
使用可选绑定来判断Optional是否包含值，如果包含则把值赋给一个临时变量或常量，可选绑定用在if和while之间来对可选的值进行判断并把值赋给常量或变量

if let constantName = someOptional {
   statements
}

以下可理解为：如果possibleNumber.toInt 返回的可选值Int包含一个值，则新建一个actualNumber的常量并赋值给他，actualNumber的值可在if语句中使用，并且已经初始化，不需要用 ! 来取值

if let actualNumber = possibleNumber.toInt() {
   println("\(possibleNumber) has an integer value of \(actualNumber)")
} else {
   println("\(possibleNumber) could not be converted to an integer")
}
// prints "123 has an integer value of 123"

nil
给变量赋值为nil，表示没有值，如果声明了一个常量或变量没有赋值，则会自动被设置为nil

var serverResponseCode: Int? = 404
// serverResponseCode contains an actual Int value of 404
serverResponseCode = nil
// serverResponseCode now contains no value
var surveyAnswer: String?
// surveyAnswer is automatically set to nil

Swift中的nil和OC中的nil并不一样，在OC中，nil是一个指向空对象的指针，在Swift中，nil是一个确定的值，表示值的缺失，任何类型都可以赋值为nil

Implicitly Unwrapped Optionals 隐式解析可选
Optional表示常量或变量可以没有值，通过if来判断是否有值，如果通过可选绑定来解析值，但在第一次被赋值之后，就可以确定一个可选值总会有值的了，这样的话每次再去判断和解析Optional值就会变得低效了
这样类型的可选定义为隐式解析可选，把 ? 改成 ! 来声明一个隐式解析可选，比如String!， 一个隐式解析可选其实就是一个普通的可选，但可以当做非可选来用，并不需要每次都使用解析来获取可选值

let possibleString: String? = "An optional string."
println(possibleString!) // requires an exclamation mark to access its value
// prints "An optional string."
 
let assumedString: String! = "An implicitly unwrapped optional string."
println(assumedString)  // no exclamation mark is needed to access its value
// prints "An implicitly unwrapped optional string."

11.Assertions 断言

断言在运行时判断一个条件是否为true，使用断言来保证在运行其他代码的时候，某些重要条件已经得到满足，否则代码终止
使用全局函数assert函数来写一个断言，给assert函数传入一个结果为true或false的表达式以及一条信息，当表达式为false的时候这条信息显示出来

let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// this causes the assertion to trigger, because age is not >= 0