Swift @escaping and Completion Handler

Próbuję dokładniej zrozumieć „Zamknięcie” Swifta.

Ale @escapingi Completion Handlersą zbyt trudne do zrozumienia

Przeszukałem wiele ogłoszeń Swift i oficjalnych dokumentów, ale czułem, że to wciąż za mało.

To jest przykład kodu oficjalnych dokumentów

var completionHandlers: [()->Void] = []

func someFunctionWithEscapingClosure(completionHandler: @escaping ()->Void){
    completionHandlers.append(completionHandler)
}

func someFunctionWithNoneescapingClosure(closure: ()->Void){
    closure()
}

class SomeClass{
    var x:Int = 10
    func doSomething(){
        someFunctionWithEscapingClosure {
            self.x = 100
            //not excute yet
        }
        someFunctionWithNoneescapingClosure {
            x = 200
        }
    }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x)

completionHandlers.first?() 
print(instance.x)

Słyszałem, że są dwa sposoby i powody używania @escaping

Pierwszy służy do przechowywania zamknięcia, a drugi do celów operacyjnych Async.

Oto moje pytania :

Po pierwsze, jeśli doSomethingWykonuje wtedy someFunctionWithEscapingClosurebędzie wykonanie z parametrem zamknięcia i zamknięcie zostanie zapisany w globalnej tablicy zmiennych.

Myślę, że zamknięcie to {self.x = 100}

Jak selfw {self.x = 100} ta zapisana w zmiennej globalnej completionHandlersmoże połączyć się z instancetym obiektem SomeClass?

Po drugie, rozumiem w someFunctionWithEscapingClosureten sposób.

Aby przechowywać lokalne zamknięcie zmiennej completionHandlerw globalnym we usingsłowie kluczowym „completeHandlers @ escaping”!

bez zwracania @escapingsłów kluczowych someFunctionWithEscapingClosurezmienna lokalna completionHandlerzostanie usunięta z pamięci

@escaping to zachować to zamknięcie w pamięci

Czy to jest poprawne?

Na koniec po prostu zastanawiam się nad istnieniem tej gramatyki.

Może to bardzo podstawowe pytanie.

Jeśli chcemy, aby jakaś funkcja była wykonywana po określonej funkcji. Dlaczego po prostu nie wywołamy jakiejś funkcji po wywołaniu określonej funkcji?

Jakie są różnice między użyciem powyższego wzorca a użyciem funkcji ucieczki zwrotnej?

Ucieczka programu obsługi szybkiego zakończenia i brak ucieczki:

Jak wyjaśnia Bob Lee w swoim poście na blogu Completion Handlers in Swift with Bob :

Załóżmy, że użytkownik aktualizuje aplikację podczas jej używania. Na pewno chcesz powiadomić użytkownika, gdy to się skończy. Być może chcesz wyświetlić okno z napisem „Gratulacje, teraz możesz w pełni się cieszyć!”

Jak więc uruchomić blok kodu dopiero po zakończeniu pobierania? Co więcej, w jaki sposób animować pewne obiekty dopiero po przeniesieniu kontrolera widoku do następnego? Cóż, dowiemy się, jak zaprojektować takiego jak szefa.

Opierając się na mojej obszernej liście słownictwa, pomocnicy uzupełniania oznaczają

Rób rzeczy, gdy coś już zostało zrobione

Post Boba zapewnia jasność co do programów obsługi zakończenia (z punktu widzenia programisty dokładnie definiuje to, co musimy zrozumieć).

@escaping closures:

Kiedy przekazuje się zamknięcie w argumentach funkcji, używa się go po wykonaniu treści funkcji i zwraca kompilator z powrotem. Kiedy funkcja się kończy, zakres przekazanego domknięcia istnieje i istnieje w pamięci, dopóki zamknięcie nie zostanie wykonane.

Istnieje kilka sposobów na uniknięcie zamknięcia w funkcji zawierającej:

• Przechowywanie: gdy chcesz zapisać zamknięcie w zmiennej globalnej, właściwości lub innym miejscu w pamięci, która istniała w przeszłości funkcji wywołującej, zostanie wykonana i zwróć kompilator.

• Wykonywanie asynchroniczne: gdy wykonujesz zamknięcie asynchronicznie w kolejce wysyłkowej, kolejka będzie przechowywać zamknięcie w pamięci, aby można było z niej korzystać w przyszłości. W takim przypadku nie masz pojęcia, kiedy zamknięcie zostanie wykonane.

Podczas próby użycia zamknięcia w tych scenariuszach kompilator Swift wyświetli błąd:

Aby uzyskać więcej informacji na ten temat, sprawdź ten post na Medium .

Dodanie jeszcze jednego punktu, które każdy programista iOS musi zrozumieć:

1. Zamknięcie ucieczki: Zamknięcie ucieczki to zamknięcie wywoływane po funkcji, do której została przekazana. Innymi słowy, przeżywa funkcję, do której został przekazany.
2. Zamknięcie bez ucieczki : zamknięcie, które jest wywoływane w funkcji, do której zostało przekazane, tj. Przed powrotem.

Oto mała klasa przykładów, których używam, aby przypomnieć sobie, jak działa @escaping.

class EscapingExamples: NSObject {

    var closure: (() -> Void)?

    func storageExample(with completion: (() -> Void)) {
        //This will produce a compile-time error because `closure` is outside the scope of this
        //function - it's a class-instance level variable - and so it could be called by any other method at
        //any time, even after this function has completed. We need to tell `completion` that it may remain in memory, i.e. `escape` the scope of this
        //function.
        closure = completion
        //Run some function that may call `closure` at some point, but not necessary for the error to show up.
        //runOperation()
    }

    func asyncExample(with completion: (() -> Void)) {
        //This will produce a compile-time error because the completion closure may be called at any time
        //due to the async nature of the call which precedes/encloses it.  We need to tell `completion` that it should
        //stay in memory, i.e.`escape` the scope of this function.
        DispatchQueue.global().async {
            completion()
        }
    }

    func asyncExample2(with completion: (() -> Void)) {
        //The same as the above method - the compiler sees the `@escaping` nature of the
        //closure required by `runAsyncTask()` and tells us we need to allow our own completion
        //closure to be @escaping too. `runAsyncTask`'s completion block will be retained in memory until
        //it is executed, so our completion closure must explicitly do the same.
        runAsyncTask {
            completion()
        }
    }





    func runAsyncTask(completion: @escaping (() -> Void)) {
        DispatchQueue.global().async {
            completion()
        }
    }

}