Swift Language
Uppskjutande uttalande

När du ska använda ett uppskjutande uttalande

Ett defer uttalande består av ett kodblock, som kommer att köras när en funktion återgår och bör användas för sanering.

Eftersom Swifts guard uppmuntrar en stil med tidig återkomst kan många möjliga vägar för en återkomst existera. Ett defer uttalande tillhandahåller saneringskod, som då inte behöver upprepas varje gång.

Det kan också spara tid under felsökning och profilering, eftersom minnesläckor och oanvända öppna resurser på grund av glömd sanering kan undvikas.

Det kan användas för att fördela en buffert i slutet av en funktion:

func doSomething() {
    let data = UnsafeMutablePointer<UInt8>(allocatingCapacity: 42)
    // this pointer would not be released when the function returns 
    // so we add a defer-statement
    defer {
        data.deallocateCapacity(42)
    }
    // it will be executed when the function returns.
    
    guard condition else { 
        return /* will execute defer-block */ 
    }
       
}   // The defer-block will also be executed on the end of the function.

Det kan också användas för att stänga resurser i slutet av en funktion:

func write(data: UnsafePointer<UInt8>, dataLength: Int) throws {
    var stream:NSOutputStream = getOutputStream()
    defer {
        stream.close()
    }

    let written = stream.write(data, maxLength: dataLength)
    guard written >= 0 else { 
        throw stream.streamError! /* will execute defer-block */ 
    }
    
}    // the defer-block will also be executed on the end of the function

När INTE ska använda ett uppskjutande uttalande

När du använder ett uppskjutande uttalande, se till att koden förblir läsbar och att körningsordern förblir klar. Exempelvis gör följande användning av uppskjutningsuppdraget exekveringsordern och kodens funktion svår att förstå.

postfix func ++ (inout value: Int) -> Int {
    defer { value += 1 } // do NOT do this!
    return value
}