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,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

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