Swift @échapper et Gestionnaire d'Achèvement

[Swift]

Salut, je suis en train d'essayer de comprendre les "Fermeture" de Swift avec plus de précision.

Mais @escaping et Completion Handler sont trop difficiles à comprendre

J'ai cherché de nombreuses Swift publications et documents officiels, mais j'ai senti qu'il n'était pas encore suffisant.

C'est le code d'exemple de documents officiels

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)

J'ai entendu dire qu'il y a deux façons et les raisons à l'aide de @escaping

Première est pour le stockage d'une fermeture, la seconde est pour Async à des fins d'exploitation.

Voici mes questions:

Tout d'abord, si doSomething exécute ensuite someFunctionWithEscapingClosure sera exécuté avec fermeture paramètre et que cette fermeture sera enregistrée dans la variable globale tableau.

Je pense que la fermeture est {self.x = 100}

Comment self dans {self.x = 100} sauvegardée dans la variable globale de completionHandlers peut se connecter à instance que l'objet de la SomeClass ?

Deuxième, je la compréhension someFunctionWithEscapingClosure comme ça.

Pour stocker les variables locales fermeture completionHandler à la variable globale 'completionHandlerswe using@échapper à ce mot-clé!

sans @escaping mot-clé someFunctionWithEscapingClosure retourne, la variable locale completionHandler va supprimer de la mémoire

@escaping est de le garder à la fermeture dans la mémoire

Est ce droit?

Enfin, je me demande juste au sujet de l'existence de cette grammaire.

Peut-être que c'est un très rudimentaire question.

Si nous voulons que la fonction à exécuter après certaines fonctions spécifiques. Pourquoi ne pas simplement appeler une fonction après un appel de fonction?

Quelles sont les différences entre l'aide du schéma ci-dessus et à l'aide d'un échappement fonction de rappel?

je vous remercie pour la lecture des questions et désolé car je ne suis pas originaire

OriginalL'auteur Dongkun Lee | 2017-09-15

78

Tout d'abord, je tiens à dire "Très Bonne Question :)"

Gestionnaire D'Achèvement :

Supposons que l'utilisateur est mise à jour d'une application en cours d'utilisation. Vous voulez certainement pour avertir l'utilisateur quand il est fait. Vous pouvez afficher une boîte qui dit: “Félicitations, vous pouvez maintenant profiter pleinement de!”

Alors, comment voulez-vous exécuter un bloc de code seulement après le téléchargement est terminé? De plus, comment voulez-vous animer certains objets seulement après un view controller a été déplacé à la prochaine? Eh bien, nous allons découvrir comment concevoir un comme un boss.
Basé sur mon vaste liste de vocabulaire, de l'achèvement des gestionnaires stand pour

Faire des trucs quand les choses ont été faites

Pour plus de détails, veuillez visiter ce blog.

Ce lien me donne une clarté complète sur l'achèvement des gestionnaires (à partir d'un développeur point de vue, il définit exactement ce dont nous avons besoin pour comprendre).

@échapper fermetures:

Lorsque vous êtes de passage à la fermeture en fonction de ses arguments, à l'utiliser après la fonction du corps est exécuté et renvoie le compilateur de retour. Lorsque la fonction se termine, le champ d'application de la passé de fermeture existent et ont une existence dans la mémoire, jusqu'à ce que la fermeture soit exécutée.

Il y a plusieurs façons d'échapper à la fermeture en fonction contenante:
- De stockage: Lorsque vous avez besoin de stocker la fermeture de la variable globale, de la propriété ou de tout autre système de stockage qui existent dans la mémoire du passé de l'appel de la fonction est exécutée et retour le compilateur de retour.
- D'exécution asynchrone: Lorsque vous êtes l'exécution de la fermeture de manière asynchrone à l'expédition, la file d'attente tiendra la fermeture de la mémoire pour vous, peut être utilisé à l'avenir. Dans ce cas, vous n'avez aucune idée de quand la fermeture sera exécuté.
Lorsque vous essayez d'utiliser la fermeture dans ces scénarios, la Swift compilateur affiche l'erreur:

Pour plus de clarté sur ce sujet, vous pouvez consulter la ce post sur les Moyennes.

J'espère que vous aurez une bonne compréhension de ce lien.

Si vous avez des questions (mais assurez-vous de lire ce lien, ligne par ligne, d'abord; c'est très bien expliqué), alors n'hésitez pas à partager votre commentaire.

Grâce, continuez à poster si cette réponse doit mettre à jour

vos liens ont été très utiles
Merci, profiter de codage en Swift
que faire si nous conservons une fermeture mais ne pas l'appeler plus tard. Ou si la méthode m'a appelé deux fois, mais nous avons appelé la fermeture en une seule fois. Puisque nous savons que le résultat est le même.
Je pense que vous parler au sujet d'échapper à la fermeture, la Fermeture ne va pas s'exécuter jusqu'à ce que vous ne sera pas l'appeler. Dans l'exemple ci-dessus, si l'appel de méthode doSomething 2 fois 2 completionHandler objet ajoutera dans completionHandlers tableau. Si vous prenez le premier objet de completionHandlers tableau et de l'appel qu'elle exécutera mais completionHandlers tableau comte restera même(2).
La fermeture sont le type de référence (comme la classe), lorsque vous attribuer de nouvelles fermetures de la variable puis propriété/variable pointeront à nouveau la fermeture de sorte ARC de libérer de la mémoire pour les précédentes fermetures.

OriginalL'auteur

Voici une petite classe d'exemples que j'utilise pour me rappeler comment @échapper œuvres.

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 preceeds/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 `anotherThing()` and tells us we need to allow our own completion
        //closure to be @escaping too.  `anotherThing`'s completion block will be retained in memory until
        //it is executed, so our completion closure must explicitely do the same.
        runAsyncTask {
            completion()
        }
    }





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

}

Élégant réponse !

OriginalL'auteur

import UIKit
import Alamofire

//Modèle

class ShortlistCountResponse : Decodable {
    var response : String?
    var data : ShortlistcountData?

}
class ShortlistcountData : Decodable {

    var totalpropFavcount : Int?
    var totalprojFavcount : Int?

}

//Définition de classe générique......

static func fetchGenericData<T: Decodable>(urlString: String,params : [String:Any], completion: @escaping (T) -> ()) {
        let url = urlString
        let headers = ["Content-Type": "application/x-www-form-urlencoded", "Accept":"application/json"]
        Alamofire.request(url, method: .post, parameters:params, encoding: URLEncoding.default, headers: headers).responseJSON { response in
            print(response.request?.urlRequest ?? "")
            print(params)
            print(response.data ?? "")
            print(response.value ?? "")
            switch(response.result) {
            case .success(_):
                if let data = response.data{
                    do {
                        let gotData = try JSONDecoder().decode(T.self, from: data)
                        completion(gotData)

                    }
                    catch let jsonErr {
                        print("Error serializing json:", jsonErr)
                        ActivityIndicator.dismissActivityView()

                    }
                    DispatchQueue.main.async {
                        ActivityIndicator.dismissActivityView()
                    }
                }
                break
            case .failure(_):
                print(response.result.error ?? "")
                ActivityIndicator.dismissActivityView()


                break

            }
        }
}

//le plaisir d'appel

override func viewDidLoad() {
    super.viewDidLoad()

            let userID = ""
            let languageID = ""
            let params = ["userID":userID,"languageID":languageID]
            var appDelegate: AppDelegate?
            Service.fetchGenericData(urlString: "your url...", params: params) { (shortlistCountResponse : ShortlistCountResponse) in
             print(shortListCountResponse.data.totalprojFavcount ?? 0)

            }
}

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.