Achèvement rapide du bloc

Je vais avoir un moment difficile la compréhension d'un problème que je vais avoir.
Pour simplifier, je vais utiliser UIView méthode.
En gros, si j'écris la méthode

UIView.animateWithDuration(1, animations:  {() in
        }, completion:{(Bool)  in
            println("test")
    })

il fonctionne très bien.
Maintenant, si je fais la même méthode, mais la création d'une chaîne de caractères comme suit:

    UIView.animateWithDuration(1, animations:  {() in
        }, completion:{(Bool)  in
            String(23)
    })

Il s'arrête de fonctionner. Erreur de compilateur: argument Manquant pour le paramètre "retard" dans l'appel

Maintenant, voici la partie étrange. Si je n'ai exactement le même code que celui qui échoue, mais il suffit d'ajouter une commande d'impression comme suit:

   UIView.animateWithDuration(1, animations:  {() in
        }, completion:{(Bool)  in
            String(23)
            println("test")
    })

il commence à travailler à nouveau.

Mon problème est fondamentalement la même chose. Mon code:

   downloadImage(filePath, url: url) { () -> Void in
         self.delegate?.imageDownloader(self, posterPath: posterPath)
        }

Ne fonctionne pas. Mais si je change de.

 downloadImage(filePath, url: url) { () -> Void in
             self.delegate?.imageDownloader(self, posterPath: posterPath)
                println("test")
            }

ou encore:

downloadImage(filePath, url: url) { () -> Void in
             self.delegate?.imageDownloader(self, posterPath: posterPath)
             self.delegate?.imageDownloader(self, posterPath: posterPath)
            }

Il fonctionne très bien.
Je ne comprends pas pourquoi ce qui se passe. Je suis près à accepter que c'est un bug du compilateur.

OriginalL'auteur Wak | 2014-09-21

10

Fermetures de Swift ont rendement implicite lorsqu'ils sont constitués d'un expression unique. Cela permet succincte code comme ceci:
```
reversed = sorted(names, { s1, s2 in s1 > s2 } )
```
Dans votre cas, lorsque vous créez votre chaîne ici:
```
UIView.animateWithDuration(1, animations:  {() in }, completion:{(Bool) in
    String(23)
})
```
vous finissent par retourner cette chaîne et qui fait de la signature de votre fermeture:
```
(Bool) -> String
```
Qui ne correspond plus à ce qui est requis par animateWithDuration's la signature (qui se traduit par Swift cryptique Missing argument for parameter 'delay' in call erreur, car il ne peut pas trouver une signature appropriée pour correspondre).

Une solution facile est d'ajouter un retour à vide à la fin de votre fermeture:
```
UIView.animateWithDuration(1, animations:  {() in}, completion:{(Bool) in
    String(23)
    return
})
```
Qui rend votre signature ce qu'elle devrait être:
```
(Bool) -> ()
```
Votre dernier exemple:
```
downloadImage(filePath, url: url) { () -> Void in
    self.delegate?.imageDownloader(self, posterPath: posterPath)
    self.delegate?.imageDownloader(self, posterPath: posterPath)
}
```
fonctionne parce qu'il y a deux expressions, pas un seul, rendement implicite a lieu uniquement lorsque la fermeture contient une expression unique. Donc, que cette fermeture n'est pas de retourner quoi que ce soit et qui correspond à sa signature.

Merci. Mais pourquoi ne pas échouer si j'ajoute String(23) et de copier la même ligne de nouveau comme: String(23); String(23); ?
J'ai été réellement dans le milieu de préciser que dans la réponse. Voir modifier.
Merci pour cette réponse, m'a aidé à comprendre pourquoi j'ai eu une étrange "ne peut pas invoquer 'animateWithDuration" avec une liste d'arguments de type..." erreur. Le correctif a été exactement la même.

OriginalL'auteur Mike S

Vous devez vous connecter pour publier un commentaire.