Pourquoi ajouter “()” après la fermeture du corps dans Golang?

Je suis en train de lire The Go Programming Language Specifications et je me trouve pas vraiment comprendre avec les "()" après la fermeture du corps:

Dans Function literals:

func(ch chan int) { ch <- ACK }(replyChan)`

Dans Defer statements's exemple:

//f returns 1
func f() (result int) {
    defer func() {
        result++
    }() //why and how?
    return 0
}

Je ne suis pas clair sur la raison d'ajouter & utilisation de "()" après la fermeture du corps, de l'espoir, quelqu'un peut expliquer cela clairement.

InformationsquelleAutor Reck Hou | 2013-04-15

closures go

64

Ce n'est pas que () doit être ajouté après (seulement) un fermeture dans defer. Le langage de spécifications pour le reporter la déclaration mandat que "l'Expression' toujours doit être un appel de fonction.

Et pourquoi est-il si? C'est la même qu'avec toute autre fonction, de "différer" ou pas:

Considérer:
```
func f() int { return 42 }
```
et
```
a := f
```
vs
```
b := f()
```
La première expression du membre de droite est une fonction de la valeur. Dans la deuxième version, le membre de droite est la valeur retourné par la fonction - c'est à dire un appel de fonction.

Est donc la sémantique de:
```
defer f
```
vs
```
defer f()
```
sauf que la première version n'a pas de sens dans le contexte de "différer", et donc le cahier des charges mentionne qu'il doit être le second formulaire (uniquement).

C'est à mon humble avis aussi plus facile à apprendre, grâce à l'orthogonalité avec le évoquées ci-dessus appel de fonction à l'extérieur de la "différer" instruction.

Notez également qu'un appel de fonction n'est pas uniquement fn-expr suivie par (), mais une expression de la liste est généralement à l'intérieur de la parenthèse (y compris une liste vide). Il y a une grosse différence entre:
```
for i := range whatever {
        defer func() { fmt. Println(i) }()
}
```
et
```
for i := range whatever {
        defer func(n int) { fmt. Println(n) }(i)
}
```
La première version imprime la valeur de " i "dans le moment de la fermeture exécute, la deuxième imprime la valeur de" i " dans le moment où le reporter déclaration était exécuté.
- J'ai reçu votre point, de sorte que dans func(ch chan int) { ch <- ACK }(replyChan), func(ch chan int) { ch <- ACK } signifie que la définition de la fermeture, (replyChan) signifie "exécuter cette fermeture avec paramètre replyChan".
- Une autre question avec votre dernier exemple: quelle est la différence entre in the moment when the closure executes & in the moment when the defer statement was executed? Si j'ai un return après for{}, à la fois de ces 2 defers doit s'exécuter avant return en même temps, n'est-ce pas?
- Exécutez play.golang.org/p/Orm-0EaBY6 et regardez le résultat
- J'ai fait quelques expériences à ce sujet, mais encore confus à propos de defer exécution, savez-vous quel article peut expliquer cela?
- Je crois que les spécifications (lien dans la réponse) de façon concise, mais complète à propos de la 'reporter' instruction. Je pense que vous êtes bienvenus pour mettre une autre SORTE de question à propos de tous les détails qui ne sont pas claires pour vous.
- Dois-je comprendre correctement que dans func(ch chan int) { ch <- ACK }(replyChan) ch et chan sont les paramètres de la fonction littérale, si oui, pourquoi ne sont-ils pas séparés par une virgule? Merci?
- Découvrez: blog.learngoprogramming.com/...
- Cette dernière phrase est confuse (peut-être erronée): Essayez de play.golang.org/p/8RBNq0LrUNP et vous pouvez voir que la deuxième forme de capture de la valeur de i au point de le remettre (car la fermeture a un i argument), tandis que la première forme de feuilles i libre (pas d'arguments à la fermeture). La première forme imprime la valeur i a en fonction de la fin.
InformationsquelleAutor zzzz
15
Références

La Spécification De Langage De Programmation Go

Des types de fonction

Un type de fonction désigne l'ensemble de toutes les fonctions avec la même
paramètre et les types de résultats.
```
FunctionType   = "func" Signature .
Signature      = Parameters [ Result ] .
Result         = Parameters | Type .
Parameters     = "(" [ ParameterList [ "," ] ] ")" .
ParameterList  = ParameterDecl { "," ParameterDecl } .
ParameterDecl  = [ IdentifierList ] [ "..." ] Type .
```
Les déclarations de fonction

Une déclaration de fonction se lie à un identifiant, le nom de la fonction, pour un
fonction.
```
FunctionDecl = "func" FunctionName Signature [ Body ] .
FunctionName = identifier .
Body         = Block .
```
Des littéraux de fonction

Littéral de fonction représente une fonction anonyme. Il se compose d'une
spécification du type de fonction et d'un corps de fonction.
```
FunctionLit = FunctionType Body .
```
Fonction des littéraux sont des fermetures: ils peuvent faire référence à des variables définies dans
entouré d'une fonction. Ces variables sont ensuite partagés entre les
entourant la fonction et la fonction littérale, et ils survivre en tant que
tant qu'ils sont accessibles.

Littéral de fonction peut être affectée à une variable ou directement invoquée.

Appels

Donné une expression f de type fonction F,
```
f(a1, a2, … an)
```
appels f avec des arguments a1, a2, … an.

Dans un appel de fonction, la valeur de la fonction et les arguments sont évalués en
l'ordre habituel. Après ils sont évalués, les paramètres de l'appel
sont passés par valeur de la fonction et de la fonction appelée commence
l'exécution. Le retour des paramètres de la fonction sont passés par valeur
de retour à l'appel de la fonction lorsque la fonction retourne.

Reporter états

Un "defer" instruction appelle une fonction dont l'exécution est différée
pour le moment les environs de la fonction retourne.
```
DeferStmt = "defer" Expression .
```
L'expression doit être une fonction ou un appel de méthode. Chaque fois que le
"defer" exécution d'une instruction, la valeur de la fonction et des paramètres à l'
appel sont évalués comme d'habitude et enregistré à nouveau, mais la fonction elle-même est
pas invoquée. Au lieu de cela, différé appels sont exécutés dans l'ordre LIFO
immédiatement avant les environs de la fonction retourne, après le retour
les valeurs, le cas échéant, ont été évalués, mais avant de les retourner
l'appelant.
Puisque vous êtes encore confus, voici une autre tentative de fournir une réponse à votre question.

Dans le contexte de votre question, () est l'appel à la fonction d'opérateur.

Par exemple, la fonction littérale
```
func(i int) int { return 42 * i }
```
représente une fonction anonyme.

La fonction littérale suivie par la () l'invocation de la fonction de l'opérateur
```
func(i int) int { return 42 * i }(7)
```
représente une fonction anonyme qui est ensuite directement invoquée.

Normalement, dans un appel de fonction, la valeur de la fonction et les arguments sont évalués dans l'ordre habituel. Après ils sont évalués, les paramètres de l'appel sont transmis par valeur de la fonction et de la fonction appelée commence l'exécution. Le retour des paramètres de la fonction sont passés par valeur de retour à l'appel de la fonction lorsque la fonction retourne.

Cependant, l'invocation de la fonction par le biais de la reporter l'instruction est un cas spécial. Chaque fois que le "reporter" exécution d'une instruction, la valeur de la fonction et les paramètres de l'appel sont évalués comme d'habitude et enregistré à nouveau, mais la fonction n'est pas appelée. Au lieu de cela, différé appels sont exécutés dans l'ordre LIFO immédiatement avant les environs de la fonction retourne, après les valeurs de retour, le cas échéant, ont été évalués, mais avant qu'ils sont retourné à l'appelant.

La reporter la déclaration de l'expression doit être une fonction ou un appel de méthode qui est appelée directement, et pas seulement une fonction ou une méthode littérale qui n'est pas appelé directement. Par conséquent, la fonction ou de la méthode littérale doit être suivie par le () l'invocation de la fonction de l'opérateur, de sorte que le reporter déclaration expression est une fonction ou un appel de méthode.

Le reporter déclaration
```
defer func(i int) int { return 42 * i }(7)
```
est valide.

Le reporter déclaration
```
defer func(i int) int { return 42 * i }
```
est pas valide: syntax error: argument to go/defer must be function call.

InformationsquelleAutor peterSO

Si vous ne voulez pas lire de longues réponses:

str := "Alice"
go func(name string) {
    fmt.Println("Your name is", name)
}(str)

Est la même que:

str := "Alice"
f := func(name string) {
    fmt.Println("Your name is", name)
}
go f(str)

InformationsquelleAutor Erikas

Vous devez vous connecter pour publier un commentaire.