Question

相关文章
Swift 快速入门（一）第一个 Swift 程序

1.变量和常量

声明常量和变量

Swfit 是强类型的语言，Swift 要求所有的变量和常量必须先声明后使用。
声明变量需要使用 var，声明常量则需要使用 let

var 变量名[:类型] =初始值
let 常量名[:类型] =初始值

下面来进行举例：

// 声明变量时显式指定类型
var age : Int
// 声明变量时指定初始值，编译器会根据初始值确定该变量的类型为 String
var game= "九阴真经"
// 显式指定的类型与初始值的类型一致，声明变量正确
var age1: Int = 30;
// 显式指定的类型与初始值的类型不一致，声明变量失败
var game1 : String = 500;

// 定义常量，没有显式指定类型，编译器根据初始值确定常量的类型
let maxAge = 120
// 定义常量时，既显式指定常量的类型，也指定常量的初始值
let game2: String = "九阴真经"

输出常量和变量

可以用 print 函数来输出当前常量或变量的值:

print(game) //九阴真经

Swift 用字符串插值（string interpolation）的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义：

print("game 的值为:\(game)") //game 的值为:九阴真经

2.整型

整数就是没有小数部分的数字，比如 23 和-23。整数可以是有符号（正、负、零）或者无符号（正、零）。
Swift 提供了 8，16，32 和 64 位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如 8 位无符号整数类型是 UInt8，32 位有符号整数类型是 Int32。就像 Swift 的其他类型一样，整数类型采用大写命名法。

整型范围

你可以访问不同整数类型的 min 和 max 属性来获取对应类型的最大值和最小值：

let minValue = UInt8.min // minValue 为 0
let maxValue = UInt8.max // maxValue 为 255

Int 型与 UInt 型

Int 型占的内存和当前的平台原生字长相同：对于 32 位平台，Int 型与 Int32 型的长度相同，对于 64 位平台，Int 型与 Int64 型的长度相同。此外 Swift 还支持对无符号整数的支持。但是尽量不要使用 UInt，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用 Int，即使你要存储的值已知是非负的。统一使用 Int 可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推测。即使是在 32 位平台上，Int 可以存储的整数范围也可以达到-2147483648~2147483647，大多数时候这已经足够大了。

整数数值表现形式

Swift 整数数值有 4 种表示方式：

• 十进制：默认的就是十进制整数。
• 二进制：以 0b 开头的整数。
• 八进制：以 0o 开头的整数。
• 十六进制： 以 0x 开头的整数。

let decimalInteger = 17
let binaryInteger = 0b10001 // 二进制的 17
let octalInteger = 0o21 // 八进制的 17
let hexadecimalInteger = 0x11 // 十六进制的 17 

3.浮点型

浮点类型比整数类型表示的范围更大，可以存储比 Int 类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：
Double 表示 64 位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。
Float 表示 32 位浮点数。精度要求不高的话可以使用此类型。

浮点数值表现形式

Swift 的浮点数有 3 中表现形式：

• 十进制形式：这种形式就是平常简单的浮点数，例如 2.23，50.0。浮点数必须包含一个小数点，否则会被当作整数类型处理。
• 科学计数形式：例如 2.23e2(2.23×10²)，2.23E2(2.23×10²)。
• 十六进制数形式：这种形式的浮点数必须以 0x 开头，且需要使用 p 来代表指数部分，例如 0x2.a2p2(0x2.a2×10²)

4.数值型类型转换

整型之间的转换

不同整数类型的变量和常量可以存储不同范围的数字。Int8 类型的常量或者变量可以存储的数字范围是-128~127，而 UInt8 类型的常量或者变量能存储的数字范围是 0~255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：

// UInt 类型不能存储负数，所以会报错
let age: UInt = -1 
// Int8 类型不能存储超过最大值的数，所以会报错 
let big: Int8 = Int8.max + 1 

要将一种数字类型转换成另一种，你要用当前值来初始化一个期望类型的新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量 two 是 UInt16 类型，然而常量 one 是 Uint8 类型。它们不能直接相加，因为它们类型不同。所以要调用 UInt16(one) 来创建一个新的 UInt16 数字并用 one 的值来初始化，然后使用这个新数字来计算：

let two: UInt16 = 2
let one: UInt8 = 1
let third= two+ UInt16(one) 

整数和浮点数转换

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

let three = 3
let point = 0.141596
let add= Double(three) + point // add 等于 3.14159，所以被推测为 Double 类型 

当进行类型转换时要尽量向表数范围大的数据类型转换，这样的程序更安全些，而反过来转换可能会导致运行时的错误。Swift 各种数值型表数范围由小到大顺序：Int8—Int16—Int32—Int64—Float—Double

5.布尔型

Swift 有一个基本的布尔(Boolean) 类型，叫做 Bool，它的数值只能是 true 和 false，不能用 0 或者是非 0 来代表。其他的数据类型也不能转换成 Bool 类型。

var isGame= true
var isShow= false 

字符串”true”和”false”不会直接转换成 Bool 类型，但 Bool 类型变量可以插值到字符串中：

var str:String="\(isGame) 是真的"
print(str)

6.元组类型

定义元组类型变量

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

// 定义元组变量，并指定初始值，系统推断该元组类型为(Int, Int, String)
var game= (1, 2 , "九阴真经")
// 使用元组类型来定义元组变量
var score : (Int , Int , String , Double)
// 为元组变量赋值时必须为所有成员都指定值
score = (98 , 89 , "及格" , 20.4)

元组类型的成员可以再次是元组：

var test : (Int , (Int , String))
test = (20 , (15 , "大航海时代"))

输出元组：

print("game 元组的值为：\(game)")
print("score 元组的值为：\(score)")
print("test 元组的值为：\(test)")

获取元组中的元素值

Swift 允许通过下表来访问元组的单个元素，元组的下标从 0 开始。

print("game 元组的排名元素为：\(game.0)")
print("game 元组的名称元素为：\(game.2)")
print("test 元组的第 2 个元素的第 2 个元素为：\(test.1.2)")

为元组中的元素命名

定义元组时也可以使用 key:value 的形式来定义元组，这种形式相当于为每个元素都指定了名字，并且指定名字有更好的可读性：

// 使用元组类型来定义元组变量
var score : (java:Int , swift:Int , oc:String , ruby:Double)
// 简单为每个元素指定值，此时必须按顺序为每个元素指定值
score = (99 , 60 , "及格" , 20.1) 
// 通过 key 为元组的元素指定值，在这种方式下，元组内各元素的顺序可以调换
score = (oc:"及格" , swift:60 , java:99 , ruby:20.1) 

7.可选类型

可选类型与值缺失

在任何已有类型的后面紧跟？就可以代表是可选类型，可选类型的变量用于处理“值缺失”。
我门先来看看如下代码：

var str = "九阴真经"
var num :Int = str.toInt()//会报错
var num1: Int? = str.toInt()//正确的代码

第二行代码会报错，因为“九阴真经”这个 String 类型无法转换成 Int 类型，如果 str 等于数字型的字符串则会转换成功（如 var str = “11”）。转换失败时，我们无法返回 Int 值，这就是”值缺失”的情况，因此在这里必须使用 Int?类型的变量来储存转换结果，所以第三行代码是正确的。
Swfit 用 nil 来代表”值缺失”,因此上面的 num1 变量的值为 nil。
需要注意的是，只有可选类型的变量和常量才能接收 nil，非可选类型的变量和常量不能接收 nil。

强制解析

Int?类型与 Int 类型不是相同的类型，程序不能把 Int?类型的值当作 Int 类型的。为了获取可选类型的实际存储的值，我们可以在可选类型的值后面加上“！”号。这个叹号表明：已知该可选变量有值，请提取其中的值，这种添加叹号进行解析的方法称之为强制解析。

var str : String? = "九阴真经"
// str 是 String?类型的，不能赋值给 String 类型的 s 变量
var s : String = str//会报错

上面的例子会报错，如果我们这样写则不会有问题：

var s : String = str!
print(s)

强制解析必须是可选类型的变量或者常量确实有值时才能够解析成功，否则会报错。为了去报强制解析不会导致运行是错误，Swift 提供了 if 语句来判断可选类型是否有值，因此上面的语句改为如下的形式比较合适：

var str : String? = "九阴真经"
if str != nil
{
    // 该值是 String 类型，因此可赋值给 String 类型的 s 变量
    var s : String = str!
    print(s)
}else{
    print("str 为 nil，不能强制解析")
}

隐式可选类型

隐式可选就是在任意的已有类型后面添加“！”。拿 Int 类型举例，Int？和 Int！的区别就是：当程序获取 Int？类型的值时，程序必须在变量名后添加“！”后缀来进行强制解析，而 Int！则不需要，Swift 会自动的执行隐式解析：

var s1: String? = "九阴真经"
// 对于 String?可选类型，必须使用感叹号执行强制解析
var tmp : String = s1!
var s2 : String! = "大航海时代"
// 对于 String!隐式可选类型，无需使用感叹号执行强制解析
var tmp2 : String = s2

需要注意的是隐式可选类型的值如果没有值的情况下，如果程序尝试获取该值同样会导致运行时错误，和强制解析一样，我们用 if 语句来判断隐式可选类型是否有值：

var str : String! = "大航海时代"
if str != nil {
// 对于 String!隐式可选类型，无需使用感叹号执行强制解析
var s : String = str
print(s)
}else{
   print("s 为 nil，不能强制解析")
}

可选绑定

可选绑定用来判断可选是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定一般用在 if 和 while 语句中，对可选的值进行判断并把值赋给一个常量或者变量。

var str : String! = "九阴真经"
// 如果可选变量 str 有值，将值赋值给 tmp 变量。
if var tmp = str
{
    print("str 的值为：\(tmp)")
}else{
    print("str 的值为 nil，不能解析！")
}

8.字符和字符串

Swift 使用 Character 来代表字符，String 来代表字符串，字符串表示一个有序的字符集合。

字符类型

Swift 采用 Unicode 字符集来存储字符，字符必须使用双引号来包起来。
定义字符型的值有三种表示形式：

• 直接通过单个字符来指定字符常量，如“A”，”3”。
• 通过转义字符表示特殊字符常量，如“\n”，”\r”。
• 使用\u{n}的 Unicode 形式，其中 n 代表一个 1~8 的十六进制数。

swift 常用的转义字符：
\0 空字符
\ 反斜杠
\ t 制表符
\n 换行符
\r 回车符
\” 双引号
\’ 单引号

字符串类型

创建字符串：

var str="九阴真经"
var name:String="九阴真经"

字符串其实是一个结构体，因此我们可以调用结构体的构造器来创建字符串：

var str=String()//创建空字符串
var str=String("九阴真经")

字符串可变性

在 oc 中有 NSSting 和 NSMutableString 来分别表示不可变和可变的字符串，Swift 中只提供了 String 类型，Swift 通过常量和变量来区分字符串是否可变：

var mutableStr="可变字符串"
let immutableStr="不可变字符串"

字符串比较

Swift 提供了 3 种方式来比较字符串：

• 字符串相等 ==
• 前缀相等 hasPrefix()
• 后缀相等 hasSuffix()

var str="jiuyinzhenjing"
var hasPrefix:Bool=str.hasPrefix("jiu")
print(hasPrefix)//结果为 true

9.类型别名

Swift 提供了类型别名为已有类型指定另一个名字，用 typealias 来定义类型别名：

typealias UintMin=Unit16
var max=UintMin.max//相当于取 Unit16 类型的最大值
print(max)//结果为 65535

在这里不建议用类型别名，会使程序可读性降低。