Attribute in Swift -Part 1

作者: ZHONG子航 | 来源:发表于2015-10-12 23:25 被阅读152次

最近参加朋友举办的开发者聚会,我分享了 Swift 的特性,可以写出更有 Swift 味道的代码,也更加规范。

解决的问题

通常来说,编程语言的特性出现的原因是为了解决开发中不愉快的问题。接下来要介绍的特性提供了关于声明和类型的更多信息。

Format

和大多数情况一样,特性的格式有带/不带参数两个版本

  • 不带参数版本
    @attribute name
  • 带参数版本
    @attribute name(attribute arguments)
    接下来开始介绍各个特性了。

autoclosure - 自动封装成无参数的闭包

被修饰的参数会自动带上闭包属性

//没有使用 autoclosure,调用函数显得别扭
func printWhenTrue(pred: () -> Bool) {
     if (prod()) {
          print(“I am waiting for you.")
     }
}
func printWhenTrue{ 2 > 1 }

// 使用 autoclosure,调用函数自然得多
func printWhenTrue(prod: @autoclosure () -> Bool) {
     if (prod()) {
          print(“I am here.")
     }
}
func( 2 > 1 )

学会了之后,思考在什么场景适合使用。先看系统是如何使用的,看 fatalError 的定义。

// Unconditionally print a `message` and stop execution.
@noreturn public func fatalError(
                       @autoclosure message: () -> String = default,   
                       file: StaticString = default,
                       line: UInt = default)

autoclosure 的用途是使调用变得简单,试想一下,如果 message 参数是一个闭包{ xxx } 显得多么的累赘。总结出来是,autoclosure 让调用者用的舒心,在调用有可能变得更加简单的场景下都考虑是否加上该特性,如断言就十分合适。

noescape - 参数与函数的生命周期绑定

参数将不会被存储用作后续的计算,其用来确保不会超出函数调用的生命周期。光看这段文字比较难理解,通过代码理解起来更加轻松。

//这是一个辅助理解的函数,参数 code 的生命周期和 doItMore 一样
func doItMore(@noescape code: (Int) -> ()) {}

//参数 code 和 doIt 的生命周期一样
func doIt(@noescape code: () -> ()) {
    code()
    doItMore(code)
/* what we CANNOT do *****
// pass it as a non-`@noescape` parameter
dispatch_async(dispatch_get_main_queue(), code)
// store it
let _code:() -> () = code
// capture it in another non-`@noescape` closure
let __code = { code() }
*/
}

任何改变参数 code 生命的行为都会被拒绝。code()没有改变生命周期,doItMore(code)也没有改变生命周期,因为函数doItMore(_:)的参数带上了 noescape,然而dispatch_async改变了生命周期,_code强引用参数code,也改变了生命周期,__code也是如此。

因为参数的生命与函数绑定,因此不能是执行异步操作的闭包,其中一个适用的场景是,开源库规范使用者的使用方法,避免难以察觉的 bug
值得一提的是,noescape 带来了一个好处,不需要显式的使用 self.xxx。

class Bar {
    var i = 0
    func some() {
        doIt {
            //并不需要写成 print(self.i)
            print(i)
        }
    }
}

noreturn - 函数或方法就不会返回到它的调用者中去

系统 API fatalErrorpreconditionFailure 使用了 noreturn,其定义如下。

@noreturn public func fatalError(
                  @autoclosure message: () -> String = default, 
                  file: StaticString = default, 
                  line: UInt = default)

@noreturn public func preconditionFailure(
                  @autoclosure message: () -> String = default,
                  file: StaticString = default, 
                  line: UInt = default)

调用 fatalError 后,程序就会崩溃,打印出错误日志,调用 preconditionFailure后,效果和 fatalError一样。

这两个 API 均改变了程序正常的执行流程,你的程序已经失去控制了。这效果适用于程序错误处理,如断言,在不满足条件可以让程序崩溃。同样,你也可以自定义自己的函数,在出错打印出你关心的信息。

对于一个没有用 noreturn 特性标记的函数或方法,可以将它重写为用该特性标记的。相反,对于一个已经用 noreturn 特性标记的函数或方法,则不可以将它重写为没使用该特性标记的。借助这特性,可以重写某函数,当在不该调用的地方调用时,直接让程序崩溃

inline - 内联函数

内联函数用得好,才能提高效率。通常来说,简短的函数应当使用内联函数,冗长的函数不适宜用内联函数,不长不短的函数由系统决定,不要干预就好。Swift 也是这样的原则,用inline带上参数的形式显式指定是否内联。

// @inline(never) 显式指定永远不实用内联函数
@inline(never) func randomInt() -> Int{
    return Int(arc4random_uniform(UInt32.max))
}

// @inline(__always) 显式指定永远使用内联函数
@inline(__always) func randomInt() -> Int{
    return Int(arc4random_uniform(UInt32.max))
}

//有时候是内联,有时候又不是,有系统决定
func randomInt() -> Int{
    return Int(arc4random_uniform(UInt32.max))
}

inline 是一个小技巧,简短的内联函数不见得高效非常多,感觉这个特性的最佳使用场景是提高代码的逼格

NSCopying - 修饰类的存储型变量属性

使属性的setter与属性值的一个副本合成,这个值由copyWithZone(_:)方法返回,而不是属性本身的值。但是,该属性的类型必需遵循 NSCopying协议。在 Swift 中,有引用类型和值类型,NSCopying 只适用于引用类型,而值类型是自动复制的。

熟悉 Objective-C 朋友,应该知道 @property (nonatomic, copy) NSString *myString 的涵义,给 myString赋值时,会拷贝一份,他们的内存地址并不相同。在 Swift 中,NSCopying 就是做这样的事情。学习最好不要眼高手低,写一段代码熟悉特性。

// 基础类,辅助理解
class Foo : NSObject, NSCopying {
    var bar = "bar"
    // 只有遵循 NSCopying 协议的属性才可被 NSCopying 修饰
    func copyWithZone(zone: NSZone) -> AnyObject {
        let copy = Foo()
        copy.bar = bar
        return copy
    }
}
class Test : NSObject {
    // NSCopying 修饰 foo
    @NSCopying  var foo : Foo?
    convenience override init() {
        self.init(foo: nil)
    }
    init(foo : Foo?) {
        self.foo = foo
        super.init()
    }
}

接下来看 NSCopying 如何发挥作用。

  • 只有在初始化方法被调用之后,NSCopying 才会发挥作用,不然和普通的引用类型的属性没有区别,下面用两段类似的代码来说明。
let foo = Foo()
foo.bar = "initial"
let test = Test(foo: foo)
print(foo === test.foo) // true
foo.bar = "changed"
print(test.foo!.bar) // "changed"
let foo = Foo()
foo.bar = "initial"
let test = Test()
test.foo = foo
print(foo === test.foo) // false
foo.bar = "changed"
print(test.foo!.bar) // "initial"
  • 访问属性时不会赋值一个值,再返回给调用者,用代码验证。
  let foo = Foo()
  foo.bar = "initial"
  let test = Test()
  test.foo = foo
  foo.bar = "changed"

  //在访问属性时,是没有 copy
  let readFoo = test.foo!
  print(readFoo === test.foo!) // true
  readFoo.bar = "changed"
  print(test.foo!.bar) // "changed"

使用场景是想用引用类型,在合适的时候又能像值类型那样深复制赋值。不过不建议这样,会增加应用的复杂度,如非要这么做,请深入思考。

写在最后

觉得 Swift 的特性很有意思,也有很多,我会在 Part 2 继续介绍。在学习这么细节的知识时,跑操场(Playground)是很有帮助的,建议读者们也跑跑操场,理解更加深刻。

在分享过程中,我关注这些特性的应用场景是什么,不仅要懂知识点,也要知道最佳使用模式。读者在阅读时候如果想到更多的应用场景,请留下你的评论,感谢。

相关文章

网友评论

    本文标题:Attribute in Swift -Part 1

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