SWift基本语法（二）

一 可选类型知识点补充

例一 :强转并且制定类型

let str01 = "23"  //打印结果: "23"
let age : Int? = Int(str01) //打印结果 :23

问题 : 该例子转化的结果为什么需要用可选类型来接收?

解答 : 因为很有可能是转化不成功的,如果此时不用可选类型来接收的话,万一转化失败,那么该值就为空(nil),如果不选择可选类型来接收,程序会崩溃.

例二 : 获取某个plist文件的路径

let path : String? = Bundle.main.path(forResource: "xiaofeng.plist", ofType: nil)

if let path = path {
NSArray(contentsOfFile: path)
}

—-> 2.1 这里同样需要用可选类型来接收,原因是很有可能找不到名字为”xiaofeng”的plist文件,如果此时不用可选类型来接收,值为nil,程序会崩溃.
—-> 2.2 在此句后面写一个判断语句更加安全的判断是否可以取成功.判断的好处如下:
—> 2.2.1 判断path是否有值,如果没有值的话,就不执行{}中的内容
—> 2.2.2 如果path有值,那么系统就会对path进行解包,并且将解包的结果赋值

例三 : 获取一个NSURL

let url : NSURL? = NSURL(string: "www.baidu.com") 
//打印结果:www.baidu.com
if let url = url { NSURLRequest(url : url as URL )
print(url)
//<NSURLRequest: 0x7fd050d18610> { URL: www.baidu.com }
}

—-> 3.1 如果不加判断或者将获取到的值不用可选类型来接收的话,那么当url是下面这种类型,就获取不到.不用选类型来接收是会报错的.
url中出现了中文,并且没有用可选类型来接收值,系统会报错
系统包的错误: cannot convert value of type ‘NSURL?’ to specified type ‘String’
let url02 : String = NSURL(string: “www.baidu.com/百度”)!
—-> 3.2 如果用if做出了判断,此时能更加安全的对url进行操作,判断url是否获取成功,成功的话就将url解包.

例四 : 在保证一个可选类型一定有值的前提下,可以直接强制解包

4.1 如果此时的123.plist文件存在的话,就可以强制解包(通过按住option点击path1可以看出,path1的类型是可选类型)

let path1 = Bundle.main.path(forResource:"123.plist", ofType: nil)

二 is; as?; as!的用法

is : 用来判断某种类型是不是另外一种类型(用法比较简单)

let array = [12,"xiaofeng",1.89] as [Any]
let arrayM = [NSObject]()//定义数组,内部的元素是NSObject类型

判断取出的第一个元素是不是整型

if let firstObject = array.last {
    if firstObject is Int {
        print("是Int类型")    //打印结果:"是Int类型\n"
}else{
    print("不是Int类型")
}
}

as? : 转成的最终类型是一个可选类型(需要作出判断)

let dict = ["name" : "xiaofeng", "age" : 20, "height" : 1.88] as [String : Any]
let value = dict["name"] 
//通过按住option点击value,可以看出类型为可选类型

将NSObject转成String类型

if let value = value {
//此处value as? String也有可能转失败
let valueStr : String? = value as? String
//判断是否能转成功
if let valueStr = valueStr {
    let info = "my name is " + valueStr //最终结果:"my name is xiaofeng"
}
}

2.1 简便写法判断NSObject? 转 String

if let valueStr = value as? String {
let info = "my name is " + valueStr //打印结果 :"my name is xiaofeng"
}

as! : 转成的最终类型就是具体的类型(NSObject? 转成 String)

—-> 3.1 此方法的后果: 如果用这种方法转化不成功,那么程序会直接崩溃

let info = "my name is " + (value as! String) //打印结果 :"my name is xiaofeng"

内部参数和外部参数

—-> 4.1 含义: 内部参数: 在函数内部可以看到的参数,就是内部参数;外部参数: 在函数外面可以看到的参数,就是外部参数

func sum (num1 : Int , num2 : Int , num3 : Int) ->Int {
print(num1)
print(num2)
print(num3)
return num1 + num2 + num3   //返回结果 : 30
}
//调用
sum(num1: 100, num2: 200, num3: 10)

func multiply (_ num1 : Int , num2 : Int , num3 : Int) ->Int {
return num1 * num2 * num3  //返回结果 : 1000
}
multiply(10, num2: 10, num3: 10)

—-> 4.6 如何让外部参数不显示?
—-> 4.7 可以在参数名称前加下划线(_)

func subtraction (num1 : Int , _ num2 : Int , _ num3 : Int) ->Int {
return num1 - num2 - num3   //返回结果 : 50
}
subtraction(num1: 100, 20, 30)

默认参数

—-> 5.1 含义 : 某些情况,如果没有传入具体的参数,可以使用默认参数(“蓝山”)
—-> 5.2 需求 : 刚进入公司作为新员工,老员工需要你帮他们泡咖啡,他们说了各自的咖啡需求,但是有一些人没有说,只说了随便,此时要你设计一个函数求出咖啡的种类?

func makeCoffee(coffeeName : String = "蓝山") ->String {
return "制作了一杯:\(coffeeName)咖啡"
}
makeCoffee(coffeeName: "拿铁")  
//通过传入咖啡的名称,返回制作好的咖啡
//此时的调用函数,返回的结果是默认设置的"蓝山"咖啡

可变参数

—-> 6.1 含义与条件
—–> 6.1.1 swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数
—–> 6.1.2 它们必须具有相同的类型
—–> 6.1.3 我们可以通过在参数类型名后面加入（…）的方式来指示这是可变参数
—-> 6.2 需求 : 第一天 老板要你通过函数计算两个数的相加;第二天 老板要你通过函数计算三个数的相加; 第三天 老板要你通过函数计算四个数的相加
此时需要些三个方法来计算

func sum(num1 : Int , num2 : Int) ->Int {
return num1 + num2
}
func sum1(num1 : Int , num2 : Int , num3 : Int) ->Int {
return num1 + num2 + num3
}
func sum2(num1 : Int , num2 : Int , num3 : Int , num4 : Int) ->Int {
return num1 + num2 + num3 + num4
}
sum2(num1: 10, num2: 20, num3: 30, num4: 40)

—-> 6.3 使用可变参数进行改进
计算参数为数组中的各个元素的和(方法一)

func arrayCount(nums : [Int]) ->Int {
var result = 0
for num in nums {
    result += num
}
return result
}
arrayCount(nums: [10,20,30,40])  //传入一个数组   打印结果是 : 100

计算参数为数组中的各个元素的和(方法二)

func sunNums(nums : Int...) ->Int {
var result = 0
for num in nums {
    result += num
}
return result
}
sunNums(nums: 10,20,30,40)

引用类型(指针的传递)

—-> 7.1 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
—-> 7.2 必须是变量,因为需要在内部改变其值
—-> 7.3 Swift提供的inout关键字就可以实现
—-> 7.4 需求 : 用函数交换两个数的值
错误写法 :

var m = 20
var n = 30
func exchangeNum( num1 : Int , num2 : Int) {
var num2 = num2
var num1 = num1
let tempNum = num1
num1 = num2
num2 = tempNum
}
exchangeNum(num1: m, num2: n)
print("m :\(m), n: \(n)")    //打印出结果 : "m :20, n: 30\n"

正确写法 一: 运用指针进行交换(swift提供的关键字: inout)

var a = 20
var b = 30
func exchangeNum( num1 : inout Int , num2 : inout Int) {
let tempNum = num1
num1 = num2
num2 = tempNum
}
exchangeNum(num1: &a, num2: &b)
print("a : \(a) , b : \(b)")    
//打印结果 : "a : 30 , b : 20\n"

特别写法 :

var c = 20
var d = 30
func exchangeNum2( num1 : Int , num2 : Int) -> (Int , Int) {
return (num2 ,num1)
}
let num = exchangeNum2(num1: c, num2: d)
c = num.0     //打印结果 : 30
d = num.1     //打印结果 : 20

属性监听

9.1 在OC中我们可以重写set方法来监听属性的改变
9.2 Swift中可以通过属性观察者来监听和响应属性值的变化
9.3 通常是监听存储属性和类属性的改变.(对于计算属性，我们不需要定义属性观察者，因为我们可以在计算属性的setter中直接观察并响应这种值的变化)
9.4我们通过设置以下观察方法来定义观察者
9.4.1 willSet：在属性值被存储之前设置。此时新属性值作为一个常量参数被传入。该参数名默认为newValue，我们可以自己定义该参数名
9.4.2 didSet：在新属性值被存储后立即调用。与willSet相同，此时传入的是属性的旧值，默认参数名为oldValue
9.4.3 willSet与didSet只有在属性第一次被设置时才会调用，在初始化时，不会去调用这些监听方法

class Person: NSObject {
//属性监听器name
var name : String = "" {
    //监听属性即将发生改变
    willSet (new) {
        //在该方法中有一个默认的系统属性newValue,用于存储新值
        print(name)    //打印结果 : "\n"
        print(new)     //打印结果 : "xiaofeng\n"
    }
    //监听属性已经发生改变
    didSet (old){
        //在该方法中有一个默认的系统属性oldValue,用于存储旧值
        print(name)     //打印结果 : "xiaofeng\n"
        print(old)      //打印结果 : "\n"
    }
}
//属性监听器age
var age : Int = 0 {
    //在willSet中有newValue,用于保存新值
    willSet (newAge) {
        print(age)
        print(newAge)
    }
    //在didSet中有oldSet,用于保存旧值
    didSet (oldAge) {
        print(age)
        print(oldAge)
    }
}
}

//创建对象
let p = Person()
p.name = "xiaofeng"
p.age = 20