快速延迟加载属性

Question

我正在尝试围绕 Swift 语言展开思考。使用 Objective-C 在代码中构建视图的常见模式是覆盖 UI 属性并延迟加载它们，如下所示：

@property(nonatomic, strong) UILabel *myLabel;

- (UILabel *)myLabel
{
     if (!_myLabel) {
         _myLabel = [[UILabel alloc] initWithFrame:CGRectMake(20.0f, 75.0f, 320.0f, 20.0f)];
        [_myLabel setFont:[UIFont subHeadlineFont]];
        [_myLabel setTextColor:[UIColor subHeadlineColor]];
        [_myLabel setText:@"Hello World"];
     }
     return _myLabel;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
    [self.view addSubview:self.myLabel];
}

这允许 UIElements 的配置在其设置中自包含，但不会导致每次都重新配置它们。

似乎我们无法访问 Swift 中的后备存储，并且 @lazy 关键字实际上并没有相同的语义。

我很好奇是否有人在 Swift 中发现了一种类似的模式，它允许人们以一种不会导致每次都重新配置的简洁语法方式将变量和常量的配置与它们的声明保持在一起？

Answer 1

斯威夫特 3.0

我更喜欢这种内联样式。

lazy var myLabel: UILabel = self.createMyLabel()

private func createMyLabel() -> UILabel {
    let mylabel = UILabel()
    // ...
    return mylabel
}

Answer 2

我认为使用闭包初始化的 lazy 属性会起作用：

lazy var myLabel: UILabel = {
    var temporaryLabel: UILabel = UILabel()
    ...
    return temporaryLabel
}()

当我阅读“Swift 编程语言”时。 （棋盘格示例）闭包只评估一次）。

Answer 3

作为 Christian Otkjær 答案的变体，也可以将类方法分配给 @lazy var：

class MyClass {

  @lazy var myLabel : UILabel = MyClass.newLabel()

  class func newLabel() -> UILabel {
    var temporaryLabel : UILabel = UILabel()
    ...
    return temporaryLabel
  }
}

它实际上与使用闭包相同，但如果闭包中的代码行数过多，则可以选择在声明所有属性和初始化方法之后将该代码放在其他地方的类方法中。

Answer 4

Apple 的做法似乎有所不同...如果我在 Xcode 中创建一个新项目并添加 Core Data，AppDelegate.swift 中有一个示例：

// Returns the managed object model for the application.
// If the model doesn't already exist, it is created from the application's model.
var managedObjectModel: NSManagedObjectModel {
    if !_managedObjectModel {
        let modelURL = NSBundle.mainBundle().URLForResource("MyApp", withExtension: "momd")
        _managedObjectModel = NSManagedObjectModel(contentsOfURL: modelURL)
    }
    return _managedObjectModel!
}
var _managedObjectModel: NSManagedObjectModel? = nil

虽然，这对我来说是因为变量是在初始化时创建的，但是随后读取，@lazy 似乎是一个更好的实现。有什么想法吗？

所以我尝试了这个：

class TestClass {
    @lazy var myLabel : UILabel = {
        var temporaryLabel : UILabel = UILabel()
        return temporaryLabel 
    }()

    var testLabel: UILabel {
    if !_testLabel {
        _testLabel = UILabel()
        }
    return _testLabel!
    }
    var _testLabel: UILabel? = nil

    func test () {
        println(myLabel)
        println(self.testLabel)
    }
}

两者确实只是懒惰地创建的。作为@bradlarson points out on Twitter:

@runmad 您的方法保留的一件事是只读的 财产的状态。 @lazy 不能与 let 一起使用，这是一个 问题。

Answer 5

class Thingy {
    init(){
        println("making a new Thingy")
    }
}

var thingy = {
    Thingy();
}()

println("\(self.thingy)")
println("\(self.thingy)")

日志信息“making a new Thingy”只出现一次，证明只创建了一个Thingy——闭包只被调用了一次，即初始化这个属性。这实际上就是您所描述的。您所要做的就是向闭包添加更多内容，以便将其配置为返回的对象。

如果你创建 var @lazy 并注释掉 println 语句，no Thingy 被创建，证明懒惰做了它想要做的事情；但是，您可以忽略这一点，因为您知道实际上在早期总是需要该标签。 @lazy 的目的是防止闭包永远被调用，除非调用 getter，但你总是要调用 getter，所以这在你的情况下毫无意义。

Answer 6

您可以在 @lazy 变量上提供一个闭包来声明它应该如何创建：

class Blah {
    @lazy var label: () -> UILabel = {
        var view:UILabel = UILabel();
        //Do stuff here
        return view;
    }
}

Answer 7

这几乎是作为您的 ObjectiveC 示例的 Swift 版本。 （简化为使用Int 而不是视图）

class Foo {
    var _value: Int?
    var value: Int {
        get {
            if !_value {
                _value = 123
            }
            return _value!
        }
    }
}

Foo().value //-> 123

虽然不是很漂亮。