Swift - try & as

没啥可说的

1. try

谈到try就不得不先说说Swift的错误处理

Swift错误处理

有四种错误处理方式：

1.1 用 throwing 函数传递错误

func canThrowErrors() throws -> String

func cannotThrowErrors() -> String

1.2 用 Do-Catch 处理错误

do {
    try expression
    statements
} catch pattern 1 {
    statements
} catch pattern 2 where condition {
    statements
} catch pattern 3, pattern 4 where condition {
    statements
} catch {
    statements
}

1.3 将错误转换成可选值

func someThrowingFunction() throws -> Int {
    // ...
}

let x = try? someThrowingFunction()

let y: Int?
do {
    y = try someThrowingFunction()
} catch {
    y = nil
}

1.4 禁用错误传递

let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")

1.5 try

在以上四种错误处理中我们能看到很多try的身影。

在开发中我们可以使用try、try?、try!三种情况。

• 一般在do catch中使用try，在外面可以使用其余两个

• try?返回一个可选类型，要么成功返回正常值，要么失败返回nil

• try!当开发者知道某个throwing函数实际上在运行时不会抛出错误，在这种情况可以在表达式前面写try!

• 写try!的时候如果真的抛出了错误，你会得到一个运行时错误，也就是崩溃

• 所以慎用try!

2. as

as 就是将类型转换为其他类型，其实这样说不严谨，应该说as是向下转型，因为通常我们不会将子类转换为父类类型，因为它已经是父类类型，没必要强转了。

向下转型

简单来说，我们需要定义一个参数来获取调用者传来的值，但是这个值的类型不确定，所以我们需要将其声明为Any，但是获取到了在使用过程中就需要将其转换为已知类型去使用。

struct Cat {
    var name: String
    var age: Int
}

struct Dog {
    var name: String
    var age: Int
}

struct Bird {
    var name: String
    var age: Int
}


func animalName(animal: Any) {
    if animal is Cat {
        print("The cat name is \((animal as! Cat).name)")
    } else if animal is Dog {
        print("The dog name is \((animal as! Dog).name)")
    } else if animal is Bird {
        print("The bird name is \((animal as! Bird).name)")
    }
}

let c = Cat(name: "cat", age: 2)
let d = Dog(name: "dog", age: 1)
let b = Bird(name: "bird", age: 2)


animalName(animal: c)
animalName(animal: d)
animalName(animal: b)

<!--打印结果-->
The cat name is cat
The dog name is dog
The bird name is bird

当然在不确定类型的时候我们也可以这样写：

func animalName(animal: Any) {

    if let c = animal as? Cat {
        print("The cat name is \(c.name)")
    }
    
    if let d = animal as? Dog {
        print("The dog name is \(d.name)")
    }
    
    if let b = animal as? Bird {
        print("The bird name is \(b.name)")
    }
}

如果你确定需要转换的类型一定是某个类型，就可以使用as!，但是一旦它不是这个类型，你就会获得一个运行时错误，也就是崩溃。

所以使用as!前最好使用is判断一下类型，以免发生崩溃。

一般将指定类型转换为广义类型的时候可以使用as，比如下面的代码：

let a = 10
let b = a as Any

但是反过来就不行了

image

反过来就必须使用as?或者as!了

• as?返回一个可选类型，要么转换成功返回转换的类型，要么转换失败返回nil
• as!返回要转换的类型，如果类型不匹配就会引起崩溃，所以慎用