Wie macht man schnell einen optionalen Verschluss?

Ich versuche, in Swift ein Argument zu deklarieren, das optional geschlossen werden kann. Die von mir deklarierte Funktion sieht folgendermaßen aus:

class Promise {

 func then(onFulfilled: ()->(), onReject: ()->()?){       
    if let callableRjector = onReject {
      // do stuff! 
    }
 }

}

Swift beschwert sich jedoch darüber, dass "Gebundener Wert in einer Bedingung ein optionaler Typ sein muss", in dem "if let" deklariert ist.

Sie sollten den optionalen Verschluss in Klammern setzen. Dadurch wird der ?Bediener ordnungsgemäß erfasst .

func then(onFulfilled: ()->(), onReject: (()->())?){       
    if let callableRjector = onReject {
      // do stuff! 
    }
 }

Um den Code noch kürzer zu machen, können wir ihn beim Aufrufen nilals Standardwert für onRejectParameter und optionale Verkettung verwenden ?():

func then(onFulfilled: ()->(), onReject: (()->())? = nil) {
  onReject?()
}

Auf diese Weise können wir onRejectParameter weglassen , wenn wir thenfunction aufrufen .

then({ /* on fulfilled */ })

Wir können auch die Trailing-Closure-Syntax verwenden, um onRejectParameter an die thenFunktion zu übergeben:

then({ /* on fulfilled */ }) {
  // ... on reject
}

Hier ist ein Blog-Beitrag darüber.

Da ich davon ausgehe, dass dieser "optionale" Abschluss einfach nichts bewirken sollte, können Sie einen Parameter mit einem leeren Abschluss als Standardwert verwenden:

func then(onFulfilled: ()->(), onReject: ()->() = {}){       
    // now you can call your closures
    onFulfilled()
    onReject()
}

Diese Funktion kann jetzt mit oder ohne onRejectRückruf aufgerufen werden

then({ ... })
then({ ... }, onReject: { ... })

Swift ist Optionals?hier nicht nötig !

Vielleicht ist es ein sauberer Weg. Besonders wenn der Verschluss komplizierte Parameter hat.

typealias SimpleCallBack = () -> ()

class Promise {

func then(onFulfilled: SimpleCallBack, onReject: SimpleCallBack?){       
    if let callableRjector = onReject {
        // do stuff! 
    }
}

}