Rückgabe nach dem Aufruf des Beendigungshandlers oder Rückgabe des Beendigungshandlerparameters?

Question

Ich habe eine Methode, die eingerichtet werden summiert kann wie folgt aussehen:

func apply(username: String, email: String, password: String, 
      onDone: @escaping (_ error: Error?) ->()) 
{ 
    //Do async stuff 
    do 
    { 
     try asyncGood() 
     onDone(nil) 
     return 
    } 
    catch 
    { 
     onDone(error) 
     return 
    } 
} 

Was ist der Unterschied zwischen tun:

return onDone(error) 

gegen

onDone(error) 
return 

?
Speichert es nur eine zusätzliche Codezeile? Ich sehe keinen Unterschied zwischen den beiden. Fehle mir ein grundlegender Aspekt der asynchronen Swift-Programmierung?

Sollte ich Ihrer Meinung nach immer versuchen, alles so zusammenzufassen, dass onDone (...) am Ende nur einmal heißt?

Answer 1

Semantisch sind beide Fälle gleich. Sie sind im Grunde sagen:

return() 

Ihre Methode () zurückzukehren deklariert wird, und da die onDone Schließung auch eine () zurückgibt, können Sie return onDone(error) sagen. Die Rückgabetypen stimmen überein.

Allerdings finde ich schreibe sie in zwei separate Leitungen besser lesbar:

// This clearly shows that you are doing 2 separate things 
onDone(error) // call the completion handler 
return // return 

oder sogar die return weglassen!

Answer 2

Beide sind gleich. apply Funktion Rückgabetyp ist Void und onDone Schließung Rückgabetyp ist auch Void. Also sind beide gleich.

return onDone(error) 

oder

onDone(error) 
return 

oder Sie können einfach ignorieren, weil Rückkehr Rückgabetyp ist Void

onDone(error) 

Answer 3

gibt es keinen Unterschied. In der Tat gibt es keine Notwendigkeit für return Schlüsselwort überhaupt.

Für rasche alle folgende Erklärung entspricht:

func doNothing() { 
} 

func doNothing2() -> Void { 
} 

func doNothing3() ->() { 
} 

func doNothing4() { 
    return() 
} 

func doNothing5() -> Void { 
    return() 
} 

Wenn Sie zurückkommen() Sie nichts zurück. Keine Rückkehr ist genau das gleiche wie nichts zurückgeben.Funktionen Void Rückkehr kann in äquivalenter Weise, wie folgend

doNothing() 

var result = doNothing() 

Mehr, Void auch als Typ-Parameter verwendet werden können, verwendet werden, die ein sehr mächtiges Feature ist:

func genericCall<T>(_ f:() -> T) -> T { 
    return f() 
} 

var result1 = genericCall { print("test") } // result1 is Void 
var result2 = genericCall { return 5 } // result2 is Int 

Ihre erste Frage zu beantworten, würde ich vorschlagen,

func doStuffAsync(_ callback: @escaping (Error?) -> Void) { 
    // Just an example. Could be any other async call. 
    DispatchQueue.main.async { 
     do { 
      try doStuff() 
      callback(nil) 
     } 
     catch { 
      callback(error) 
     } 
    } 
}