美文网首页
Swift学习- 元祖&& 可选类型 &

Swift学习- 元祖&& 可选类型 &

作者: 天下林子 | 来源:发表于2018-08-20 09:48 被阅读14次

    元组

    元组的介绍

    • 元组是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<String> = nil

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

    可选类型的使用

    // 演练一:给可选类型赋值
// 定义可选类型
var string : Optional<String> = 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<String> = 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..<items.count {
        strM = strM + " " + "\(items[i])"
    }

    print(strM)
}

print(20, 30, 40)
myPrint(20, 30, 40)

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

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

//指针参数
//inout 就可以传入地址
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)")

//-------监听属性的改变--------------
class Person : NSObject {
    var name : String? {
        // 可以给newValue自定义名称
        willSet (new){ // 属性即将改变,还未改变时会调用的方法
            // 在该方法中有一个默认的系统属性newValue,用于存储新值
            print(name)
            print(new)
        }
        // 可以给oldValue自定义名称
        didSet (old) { // 属性值已经改变了,会调用的方法
            // 在该方法中有一个默认的系统属性oldValue,用于存储旧值
            print(name)
            print(old)
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在赋值时,监听该属性的改变
// 在OC中是通过重写set方法
// 在swift中,可以给属性添加监听器
p.name = "why"

//p.name = "yz"

    函数

    函数的介绍

    • 函数相当于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..<items.count {
        strM = strM + " " + "\(items[i])"
    }

    print(strM)
}

print(20, 30, 40)

myPrint(20, 30, 40)
    • 注意三: 默认参数
      • 某些情况,如果没有传入具体的参数,可以使用默认参数
    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)")

    相关文章

      网友评论

          本文标题：Swift学习- 元祖&& 可选类型 &

          本文链接：https://www.haomeiwen.com/subject/oprkiftx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|Swift学习- 元祖&& 可选类型 &|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！