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，使用AnyObject
var dic1 : NSDictionary
dic1 = ["name":"jack","age":18]

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

// 添加数据
dic["height"] = 1.8
dic["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”)，因为打印的是可选类型，所以会带Optional
print(stri as Any)
// 打印结果2：happy
print(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> = nil
if 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 = 3
let b = 4
transfer(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 = 3
var b = 4
transfer1(a:&a,b:&b)
print("a:\(a),b:\(b)”)

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

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