La forme de base de la définition de fonction est la suivante.
nom de la fonction func(argument)Type de retour{
Contenu du traitement...
}
C'est un flux pour prendre un argument pour une fonction, spécifier la valeur de retour de la fonction et écrire le contenu du traitement.
Définissons maintenant une fonction simple.
main.go
func test(x, y int) int {
a := x * y
return a
}
func main() {
fmt.Println(test(10, 5)) //50
}
Le test de fonction est défini par les types int x et y, et le type int est spécifié comme type de retour. Le processus est affecté à la variable a, la valeur renvoyée est reçue par la fonction principale et la valeur est spécifiée et sortie.
En outre, plusieurs valeurs de retour peuvent être renvoyées.
main.go
func test(x, y int) (int, int) {
a := x * y
b := x / y
return a, b
}
func main() {
a, b := test(10, 5)
fmt.Println(a, b) //50 2
}
Vous pouvez également définir une fonction sans valeur de retour en omettant le type de valeur de retour comme indiqué ci-dessous.
main.go
func test() {
fmt.Println("salut!")
return
}
func main(){
test() //salut!
}
Il existe les idiomes suivants pour la gestion des erreurs.
main.go
import (
"os"
"log"
)
func main() {
_, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
}
Ce programme est un processus qui génère un message d'erreur s'il y a une erreur lors de l'ouverture d'un fichier. Par conséquent, j'importe le package os et le package log.
Les fonctions anonymes, comme leur nom l'indique, définissent les fonctions comme "anonymes", contrairement aux fonctions nommées qui sont explicitement définies.
main.go
func main() {
a := func(x, y int) int { return x + y }
fmt.Println(a(2, 5)) //7
}
Vous pouvez également dessiner encore plus court en prenant l'argument de la fonction anonyme tel quel.
main.go
func main() {
fmt.Println(func(x, y int) int { return x + y }(2, 5)) //7
}
Cela produira la même chose pour les définitions de fonction anonymes utilisant des littéraux de fonction.
Vous pouvez renvoyer une fonction dans une fonction à l'aide d'une fonction anonyme.
main.go
func test() func() {
return func() {
fmt.Println("production")
}
}
func main() {
a := test()
a() //production
}
Ce programme affecte implicitement une fonction qui n'a aucun argument et aucune valeur de retour comme valeur de retour à la variable a et la renvoie.
De même, il est possible de prendre une fonction comme argument.
main.go
func test(a func()) {
a()
}
func main() {
test(func() {
fmt.Println("production") //production
})
}
Dans ce programme, ** une fonction qui n'a ni argument ni valeur de retour ** est prise comme argument de la fonction test, et ce qui est appelé est produit en la passant comme fonction anonyme dans la fonction main.
Dans Go, les fonctions anonymes sont des ** fermetures **, comme les fermetures de fonctions. Normalement, les variables définies dans la fonction (variables locales) sont détruites une fois l'exécution de la fonction terminée, mais en se connectant à la fermeture, elles ne sont pas détruites tant que la fermeture est référencée. Il n'y a pas. En utilisant cette logique, il est possible de réaliser des ** fonctions de type générateur ** que Go n'a pas.
main.go
func test() func() int {
a := 0 //Variables locales référencées depuis la fermeture
return func() int {
a++
return a //Variables locales(Variables appartenant à la fermeture)Référencement
}
}
func main() {
b := test()
fmt.Println(b()) //1
fmt.Println(b()) //2
fmt.Println(b()) //3
fmt.Println(b()) //4
}
Cette fois, j'ai résumé les fonctions! Dans Go, qui n'a pas de fonctions orientées objet, la définition des fonctions sera centrale.
Désormais, je vais résumer la syntaxe du contrôle! !!