Повторно инициализируйте ленивую инициализированную переменную в Swift

РЕДАКТИРОВАНИЕ: Согласно ответу Ben Leggiero, ленивый Вар может быть nil способен в Swift 3. РЕДАКТИРОВАНИЕ 2: Походит nil, способный ленивый Вар больше не.

Очень поздно стороне, и даже уверенный, если это будет релевантно в Swift 3, но здесь идет. Ответ David хорош, но если Вы хотите создать многих ленивый способный нолем Вар, необходимо будет записать довольно значительный блок кода. Я пытаюсь создать ADT, который инкапсулирует это поведение. Вот то, что я имею до сих пор:

struct ClearableLazy<T> {
    private var t: T!
    private var constructor: () -> T
    init(_ constructor: () -> T) {
        self.constructor = constructor
    }
    mutating func get() -> T {
        if t == nil {
            t = constructor()
        }
        return t
    }
    mutating func clear() { t = nil }
}

Вы затем объявили бы и использовали бы свойства как это:

var aClient = ClearableLazy(Client.init)
aClient.get().delegate = self
aClient.clear()

существуют вещи, я еще не люблю приблизительно это, но не знаю, как улучшиться:

• необходимо передать конструктора инициализатору, который выглядит ужасным. Это имеет преимущество, тем не менее, что можно указать точно, как состоят в том, чтобы быть созданы новые объекты.
• Вызов get() на свойстве каждый раз Вы хотите использовать его, ужасно. Было бы немного лучше, если бы это было вычисленным свойством, не функцией, но вычислило свойства, не может видоизменяться.
• , Чтобы избавить от необходимости звонить get(), необходимо расширить каждый тип, для которого Вы хотите использовать это с инициализаторами для ClearableLazy.

, Если бы кто-то испытывает желание брать его отсюда, который был бы потрясающим.

Это позволяет устанавливать свойство на nil для принуждения реинициализации:

private var _recordedFileURL: NSURL!

/// Location of the recorded file
private var recordedFileURL: NSURL! {
    if _recordedFileURL == nil {
        let file = "recording\(arc4random()).caf"
        let url = NSURL(fileURLWithPath: NSTemporaryDirectory()).URLByAppendingPathComponent(file)
        NSLog("FDSoundActivatedRecorder opened recording file: %@", url)
        _recordedFileURL = url
    }
    return _recordedFileURL
}

Здесь существуют некоторые хорошие ответы.
Сброс ленивого var действительно, желателен в большом количестве случаев.

я думаю, можно также определить закрытие, чтобы создать клиент и сбросить ленивый var с этим закрытием. Что-то вроде этого:

class ClientSession {
    class func shared() -> ClientSession {
        return ClientSession()
    }
}

class Client {
    let session:ClientSession
    init(_ session:ClientSession) {
        self.session = session
    }
}

class Test {
    private let createClient = {()->(Client) in
        var _aClient = Client(ClientSession.shared())
        print("creating client")
        return _aClient
    }

    lazy var aClient:Client = createClient()
    func resetClient() {
        self.aClient = createClient()
    }
}

let test = Test()
test.aClient // creating client
test.aClient

// reset client
test.resetClient() // creating client
test.aClient

Если цель состоит в том, чтобы повторно инициализировать ленивое свойство, но не обязательно установить, она к нолю, Создающему от Phlippie Bosman и Ben Leggiero, вот что-то, что избегает, чтобы условное выражение проверило каждый раз, когда значение читается:

public struct RLazy<T> {
    public var value: T
    private var block: () -> T
    public init(_ block: @escaping () -> T) {
        self.block = block
        self.value = block()
    }
    public mutating func reset() {
        value = block()
    }
}

Для тестирования:

var prefix = "a"
var test = RLazy { () -> String in
    return "\(prefix)b"
}

test.value         // "ab"
test.value = "c"   // Changing value
test.value         // "c"
prefix = "d"
test.reset()       // Resetting value by executing block again
test.value         // "db"

Swift 5.1:

class Game {
    private var _scores: [Double]? = nil

    var scores: [Double] {
        if _scores == nil {
            print("Computing scores...")
            _scores = [Double](repeating: 0, count: 3)
        }
        return _scores!
    }

    func resetScores() {
        _scores = nil
    }
}

Вот то, как использовать:

var game = Game()
print(game.scores)
print(game.scores)
game.resetScores()
print(game.scores)
print(game.scores)

Это производит следующий вывод:

Computing scores...
[0.0, 0.0, 0.0]
[0.0, 0.0, 0.0]
Computing scores...
[0.0, 0.0, 0.0]
[0.0, 0.0, 0.0]

Swift 5.1 и Обертка Свойства

@propertyWrapper
class Cached<Value: Codable> : Codable {
    var cachedValue: Value?
    var setter: (() -> Value)?

    // Remove if you don't need your Value to be Codable    
    enum CodingKeys: String, CodingKey {
        case cachedValue
    }

    init(setter: @escaping () -> Value) {
        self.setter = setter
    }

    var wrappedValue: Value {
        get {
            if cachedValue == nil {
                cachedValue = setter!()
            }
            return cachedValue!
        }
        set { cachedValue = nil }
    }

}

class Game {
    @Cached(setter: {
        print("Computing scores...")
        return [Double](repeating: 0, count: 3)
    })
    var scores: [Double]
}

Мы сбрасываем кэш путем установки его на любое значение:

var game = Game()
print(game.scores)
print(game.scores)
game.scores = []
print(game.scores)
print(game.scores)