as let swift

2017-07-02 17:29:17 robinson_911 阅读数 3152
  • The as! Operator!

    让我们来操作as吧!

  • 说明

    因为最近在学习Swift,这里根据苹果官方文档加上自己的理解,总结了下常用的as、as!、as? 这三种类型转换操作符的异同和使用方式。
  • 正文

    • as
      keywordGuaranteed conversion、 Upcasting
      理解:字面理解就是有保证的转换,从派生类转换为基类的向上转型
      著名代码:
      // 将1转成float
      let num = 1 as CGFloat
      |------------------------
      // dog转换到父类animal
      class Animal {}
      class Dog: Animal {}
      let d = Dog()
      d as Animal
    • as!
      keywordForced conversion、 Downcasting
      理解:字面理解就是有强项转换,即向下转型,子类(派生类)向父类转换,官方解释说这是一个不被保证的转换,可能会因为强转的失败而会导致崩溃。同时 是一个陷阱的标志,就像⚠️一样,用起来存在一定危险性
      著名代码:
      // Dog到Animal的转化
      class Animal {}
      class Dog: Animal {}
      let a: Animal = Dog()
      a as Dog        // as不能将a转成Dog,即不能向下转换
      a as! Dog    // as!能强行将a转成Dog -> Bingo
    • as?
      keyword Optional、 Nil
      理解:Swfit代码写一段时间后会发现到处都是  ,这预示着如果转换不成功的时候便会返回一个 nil 对象。成功的话返回可选类型值(optional)。
      著名代码:
      // Dog、Cat和Animal的转换关系
      class Animal {}
      class Cat: Animal {}
      class Dog: Animal {
      var name = "Spot"
      }
      let dog: Dog? = nil
      dog?.name        // 选择调用,返回空值nil
      dog!.name        // 强行调用,报错
      let animal: Animal = Cat()
      animal as? Dog    // 猫转狗失败,返回nil
      animal as! Dog    // 猫强行转狗,失败报错
  • 引用参考

2018-07-19 10:51:26 Philm_iOS 阅读数 2193
本文总结 as、as!、as? 这三种类型转换操作符的异同,以及各自的使用场景。

as

有保证的转换,从派生类转换为基类的向上转型(upcasts)
使用场合:

  • 从派生类转换为基类,向上转型(upcasts)
class Animal {}
class Cat: Animal {}
let cat = Cat()
let animal = cat as Animal
  • 消除二义性,数值类型转换
let num1 = 42 as CGFloat
let num2 = 42 as Int
let num3 = 42.5 as Int
let num4 = (42 / 2) as Double
  • switch 语句中进行模式匹配

如果不知道一个对象是什么类型,你可以通过switch语法检测它的类型,并且尝试在不同的情况下使用对应的类型进行相应的处理。

switch animal {
    case let cat as Cat:
    print("如果是Cat类型对象,则做相应处理")
    case let dog as Dog:
    print("如果是Dog类型对象,则做相应处理")
    default: break
}

as!

强制类型转换,向下转型(Downcasting)时使用,子类(派生类)向父类转换,如果转换失败会报 runtime 运行错误。

官方解释说这是一个不被保证的转换,可能会因为强转的失败而会导致崩溃。同时 !是一个陷阱的标志,就像⚠️一样,用起来存在一定危险性。
示例代码:

class Animal {}
class Cat: Animal {}
let animal :Animal  = Cat()
let cat = animal as! Cat

as?

[as?] 和 [as!] 操作符的转换规则完全一样。但 [as?] 如果转换不成功的时候便会返回一个 nil 对象。成功的话返回可选类型值(optional)。由于 [as?] 在转换失败的时候也不会出现错误,所以对于如果能确保100%会成功的转换则可使用 [as!] ,否则使用 [as?] 。
示例代码:

let animal:Animal = Cat()
if let cat = animal as? Cat{
    print("cat is not nil")
    } else {
    print("cat is nil")
}

原文地址:https://www.jianshu.com/p/ebe29d97b5e9

2018-04-02 09:56:09 fish_yan_ 阅读数 8187

Swift 中的变量声明相对于 OC 中简化了很多。可变与不可变取决于声明的方式,不在取决于类型了,这样简化了很多不必要的类型。比如 OC 中可变的为 NSMutableArray,不可变的是 NSArray,而 Swift 中的数组不管可变与不可变就是 Array 。

Swift 中变量的声明

在 Swift 中声明变量有两种方式: let,var

Swift 中的变量的声明方式跟 OC 大不相同,摒弃了 OC 中的 alloc init 的方式,在写法上进行了简化,使整体的入门难度降低,但仅仅是入门难度降低了。

let

let 所声明的变量统统为不可变的变量。

    let a: Int = 0

这是简单的声明了一个 Int 类型的变量 a ,a 的值只能是初始值 0 ,不能被再次修改,一般结构:let (变量名):(类型) = (值)

    a = 1

如果在写上面这句代码,编译器就会直接给出报错提示Cannot assign to value: 'a' is a 'let' constant, 所以在用let声明的变量,是不能被再次赋值,包括修改。这一点跟 OC 中的不可变类型有区别,OC 中是不能被修改,但是可以被重新赋值。

Swift 中声明一个变量是不是看起来很简单?对,入门很简单,But… 举几个例子:

    let a = 0 // Int 类型的 0
    let a: Int = 0 // Int 类型的 0
    let a = 0.0 // Double 类型的 0
    let a: Float = 0 // Float 类型的 0
    let a: Double = 0 // Double 类型的 0
    let a = {
        return 0
    }()

为什么 let a = 0Int 类型而 let a = 0.0 就是 Double 类型的呢?在 Swift 中有类型推断的机制,当你声明一个变量,如果没有指定类型,那么系统就会去推断这个变量是什么类型的。

var

var 所声明的变量统统为可变的变量。

    var a: Int = 0
    a = 3

如果上面没有写 a = 3 那么系统会给出黄色提示 Variable 'a' was never mutated; consider changing to 'let' constant 提示你声明的是一个可变的变量而你没有修改它,建议用 let 修饰。

Swift 是类型安全的语言,所以在对类型的要求比较严格。如果你不需要修改变量那么就用 let 声明,如果你需要修改那么就用 var 声明。

同样举几个例子,跟 let 一样就不解释了

    var a = 0 // Int 类型的 0
    var a: Int = 0 // Int 类型的 0
    var a = 0.0 // Double 类型的 0
    var a: Float = 0 // Float 类型的 0
    var a: Double = 0 // Double 类型的 0
    var a = {
        return 0
    }()

本篇只是简单介绍一下一个变量的声明方式,区分一下 letvar 的区别,什么时候用 let,什么时候用 var,对于那些希望从 OC 转向 Swift 语言开发的希望有些帮助。想要了解更多的 Swift 的知识请往下看。

2018-01-08 22:49:14 Sico2Sico 阅读数 921

官方Demo

func append(object: AnyObject) {
        switch object {
            case let actionSet as HMActionSet:
                actionSets.append(actionSet)
                actionSets = actionSets.sortByTypeAndLocalizedName()

            case let accessory as HMAccessory:
                accessories.append(accessory)
                accessories = accessories.sortByLocalizedName()

            case let room as HMRoom:
                rooms.append(room)
                rooms = rooms.sortByLocalizedName()

            case let zone as HMZone:
                zones.append(zone)
                zones = zones.sortByLocalizedName()

            case let trigger as HMTrigger:
                triggers.append(trigger)
                triggers = triggers.sortByLocalizedName()

            case let serviceGroup as HMServiceGroup:
                serviceGroups.append(serviceGroup)
                serviceGroups = serviceGroups.sortByLocalizedName()

            default:
                break
        }
    }

这里写图片描述

2017-12-20 18:16:49 qq_18683985 阅读数 198

对于Swift中的关键字’as’来说一共有三种方式

类型 使用方式
‘as’ 向上转型,数值类型直接转换,检测类型等
‘as!’ 一般用于向下转型,但是转型失败会报runtime错误
‘as?’ 比’as!’好在如果转换失败不会报runtime错误,会返回一个nil对象,转化成功会返回一个Optional类型的值,使用该值需要拆包

1.向上转型

1. 父类Person
    class Person: NSObject {
    //构造函数等省略
}
2. 子类Student
    class Student: Person {
    //构造函数等省略
}
3. 进行类型转换
    let student = Student()
    //类型转换(向上转型)
    let Person = student as Person

2.数值类型转换

//  //如果直接=10.那么一定是一个Int类型(swift自动类型判断,swift不支持隐式类型转换,这里不赘述了)
//  let num1 = 10
    //我们可以使用as来使num变成其他类型
    let num2 = 10 as float
    let nume3 = 3.4 as Int

3.模式匹配

if let student as Student {
    print(student是Student类的对象);
}

这种模式匹配是否比OC中的

    -(BOOL)isKindOfClass;

等能够判断类型的方法来得简单得多?