Swift学习- 元祖&& 可选类型 && 类型转化&& 函数

元组

元组的介绍

• 元组是Swift中特有的,OC中并没有相关类型
• 它是什么呢?
  • 它是一种数据结构，在数学中应用广泛
  • 类似于数组或者字典
  • 可以用于定义一组数据
  • 组成元组类型的数据可以称为“元素”

元组的定义

• 元组的常见写法

// 使用元组描述一个人的信息
("1001", "张三", 30, 90)
// 给元素加上元素名称,之后可以通过元素名称访问元素
(id:"1001", name:"张三", english_score:30, chinese_score:90)

元组的简单使用

• 用元组来描述一个HTTP的错误信息

// 元组:HTTP错误
// let array = [404, "Not Found"]
// 写法一:
let error = (404, "Not Found")
print(error.0)
print(error.1)

// 写法二:
let error = (errorCode : 404, errorInfo : "Not Found")
print(error.errorCode)
print(error.errorInfo)

// 写法三:
let (errorCode, errorIno) = (404, "Not Found")
print(errorCode)
print(errorIno)

可选类型

可选类型的介绍

• 注意:
  • 可选类型时swift中较理解的一个知识点
  • 暂时先了解,多利用Xcode的提示来使用
  • 随着学习的深入,慢慢理解其中的原理和好处
• 概念:
  • 在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)
  • 在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强类型语言)
  • 但是开发中赋值nil,在所难免.因此推出了可选类型
• 可选类型的取值:
  • 空值
  • 有值

定义可选类型

• 定义一个可选类型有两种写法
  • 最基本的写法
  • 语法糖(常用)

// 错误写法
// let string : String = nil
// 正确写法:
// 注意:name的类型是一个可选类型,但是该可选类型中可以存放字符串.
// 写法一:定义可选类型
let name : Optional = nil

// 写法二:定义可选类型,语法糖(常用)
let name : String? = nil

可选类型的使用

// 演练一:给可选类型赋值
// 定义可选类型
var string : Optional = nil

// 给可选类型赋值
// 错误写法:因此该可选类型中只能存放字符串
string = 123
// 正确写法:
string = "Hello world"

// 打印结果
print(string)
// 结果:Optional("Hello world")\n
// 因为打印出来的是可选类型,所有会带Optional


// 演练二:取出可选类型的值
// 取出可选类型的真实值(解包)
print(string!)
// 结果:Hello world\n

// 注意:如果可选类型为nil,强制取出其中的值(解包),会出错
string = nil
print(string!) // 报错

// 正确写法:
if string != nil {
    print(string!)
}

// 简单写法:为了让在if语句中可以方便使用string
// 可选绑定
if let str = string {
    print(str)
}

真实应用场景

• 目的:让代码更加严谨

// 1.将字符串类型转成Int类型
let str = "123"
let result : Int? = Int(str) // nil/Int


// 2.根据文件名称,读取路径
let path : String? = Bundle.main.path(forResource: "123.plist", ofType: nil)


// 3.根据string,创建URL
let url = URL(string: "http://www.520it.com/小码哥")


// 4.从字典中取内容
let dict : [String : Any] = ["name" : "why", "age" : 18]
dict["name"]
dict["height"]

类型转化

常见的类型转化符号

• as : 将实例转成某一种类型

例子

// 1.定义数组
let array : [AnyObject] = [12, "why", 1.88]

// 2.取出第二个元素
let objc = array[1]

// 3.将objc转成真正的类型来使用
// 3.1.as? 将AnyObject转成可选类型,通过判断可选类型是否有值,来决定是否转化成功了
let age = objc as? Int
print(age) // 结果:Optional(12)

// 3.2.as! 将AnyObject转成具体的类型,但是注意:如果不是该类型,那么程序会崩溃
let age1 = objc as! Int
print(age1) // 结果:12

---

import UIKit

var str = "Hello, playground"
/*
 元祖
 */

//1. 数组存储数据
let infoArray : [Any] = ["why", 18, 1.88]
let arrayName = infoArray[0] as! String
print(arrayName.characters.count)

//2. 使用字典
let infoDict : [String : Any] = ["name" : "ahy",  "age": 2.2]
let dictName = infoDict["name"] as! String
print(dictName.characters.count)


//3.元祖
let infoTuple = ("ahy", 15, 1.22)
let tupleName = infoTuple.0
let tupleAge = infoTuple.1

//3.2 写法二
let infoTuple1 = (name : "ahy", age : 10)
infoTuple1.name
infoTuple1.age

/*** 可选类型 *
 概念:
 在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)
 在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强类型语言)
 但是开发中赋值nil,在所难免.因此推出了可选类型
 可选类型的取值:
 空值
 有值
 
 */

/*
 定义一个可选类型有两种写法
 最基本的写法
 语法糖(常用)
 */
// 错误写法
// let string : String = nil
// 正确写法:
// 注意:name的类型是一个可选类型,但是该可选类型中可以存放字符串.
// 写法一:定义可选类型
let name : Optional = nil

// 写法二:定义可选类型,语法糖(常用)
let name2 : String? = nil

//>>>>>>可选类型的使用
//给可选类型赋值
var name3 : String? = nil
//2.1赋值方式一：
name3 = Optional("why")

//2.2 赋值方式二
name3 = "ahy"

//3. 取出可选类型中的值
print(name3!)

//从可选类型中取值： 可选类型 + ! ---> 强制解包
//注意： 如果可选类型为nil，则强制解包就会奔溃
print(name3!)

//5. 可选绑定：该语法适用于可选类型,如有没值则不进入括号，如果有值则会强制解包并赋值给temp
if let temp = name3 {
    print(temp)
}
//>>>>>>>>>使用场景
//1.将字符串类型转成Int类型
let str2 = "123"
let result : Int? = Int(str2)



//2.根据文件名称， 读取路径, path 可有值也有没值，所以用可选类型
let path : String? = Bundle.main.path(forResource: "123.plist", ofType: nil)
//3. 根据string， 创建URL URL的返回值就是一个可选类型
let url = URL(string: "http://www.fff.com")

//4，从字典中取出内容
let dict: [String : Any] = ["name" : "why", "age" : 18]
let nn =  dict["name"] //安装option看nn ->  let nn: Any?
print(nn!)

---

//-----类型转换 as
//1. as : 将实例转成某一种类型

let str0 = "www.baidu.com"
(str0 as NSString).substring(to: 5)

//2. as? 用法
let dict : [String : Any] = ["name" : "why", "age" : 18, "height" : 1.22]
//as？ 转成的类型是一个可选类型，系统会自动判断tempName 是否可以转成String，如果可以转成，那么获取字符串，如果转化不成功，则返回nil
let tempName = dict["name"]

if let name = dict["name"] as? String {
    print(name)
}

//2.2 as! 用法
/*
 as！ 转成具体类型
 注意： 如果转化成功，再用as!, 不过不成功，则奔溃，不建议使用
 */

let tempName1 = dict["name"]
let name1 = tempName1 as! String

//---------- -函数的使用- ---------------------------
/*
 注意一: 外部参数和内部参数
 在函数内部可以看到的参数,就是内部参数
 在函数外面可以看到的参数,就是外部参数
 默认所有的参数都是外部参数和内部参数
 如果不想要外部参数,可以在参数名称前加_ func sum ( _ num1: Int,  _ num2 : Int) -> Int
 */

//1.内部参数 && 外部参数
//内部参数 num1, num2
//
//func sum (num1: Int, num2 : Int) -> Int {
//    return num1 + num2
//}
//
//let result = sum(num1: 11, num2: 22)


//修改外部参数
//func sum ( abc num1: Int,   num2 : Int) -> Int {
//    return num1 + num2
//}
//let result = sum(abc : 20, num2: 30)

//不要外部参数
func sum ( _ num1: Int,  _ num2 : Int) -> Int {
    return num1 + num2
}
let result = sum(20, 30)

//2.可变参数
/*
 nums 外部参数

 */
func sum(nums : Int...) -> Int {
    var total = 0
    for num in nums {
        total += num
    }

    return total
}


sum(nums: 20, 30, 40, 50)


func myPrint(_ items : Any...) {

    var strM : String = "\(items[0])"

    for i in 1..

函数

函数的介绍

• 函数相当于OC中的方法
• 函数的格式如下

func 函数名(参数列表) -> 返回值类型 {
    代码块
    return 返回值
}

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

常见的函数类型

// 1.没有参数,没有返回值的函数
func about() -> Void {
    print("iPhone7")
}
about()

func about1() {
    print("iPhone7")
}

about1()

// 2.有参数, 没有返回值的函数
func callPhone(phoneNum : String) {
    print("打电话给\(phoneNum)")
}

callPhone(phoneNum: "+86 110")


// 3.没有参数, 有返回值的函数
func readMsg() -> String {
    return "吃饭了吗?"
}

let msg = readMsg()

// 4.有参数有返回值的函数
func addTwoNum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}

let result = addTwoNum(num1: 20, num2: 30)

函数的使用注意

• 注意一: 外部参数和内部参数
  • 在函数内部可以看到的参数,就是内部参数
  • 在函数外面可以看到的参数,就是外部参数
  • 默认所有的参数都是外部参数和内部参数
  • 如果不想要外部参数,可以在参数名称前加_

// 1.内部参数&外部参数
/*
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}

sum(num1: 20, num2: 30)
*/

/*
func sum(_ num1 : Int,_ num2 : Int) -> Int {
    return num1 + num2
}

sum(20, 30)
*/

func sum(abc num1 : Int, cba num2 : Int) -> Int {
    return num1 + num2
}

sum(abc: 20, cba: 30)


// sum(20, 30)

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

// 2.可变参数
func sum(nums : Int...) -> Int {
    var total = 0
    for num in nums {
        total += num
    }

    return total
}


sum(nums: 20, 30, 40, 50)

func myPrint(_ items : Any...) {

    var strM : String = "\(items[0])"

    for i in 1..

• 注意三: 默认参数
  • 某些情况,如果没有传入具体的参数,可以使用默认参数

func makeCoffee(coffeeName : String = "雀巢") {
    print("制作了一杯爱心\(coffeeName)咖啡")
}

makeCoffee(coffeeName: "拿铁")
makeCoffee(coffeeName: "摩卡")
makeCoffee()

• 注意四: 引用类型(指针的传递)
  • 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
  • 必须是变量,因为需要在内部改变其值
  • Swift提供的inout关键字就可以实现
  • 对比下列两个函数

// 4.指针参数
var m = 20
var n = 30

func swapNum(num1 : inout Int, num2 : inout Int) {
    let temp = num1
    num1 = num2
    num2 = temp
}

swap(&m, &n)

print("m:\(m) n:\(n)")