Swift3.0从入门到放弃(二)

• Swift中的数组
  
  • Swift中数组的定义
  • Swift中数组的操作
  • Swift中数组的遍历
  • Swift中数组的合并
• Swift中的字典
  
  • Swift中字典的定义
  • Swift中字典的操作
  • Swift中字典的遍历
  • Swift中字典的合并
• Swift中元组的使用
  
  • Swift中元组与数组和字典的不同使用
• Swift中的可选类型
  
  • Swift中可选类型的使用
  • Swift中可选类型的使用场景
  • Swift中as?和as!的使用

Swift中的数组

在Swift当中数组是Array类型的泛型集合,数组内部元素可以直接放基本数据类型,数组内部元素类型一致。

Swift中数组的定义

// 1.如何定义数组
// 定义不可变数组
let arr : Array<String> = ["陈冠希","张柏芝","谢霆锋"]
let arr01 : [String] = ["陈冠希","张柏芝","谢霆锋"]
let arr02 = ["陈冠希","张柏芝","谢霆锋"]

// 定义可变数组
var arrM : Array<String> = Array()
var arrM01 : [String] = Array()
var arrM02 = Array<String>()
var arrM03 = [String]()

Swift中数组的操作

// 2.对数组的操作
// 2.1增加数组元素
var arrayM = [String]()
arrayM.append("小泽玛利亚")
arrayM.append("武藤兰")
arrayM.append("苍井空")

// 2.2删除数组的元素
// arrayM.removeAll() 删除所有元素
// arrayM.removeFirst() 删除数组第一个元素
// arrayM.removeLast() 删除数组最后一个元素
arrayM.remove(at: 1) // 有返回值，返回删除的那个元素

// 2.3修改数组元素
arrayM[0] = "漩涡鸣人"

// 2.4获取数组元素
let item01 = arrayM.last
let item02 = arrayM[0]

Swift中数组的遍历

// 3数组的遍历
// 3.1 先获取数组的下标 再获取数组的元素
for i in 0..<arrayM.count {
    print(arrayM[i])
}

// 3.2 直接获取数组元素
for item in arrayM {
    print(item)
}

// 3.3 直接一起获取数组的下标和元素
for (index, item) in arrayM.enumerated() {
    print(index,item)
}

Swift中数组的合并

// 4.数组的合并
// 4.1相同元素类型的数组合并
let arr1 = ["山中井野","奈良鹿丸","秋道丁次"]
let arr2 = ["犬冢牙","日向雏田","油女志乃"]
let arr3 = arr1 + arr2

// 4.2不同元素类型数组合并
let arr4 = [16,22,33]
// let arr5 = arr1 + arr4 错误的

Swift中的字典

在Swift中字典是Dictionary类型,由键集合(key)和值集合(value)组成,键和值是成对出现的,值可重复,键不可重复,通过键值访问字典中的元素,字典也是一个泛型集合。

Swift中字典的定义

// 定义不可变字典
let dic_1 : Dictionary<String, Any> = ["name":"本杰明·富兰克林","age":18]
let dic_2 : [String : Any] = ["name":"本杰明·富兰克林","age":18]
// 如果字典中值集合的数据类型不相同 需要添加as 后跟上类型说明
let dic_3 = ["name":"本杰明·富兰克林","age":18] as [String : Any]
// 如果字典中值集合的数据类型相同 不用添补as
// 千言万语一句话,看编译器是否可以自己推导出数据类型
let dic_4 = ["ABC" : 16, "123" : 34]
let dic_5 = ["ABC" : "abc", "123" : "321"]


// 定义可变字典
var dic_01 : [String : Any] = Dictionary()
var dic_02 : Dictionary<String, Any> = Dictionary()
var dic_03 = Dictionary<String, Any>()
var dic_04 = [String : Any]()
var dic_05 = Dictionary() as [String : Any]

Swift中字典的操作

// 对字典的基本操作
var dictM = [String : Any]()

// 增加元素
dictM["name"] = "张一丰"
dictM["age"] = 18
dictM["height"] = 1.88
dictM["gender"] = "男"

// 删除元素
//dictM.removeAll() 删除所有元素
//dictM.removeValue(forKey: "name") 直接根据key值删除元素
//dictM.removeAll(keepingCapacity: true) 删除元素,保留存储空间
let dicIndex = dictM.index(forKey: "age")
dictM.remove(at: dicIndex!)

// 修改元素
dictM["name"] = "程冠希" // 1
dictM.updateValue("女", forKey: "gender") // 2

// 查看元素
print(dictM["name"] as! String)

Swift中字典的遍历

// 遍历字典
// 遍历key值
for key in dictM.keys {
//    print(key)
}

// 遍历value
for value in dictM.values {
//    print(value)
}

// key和value一同遍历
for (key, value) in dictM {
//    print(key, value)
}

Swift中字典的合并

// 字典合并
var dict_one = ["name":"陈冠希","height":1.88] as [String : Any]
let dict_two = ["age":18,"score":59.9]

for key in dict_two.keys {

    dict_one[key] = dict_two[key]
}
print(dict_one)

Swift中元组的使用

元组是Swift中特有的数据类型，OC中没有；跟数组和字典一样，元组也可以用来定义一组数据，组成元组类型的数据可以称为元素。

Swift中元组与数组和字典的不同使用

// Swift当中元组的使用
// 通过数组来保存数据
let infoArray = ["CHW",18,1.88] as [Any]
let infoArray01 : [Any] = ["CHW",18,1.88]
let name = infoArray[0] as! String
print(name.characters.count)

// 通过字典保存数据
let infoDict : [String : Any] = ["name":"CHW", "age":18, "height":1.88]
let dictName = infoDict["name"] as! String
print(dictName.characters.count)

// 通过元组保存数据写法一
let infoTuple = ("CHW", 18, 1.88)
print(infoTuple.0.characters.count)

// 通过元组保存数据写法二(起别名,使用方式最多)
let infoTuple_03 = (nameTp : "CHW", ageTp : 18, heightTp : 1.88)
print(infoTuple_03.nameTp)
print(infoTuple_03.nameTp.characters.count)
print(infoTuple_03.heightTp)

// 通过元组保存数据写法三(更像一次性定义多个标识符)
let (nameT, ageT, heightT) = ("CHW", 18, 18.8)
print(nameT)
print(ageT)
print(heightT)

// 元组可以保存不同数据类型的数据，从元组中取出的数据可以自动类型推导，可以给元组中的元素取别名

Swift中的可选类型

可选类型是Swift中特有的类型，目的在于判断值是否为空，给空值加了一层判断，使我们的程序更加的安全；可选类型的根源是一个枚举类型，里面有None和Some两种类型，其实nil就是Optional.None，非nil就是Optional.Some，然后通过Some<T>包装原始值，也就是在使用可选类型时为什么要拆包(从枚举类型中取出原始值)的原因。

Swift中可选类型的使用

import UIKit

class Person : NSObject
{

    // 一个姓名的属性
    var name : Optional<String> = nil

    // 一个年龄的属性 类型后面跟?号是上面方式的语法糖
    var age : Int? = nil

}

// 初始化一个人类的对象 给其内部两个可选类型的属性赋值
let p = Person()
p.name = Optional("CHW")
p.age = Optional(18)
// 上下两种方式均可
p.name = "CHW"
p.age = 18


//*********************************************
// 获取可选类型的值
//print(p.name) 打印结果: Optional("CHW")
//print(p.age) 打印结果: Optional(18)
print(p.name!) // 强制解包
print(p.age!) // 强制解包


//*********************************************
// 但是直接对可选类型进行强制解包是有危险性的，如果强制解包的对象为空时，程序会crash
// 所以这里引入了一个可选绑定的概念，就是可以在我们使用可选类型时就行空值的判断
if let name = p.name { // 当然我们也可以使用guard，但必须在函数内部
    print("有值 p.name = \(name)")
}

Swift中可选类型的使用场景

import UIKit

// 在实际应用中，如果一个标识符可能为空，就设置其为可选类型

// 案例一
let num1 : String = "123"
let num_01 = Int(num1) // 此时num_01的类型是 Int？ 可选类型，因为上面的num可能转换不成功返回nil
let num2 : String = "abc"
let num_02 = Int(num2)
//print(num_02!) 打印时崩溃 因为为nil

// 案例二
let pathStr = Bundle.main.path(forResource: "", ofType: nil) // pathStr的类型为 String？ 可选类型，因为通过对应的文件名不一定可以获得路径，返回值可能为nil

// 案例三
let urlStr = "https://www.baidu.com"
let url = URL(string: urlStr) // url的类型为 URL？ 可选类型，因为根据对应的字符串有可能创建不出URL对象返回为nil，如字符串中有中文

// 案例四
let dict : [String : Any] = ["name":"CHW", "age":18, "height":1.88]
let item = dict["name"] // item的类型为 Any？可选类型，因为可能通过key值找不到对应的value，返回nil

Swift中as?和as!的使用

import UIKit

// as？和as！在开发中一般用于将一个Any？类型转换为具体类型

let dict : [String : Any] = ["name":"CHW", "age":18, "height":1.88]
let name = dict["name"] // 此时name的类型为 Any? 可选类型，是不能够直接使用的

// as? 可以转换为可选类型，如可以将name的Any?类型转换为String?类型，当系统判定无法转换为String?时返回nil
// 下面是结合可选绑定一起使用
if let name = name as? String {

    print(name)
}

// as! 可以转换为具体类型，如可以直接将name的Any?类型转换为String类型，但是当系统判断转换不成功时，程序就会crash 相当于类型转换 + 强制解包
let name_01 = dict["name"] as! String // 此时name_01是String类型，一般我们确定有值时才使用as! 开发较少使用