XZ_Swift之Swift基础第二篇

本篇文章包括的基础概括：数组、字典、元组、可选类型和函数。
一、数组
介绍
数组（Array）是一串有序的由相同类型元素构成的集合；
数组中的集合元素是有序的，可以重复出现；
Swift中的数组是Array，是一个泛型集合；
数组分成:可变数组和不可变数组，使用let修饰的数组是不可变数组，使用var修饰的数组是可变数组
1、初始化

// 定义一个可变数据，必须初始化才能使用var array : [String] = [String]()// 定义不可变数组let array2 : [NSObject] = ["jack" as NSObject,28 as NSObject]或者let array2 : [Any] = ["jack",28]或者let array2 : [AnyObject] = ["jack" as AnyObject,28 as AnyObject]

2、声明
在声明一个Array类型的时候可以使用下列的语句之一

var stuArray1:Array<String>var stuArray2:[String]

声明的数组需要进行初始化才能使用，数组类型往往是在声明的同时进行初始化的

// 定义时直接初始化var array1 = ["jack","rose","mali"]// 先定义，后初始化var array3:Array<String>array3 = ["jack","rose","mali"]

3、数组的基本操作：增、删、查、改

// 添加数据array1.append("lili")// 删除数据array1.removeFirst()// 修改元素array[2] = "enheng"// 查找元素即取值array[0]

4、数组的遍历

// 下标的方式遍历for i in 0...array3.count {    print(array[i])}// for in 方式for item in array3 {    print(item)}// 设置遍历的区间for str in array[0..<3] {    print(str)}

5、数组的合并
注意：只有相同类型的数组才能合并，不建议一个数组中存放多种类型的数据！

var array4 = ["jack","rose"]var array5 = ["jasper","max"]var array6 = array4 + array5

二、字典
介绍
字典运行按照某个键来访问元素;
字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合;
键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的；
swift中的字典类型是Dictionary,也是一个泛型集合；

1、初始化
swift中，使用let修饰的是不可变字典，使用var修饰的是可变的字典

// 定义一个可变字典var dict : [String : NSObject] = [String : NSObject]()// 定义一个不可变字典let dict1 = ["name":"jack","sex":"male”]

2、声明
在声明的时候也可以使用以下方式：

var dict2 : Dictionary<Int,String>var dict3 : [Int:String]

声明的字典要进行初始化才能使用，字典类型往往是在声明的同时进行初始化的

// 定义字典的同时进行初始化var dic = ["name":"jack","age":18] as [String : Any]// swift中任意对象，通常不使用NSObject，使用AnyObjectvar dic1 : NSDictionarydic1 = ["name":"jack","age":18]

3、基本操作：增、删、查、改

// 添加数据dic["height"] = 1.8dic["weight"] = 70// 删除字段dic.removeValue(forKey: "weight”)// 修改字典dic["age"] = 20// 查询字段let nameStr = dic["name"]

4、字典的遍历

 // 遍历所有的键值for key in dic.keys {    print(key)}// 遍历所有的值for value in dic.values {    print(value)}// 遍历所有的键值对for (key,value) in dic {    print(key)    print(value)}

5、字典的合并

var dic2 = ["name":"jack","age":20] as [String : Any]var dic3 = ["height":1.80,"phoneNum":"+10086"] as [String : Any]// 字典不可以相加合并for (key,value) in dic2 {    dic3[key] = value}

三、元组
介绍
元组是swift中特有的，oc中并没有相关类型。它是一种数据结构，可以用于定义一组数据，在数学中应用广泛，类似于数组或字典，组成元组类型的数据可以称为“元素”。
定义
常见写法

// 使用元组描述一个人的信息("001","jack",20,1.80)// 给元素加上名称，之后可以通过元素名称访问元素(id:"001",name:"jack",age:20,height:1.80)

简单使用
用元组来描述一个HTTP的错误信息

// 元组：HTTP错误// 写法一：let error = (404,"Not Found")print(error.0)print(error.1)// 写法二:let error1 = (errCode:404,errMsg:"Not Found")print(error1.errCode)print(error1.errMsg)// 写法三：let (errCode,errMsg) = (404,"Not Found")print(errCode)print(errMsg)

四、可选类型
介绍
在OC开发中，如果一个变量暂时不使用，可以赋值为0（基本属性类型）或者赋值为空（对象类型）；
在swift开发中，nil也是一个特殊的类型，因为和真实的类型不匹配是不能赋值的（swift是强类型语言）；
但是，在开发中赋值nil，在所难免，因为推出了所选类型。

可选类型的取值
空值和有值两个。

可选类型的定义
有2中写法：1、最基本的写法；2、语法糖写法（常用）

// 错误写法let string : String = nil// 正确写法// 注意：name的类型是一个可选类型，但是该可选类型中可以存放字符串。// 写法一：基本写法let name : Optional<String> = nil// 写法二：语法糖let name1 : String? = nil

可选类型的使用

// 给可选类型赋值var stri : String? = nil// 错误赋值：因为该可选类型只能存放字符串// stri = 13// 正确赋值：stri = “happy"// 打印结果1：Optional("happy”)，因为打印的是可选类型，所以会带Optionalprint(stri as Any)// 打印结果2：happyprint(stri!) // 取出可选类型的真实值（解包）

注意：如果可选类型为nil，强制取出其中的值（解包），会出错

// 打印结果3：stri = nil;print(stri!) //fatal error: unexpectedly found nil while unwrapping an Optional value// 正确写法：if stri != nil {   print(stri!)}// 简单写法：为了在if语句中方便使用String// 可选绑定let string : Optional<String> = nilif let str = string {   print(str)}

真实应用场景
目的：让代码更加严谨
通过该方法创建的URL，可能有值，也可能没有值。

// 如果字符串中有中文,则返回值为nil,因此该方法的返回值就是一个可选类型,而使用一个NSURL类型接收是错误的// 错误写法：如果返回值是nil时,就不能接收了// let url : NSURL = NSURL(string: "www.baidu.com")// 正确写法：let url : NSURL? = NSURL(string: "www.baidu.com")// 该方式利用类型推导let url3 = NSURL(string: "www.baidu.com”)// 通过url来创建request对象：在使用可选类型前要先进行判断是否有值// 该语法成为可选绑定（如果url有值就解包赋值给tempURL,并且执行{}）if let tempUrl = url {    let request = NSURLRequest(url: tempUrl as URL)}

五、函数
介绍
函数相当于OC中的方法
格式如下：
func 函数名(参数列表) -> 返回值类型 {
// 代码块
return 返回值
}

注意：
func是关键字，多个参数列表之间使用逗号（,）隔开，也可以没有参数；
使用箭头 “->” 指向返回值类型；
如果函数没有返回值，返回值为Void。并且“->返回值类型”部分可以省略。

常见的函数类型

// 1.没有参数，没有返回值func running() -> Void {    print("在跑步")}// 简单写法：如果没有返回值，Void可以写成()func running1() -> () {   print("在跑步")}// 如果没有返回值，后面的内容也可以不写func running2() {   print("在跑步")}// 调用running()// 2.有参数，没有返回值func eat(thing:String) {   print("吃\(thing)")}// 调用eat(thing: "Apple")// 3.没有参数，有返回值func eatEnough() -> String {   return "吃饱了"}// 调用et result = eatEnough()print(result)// 4.有参数，有返回值func eat(something:String) -> String {   return "吃\(something),没吃饱”}// 调用let str = eat(something: "馒头")print(str)// 有多个参数，有返回值func sum(num1 : Int, num2 : Int) -> Int {   return num1 + num2}// 调用var result1 = sum(num1: 20, num2: 30)print(result1)

函数的使用注意
一：外部参数和内部参数
在函数内部可以看到的参数，就是内部参数；
在函数外面可以看到的参数，就是外部参数；
默认情况下，从第二个参数开始，参数名称既是内部参数也是外部参数；
如果第一个参数也想要有外部参数，可以设置标签：在变量名前加标签即可；
如果不想要外部参数，可以在参数名称前加_

// num1和a是外部参数的名称func multiplied(num1 num1:Int,a num2:Int, b num3:Int) -> Int {   return num1 * num2 * num3}// 调用var result = multiplied(num1: 3, a: 4, b: 5)// 方法的重载：方法名称相同，但是参数不同，可以称之为方法的重载func multiplied(num1:Int,num2:Int) -> Int {    return num1 * num2}// 调用var result = multiplied(num1: 3, num2: 4)

注意二：默认参数
某些情况，如果没有传入具体的参数，可以使用默认参数

func eatBreakFast(type:String = "egg") -> String {    return "the breakFast is \(type)."}// 调用let bread1 = eatBreakFast()let bread2 = eatBreakFast(type: "bread")

注意三：可变参数
swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数；
它们必须具有相同的类型；
我们可以通过在参数类型后面加入（…）的方式来指示这是可变参数

func sum(numbers:Int...) -> Int {     var total : Int = 0     for number in numbers {         total += number     }     return total}// 调用let total = sum(numbers: 1,2,3)

注意四：引用类型（指针的传递）
默认情况下，函数的参数是值传递。如果想改变外面的变量，则需要传递变量的地址；
必须是变量，因为需要在内部改变其值；
swift提供的in/out关键字就可以实现；
对比下列两个函数

// 函数一：值传递func transfer( a : Int , b : Int){    var b = b    var a = a    let temp = a;    a = b;    b = temp;    print("a:\(a),b:\(b)")}// 调用let a = 3let b = 4transfer(a:a,b:b)print("a:\(a),b:\(b)")// 函数二:指针的传递func transfer1( a: inout Int, b: inout Int) {    let temp = a;    a = b;    b = temp;    print("a:\(a),b:\(b)")}// 调用var a = 3var b = 4transfer1(a:&a,b:&b)print("a:\(a),b:\(b)”)

函数的嵌套使用
swift中函数可以嵌套使用；即函数中包含函数，但是不推荐该写法；

// 函数的嵌套let value = 40func nest() {  func test(){      print("\(value)")  }  print("nest")      test()  }// 调用:执行函数会先打印'nest',再打印‘test’nest()