参数化正则表达式用于模式匹配(Parametrized Regex for pattern matching)

 对于具有默认值或默认闭包的存储属性，在调用init方法之前，内存会分配。 您不能使用self或属性来默认值定义其他属性。 
 
 您的示例中的闭包通常用于此步骤以定义lazy属性; 它们应该是var并用lazy关键字标记： 
 
class myClass {
    let x: NSString? = nil
    let q: NSString? = {return "q"}() //allocates before class init; deallocates imidiatly
    lazy var y: NSString = {
        let z  = self.x
        return z ?? ""
    }()                               //allocates on first property call; deallocates imidiatly
}
 
 延迟属性的内存将在第一次属性调用时分配。 构造{/*...*/}()意味着此闭包将在调用时执行，并将返回计算结果（您可以在未命名函数中查看此内容），而不是引用此闭包。 这是非常重要的时刻：你没有保留闭包，这个闭包只分配执行时刻并在返回后释放，所以你不需要关心强循环引用问题。 
 
 其他的事情 - 当您保存对闭包的引用时： 
 
class myClass {
    let x: NSString? = nil
    var closure: () -> NSString = {return "q"} //allocates before class init; deallocates on references release
    lazy var lazyClosure: () -> NSString = {
        let z  = self.x
        return z ?? ""
    }                                        //allocates on first property call; deallocates on references release
}
 
 此闭包的内存与前一种情况同时分配，但它们将继续存在，直到有任何引用。 你可以在这里查看闭包，就像在不同的对象一样。 这里可能出现循环参考问题。 closure不捕获任何东西，所以它没有问题，但lazyClosure捕获self 。 如果我们永远不会调用lazyClosure就没有问题，因为这个闭包永远不会分配。 但是如果我们将它调用，它将被分配，它将捕获self ，并且将有强循环引用： self指向lazyClosure实例， lazyClosure指向self实例。 要解决这个问题，你应该使其中一个引用弱，你应该使用捕获列表：在lazyClosure体中插入[weak self] in或[unowned self] in lazyClosure [unowned self] in 。 [unowned self] in我们的案例中，因为如果财产被称为，那么self就不是nil 。 
 
lazy var lazyClosure: () -> NSString = {
    [unowned self] in
    let z  = self.x
    return z ?? ""
}

For stored properties with default values or default closures memory allocates immideatly, before init method called. You can not use self or properties for defining other property by default value.
 
Closures from your example usually used on this step to define lazy properties; they should be var and marked with lazy keyword:
 
class myClass {
    let x: NSString? = nil
    let q: NSString? = {return "q"}() //allocates before class init; deallocates imidiatly
    lazy var y: NSString = {
        let z  = self.x
        return z ?? ""
    }()                               //allocates on first property call; deallocates imidiatly
}
 
Memory for lazy properties will be allocated on first property call. Construction {/*...*/}() means that this closure will be executed just at call moment and will return result of calculation (you can look at this like at unnamed function), not reference to this closure. This is very important moment: you are not retain closure, this closure allocates only for execution moment and deallocates just after return, so you don't need care about strong cycle reference problem.
 
Other thing - when you saving reference to closure:
 
class myClass {
    let x: NSString? = nil
    var closure: () -> NSString = {return "q"} //allocates before class init; deallocates on references release
    lazy var lazyClosure: () -> NSString = {
        let z  = self.x
        return z ?? ""
    }                                        //allocates on first property call; deallocates on references release
}
 
Memory for this closures allocates at same time as in previous case, but they will continue to live until have any references. You can look at closures here like at separate objects. Cycle reference problem can arise here. closure is not capture anything, so there are no problems with it, but lazyClosure capture self. If we will never call lazyClosure there will be no problems, since this closure will never allocates. But if we will call it, it will be allocated, it will capture self, and there will be strong cycle reference: self points to lazyClosure instance, lazyClosure points to self instance. To solve this problem you should make one of references weak, you should use capture list: insert [weak self] in or [unowned self] in in lazyClosure body. [unowned self] in in our case, since if property called, then self is not nil.
 
lazy var lazyClosure: () -> NSString = {
    [unowned self] in
    let z  = self.x
    return z ?? ""
}