Reconnaître l'originalité de la fonction

Les fonctions constituent la structure logique de l'exécution du Code.InGoDans la langue,La composition de base de la fonction est：Mots clésfunc,Nom de la fonction,Liste des paramètres,Valeur de retour,Corps de la fonction et déclarations de retour.

GoLes fonctions linguistiques sont définies dans le format suivant：

func FuncName(/*Liste des paramètres*/) (01 type1, 02 type2/*Type de retour*/) {
	//Corps fonctionnel
	return v1, v2 //Renvoie plusieurs valeurs
}

Copier

Description de la définition de la fonction：

• func：La fonction a un mot cléfuncDéclaration.
• FuncName：Nom de la fonction,Comme convenu,Les initiales des noms de fonctions en minuscules sontprivate,Les mots en majuscules sontpublic.
• Liste des paramètres：La fonction peut avoir0Liste des paramètres ou plus,Le format du paramètre est：Nom de la variable Type,S'il y a plus d'un paramètre,Séparé par des virgules,Les paramètres par défaut ne sont pas pris en charge
• Type de retour：
• La valeur de retour ci - dessus indique deux noms de variables01Et02（Paramètre de retour de commande）,Ce n'est pas nécessaire,Seul le type peut avoir un nom de variable.
• S'il n'y a qu'une seule valeur de retour et qu'aucune variable de valeur de retour n'est déclarée,Alors vous pouvez omettre,Inclure les parenthèses retournées.
• Si aucune valeur n'est retournée,Omettre le dernier message de retour directement.
• S'il y a une valeur de retour,Alors vous devez ajouter à l'intérieur de la fonctionreturnDéclarations.

1,Pas de paramètre pas de valeur de retour.

package main

import "fmt"

//Définition d'une fonction sans paramètre et sans valeur de retour
func MyFunc() {
	a := 666
	fmt.Println("a =", a)
}

// C'est la même chose si la fonction appelée est placée en haut ou en bas ,La procédure commence parmainLa fonction entre dans,Puis appelezMyFuncFin de la fonction.

func main() {
	// Appel à une fonction sans paramètre et sans valeur de retour ：Nom de la fonction()
	MyFunc()
}

Copier

2,Valeur de retour avec ou sans paramètre.

1, Liste des paramètres généraux .

package main

import "fmt"

/*
 Définition d'une fonction de valeur de retour avec ou sans paramètre , Liste des paramètres généraux 
Lors de la définition d'une fonction, Après le nom de la fonction () Les paramètres définis sont appelés paramètres formels 
Passage des paramètres, Ne peut être passé qu'à un paramètre formel par un argument ,Pas l'inverse., C'est un seul passage 
*/

func MyFunc01(a int) {
	fmt.Println("a =", a)
}

func MyFunc02(a int, b int) {
	fmt.Printf("a = %d, b = %d\n", a, b)
}

//Ou écrire
func MyFunc03(a, b int) {
	fmt.Printf("a = %d, b = %d\n", a, b)
}

func MyFunc04(a int, b string, c float64) {
}

func MyFunc05(a, b string, c float64, d, e int) {

}

// L'écriture suivante est recommandée , C'est assez clair. .
func MyFunc06(a string, b string, c float64, d int, e int) {

}

func main() {
	// Méthode d'appel de la fonction avec paramètre et valeur de retour ： Nom de la fonction(Paramètres requis)
	// Les arguments passés par la fonction point sont appelés arguments réels 
	MyFunc01(666)
	MyFunc02(666, 777)
}

Copier

2, Type de paramètre indéfini .

package main

import "fmt"

//Précédemment défini, Sont des paramètres normaux , Ou paramètre fixe ,Voici quelques exemples：
func MyFunc01(a int, b int) {

}

// Ensuite vient le type de paramètre indéfini 
//...int  Un genre comme ça , Est un type de paramètre indéfini 
//Attention!：Paramètre indéfini,C'est sûr.（Seulement） Est le dernier paramètre du paramètre formel 
func MyFunc02(args ...int) { // Les paramètres passés peuvent être: 0Ou plus
	fmt.Printf("len(args) = %d\n", len(args)) // Représente le nombre de paramètres passés par l'utilisateur 

	// Comment imprimer les paramètres entrés par l'utilisateur ,Peut passerforBoucle pour exécuter
	// for i := 0; i < len(args); i++ {
	// 	fmt.Printf("args[%d] = %d\n", i, args[i])
	// }
	//Ou utiliserrangePour imprimer,Les codes sont les suivants:
	for i, date := range args { // Représente la liste des paramètres de traversée 
		fmt.Printf("args[%d] = %d\n", i, date)
	}
}

// func MyFunc03(a int,b int, test ...int){
// 	// C'est la bonne démonstration 
// }

// func MyFunc04(a int, test ... int, b int){
// 	// C'est la mauvaise démo , Que ce soit au milieu , Ou au début. ,Tout est interdit
// }

func main() {
	MyFunc02()
	MyFunc02(1)
	MyFunc02(1, 2, 3)
}

Copier

3, Passage de paramètres indéfinis .

package main

import "fmt"

/*
1, Passe d'abord quatre valeurs à travers la fonction principale test Paramètre indéfini dans la fonction args.
*/
func myfunc(tmp ...int) {
	for _, date := range tmp {
		fmt.Printf("date = %d\n", date)
	}
}

func test(args ...int) {
	// Si vous passez tous les éléments à myfunc,Les méthodes suivantes peuvent être utilisées
	//myfunc(args...)

	// Je veux juste passer deux éléments. ,Comment écrire
	myfunc(args[2:]...) //Montre - moi.args[0]~args[2]（Non comprisargs[2]） Élément correspondant passé 
	myfunc(args[:2]...) //Deargs[2]（Y compris:args[2]En soi）C'est parti., Tout le reste est passé. 
}

func main() {
	test(1, 2, 3, 4)
}

Copier

3,Valeur de retour sans paramètre.

1, Valeur de retour unique .

package main

import "fmt"

//Valeur de retour sans paramètre, Un exemple de valeur de retour 
// Une fonction avec une valeur de retour doit passer par return Fonction d'interruption de mot - clé ,AdoptionreturnRetour
func myfunc() int {
	return 666
}

func MyFunc01() (test int) {
	return 777
}

// Définissez une valeur de retour appelée testVariable de, En attribuant une valeur à la variable ,Et puisreturnDehors!,- Oui.goécriture recommandée, C'est une écriture assez courante 
func MyFunc02() (test int) {
	test = 888
	return
}

func main() {
	//Rédaction standard
	var a int
	a = myfunc()
	fmt.Println("a =", a)
	// Vous pouvez également utiliser l'écriture automatique Push to type 
	b := myfunc()
	fmt.Println("b =", b)

	c := MyFunc01()
	fmt.Println("c =", c)

	d := MyFunc02()
	fmt.Println("d =", d)
}

Copier

2,Plusieurs valeurs de retour.

package main

import "fmt"

func MyFunc01() (int, int, int) {
	return 1, 2, 3

}

//Écrire couramment
func MyFunc02() (a, b, c int) {
	a, b, c = 4, 5, 6
	return
}

func main() {
	a, b, c := MyFunc02()
	fmt.Printf("a = %d,b = %d, c = %d\n", a, b, c)
}

Copier

4,Valeur de retour avec paramètre.

package main

import "fmt"

//Définition de la fonction
func MaxAndMin(a, b int) (max, min int) {
	if a > b {
		max = a
		min = b
	} else {
		max = b
		min = a
	}
	return //Fonction avec valeur de retour,Doit passerreturnMot - clé retourné
}

func main() {
	//Appel de fonction.
	max, min := MaxAndMin(10, 20)
	fmt.Printf("max = %d, min = %d\n", max, min)

	// Jeter une valeur par une variable anonyme 
	a, _ := MaxAndMin(5, 2)
	fmt.Println("a =", a)
}

Copier

5, Processus normal d'appel de fonction .

En fonction , L'ordre d'exécution du programme est ,Appelez d'abord,Retour à.

package main

import "fmt"

func funcc(c int) {
	fmt.Println("c =", c)
}

func funcb(b int) {
	funcc(b - 1)
	fmt.Println("b =", b)
}

func funca(a int) {
	funcb(a - 1)
	fmt.Println("a =", a)
}

func main() {
	funca(3)
	fmt.Println("main")
}

Copier

Peut - être que les fonctions ne sont pas faciles à lire , Donc vous pouvez l'analyser un par un en dessinant ：

6, Processus d'appel de fonctions récursives .

1, Reconnaître les fonctions récursives .

Une fonction récursive est une fonction qui peut s'appeler directement ou indirectement .

Les fonctions récursives ont généralement la même structure：Une condition de sortie et un corps récursif. Ce qu'on appelle une condition de saut est de décider si la récursion doit être interrompue en fonction des paramètres entrants ,Et le corps récursif est une partie du traitement que la fonction elle - même fait.

package main

import "fmt"

//Récursion, C'est s'appeler en cours d'exécution 
func test(a int) {
	// Vous devez définir les conditions de sortie , Sinon, il y aura un cycle infini 
	if a == 1 {
		fmt.Println("a =", a)
		return // Mettre fin à l'appel de fonction 
	}
	//Appel de fonction lui - même
	test(a - 1)
	fmt.Println("a =", a)
}

func main() {
	test(3)
	fmt.Println("main")
}

Copier

Analyser le processus d'exécution en dessinant .

Détailler le processus d'exécution en utilisant le texte , Notez que la représentation textuelle est un peu plus simple que les étapes de dessin , En fait, il y a quelques étapes à franchir. .

• 1,Adoptionmain Entrée de la fonction dans le programme .
• 2,Appelez la fonctiontest, Et assigner des variables aPour3.
• 3, Programme à la fonction test,En ce momenta=3,Non - respect des conditions de jugement, Alors descendez. ,Appelez la fonctiontest, Et assigner des variables aPour（a-1）,En fait, c'est3-1
• 4, Le programme revient à la fonction test,En ce momenta=2,Non - respect des conditions de jugement, Alors descendez. ,Appelez la fonctiontest, Et assigner des variables aPour（a-1）,En fait, c'est2-1
• 5, Le programme revient à la fonction test,En ce momenta=1,Satisfait aux critères de jugement, Alors entrez dans le jugement , Imprimer maintenant aValeur de,Pour1,Et puisreturnSaute!.
• 6,Après avoir sauté, Retour à la page 4Pas, Puis imprimez ceci aValeur de,Pour2, Terminer l'opération ,Saute!.
• 7,Après avoir sauté, Retour à la page 3Pas, Puis imprimez ceci aValeur de,Pour3, Terminer l'opération ,Saute!.
• 8,Après avoir sauté, Retour à la page 2Pas, Puis imprimez une chaîne main.

Dont: 6,7Deux pas, Voici une analyse plus simple ：

Devant5Pas, C'est plus facile à comprendre , Mais à la 6Pas, Je me suis un peu évanoui , Je ne sais pas pourquoi ils reviennent pour imprimer , Et puis il remonte. , Voir l'exemple ci - dessus de l'appel de fonction normal , Un peu. ,En fait, jusqu'à la6Pas（ C'est la fin de l'étape 5 ）, L'équivalent d'un programme terminé 4 Appel de fonction step , Combiner d'abord , Théorie du retour en arrière , C'est la fin de l'appel , Il est temps d'imprimer .Même chose.,À la7Pas（C'est la6 Achèvement des étapes ）, L'équivalent d'un programme terminé 3 Appel de fonction step ,Une fois terminé, Imprimer les valeurs à ce moment - là , Et puis repoussez - vous de la même façon , Jusqu'à ce que le programme ait terminé la planification logique finale .

2, Calculer la somme cumulative des nombres .

Hier, quand,UtiliséforBoucle pour réaliser, Vous pouvez maintenant ne pas regarder en arrière le document , Frappe - le toi - même for Somme cumulée des cycles .

package main

import "fmt"

func main() {
	sum := 0
	for i := 1; i <= 100; i++ {
		sum = sum + i
	}
	fmt.Println("1Ajouter à100La somme de:", sum)
}

Copier

Pour comprendre, Ce n'est probablement pas très difficile , C'est calculé à partir de 1Ajouter à100Et, Vous pouvez aussi écrire à partir de 100Ajouter à1Et,Comme suit：

package main

import "fmt"

func main() {
	sum := 0
	for i := 100; i >= 1; i-- {
		sum = sum + i
	}
	fmt.Println("100Ajouter à1La somme de:", sum)
}

Copier

Alors, Il est maintenant possible d'essayer d'implémenter une fonction récursive ,Ou de1Ajouter à100C'est parti..

package main

import "fmt"

func test(i int) int {
	if i == 100 {
		return 100
	}
	return i + test(i+1)
}

func main() {
	var sum int
	sum = test(1)
	fmt.Println("1Ajouter à100La somme de:", sum)
}

Copier

Si vous ne dessinez pas , Lisez d'abord le processus exécuté par la fonction .

1,Adoptionmain Entrée de la fonction dans le programme .

2,Définir une variablesum, Qu'il soit égal à une fonction test(), Et les paramètres de passage font i=1.

3, Aller à la fonction testMoyenne,En ce momenti=1, D'abord, puis entrez. ifJugement,Apparemment pas égal à100,Continue.,Je l'ai.i+test(i+1),En fait,1+test(1+1),En ce moment1Réserve,À l'arrièretest(1+1) Entrer à nouveau dans la fonction .

4, Revenir à la fonction testMoyenne,En ce momenti=2, D'abord, puis entrez. ifJugement,Apparemment pas égal à100,Continue.,Je l'ai.i+test(i+1),En fait,2+test(2+1),En ce moment2Réserve,À l'arrièretest(2+1) Entrer à nouveau dans la fonction .

5, Revenir à la fonction testMoyenne,En ce momenti=3, D'abord, puis entrez. ifJugement,Apparemment pas égal à100,Continue.,Je l'ai.i+test(i+1),En fait,3+test(3+1),En ce moment3Réserve,À l'arrièretest(3+1) Entrer à nouveau dans la fonction .

6, Revenir à la fonction testMoyenne,En ce momenti=4, D'abord, puis entrez. ifJugement,Apparemment pas égal à100,Continue.,Je l'ai.i+test(i+1),En fait,4+test(4+1),En ce moment4Réserve,À l'arrièretest(4+1) Entrer à nouveau dans la fonction . ...... Ce cycle alternatif99Une fois,Jusqu'à la dernière fois.

7, Revenir à la fonction testMoyenne,En ce momenti=100, D'abord, puis entrez. ifJugement,égal à100,Et puisreturnUn100, Et tant de fois devant , A été accumulé en 1+2+3...+99,Plus ça.100, C'est le résultat final. .

Ensuite, essayez à nouveau 100Ajouter à1Somme cumulative de.

package main

import "fmt"

func test01(i int) int {
	if i == 1 {
		return 1
	}
	return i + test01(i-1)
}

func main() {
	var sum int
	sum = test01(100)
	fmt.Println("100Ajouter à1La somme de:", sum)
}

Copier

Ce processus d'addition et d'appel , C'est essentiellement la même chose que le haut .

7,Type de fonction.

1, Reconnaître les types de fonctions .

IngoDans la langue,La fonction est également un type de données,Ça marche.typePour le définir, Son type est le même paramètre qu'il a. ,Un type de la même valeur de retour.

package main

import "fmt"

//Ajouter deux nombres
func Add(a, b int) int {
	return a + b
}

//Soustraction de deux nombres
func Minus(a, b int) int {
	return a - b
}

//La fonction est également un type de données,Adoptiontype Vous pouvez donner un nom à la fonction , Puis appelez la fonction par ce nom .
//FuncTypeEst un type de fonction
type FuncType func(int, int) int //Pas de nom de fonction,Non.{}

func main() {
	// Fonctions d'appel traditionnelles 
	var result int
	result = Add(8, 5)
	fmt.Println("result =", result)

	// Appelez maintenant avec le nom de type de fonction que vous venez de définir 
	var ftest FuncType     //Définir une variableftest, Son type vient d'être défini FuncType
	ftest = Add            // Vous pouvez ensuite assigner le nom de la fonction à la variable ftest,De sorte queftest Capacité de fonction avec le nom correspondant 
	result = ftest(10, 20) //Équivalent à restult = Add(10,20)
	fmt.Println("result1 =", result)

	//Encore une fois, Vous pouvez également assigner un autre nom de fonction à une variable .
	ftest = Minus
	result = ftest(1, 1) //Équivalent à restult = Minus(1,1)
	fmt.Println("result2 =", result)
}

Copier

Ce qui précède est un exemple de définition traditionnelle et d'invocation , Il est également possible de définir et d'appeler de la manière suivante .

package main

import "fmt"

type FuncType func(int, int) int //Déclarer un type de fonction

// Un des types d'arguments dans la fonction est le type de fonction ：f FuncType
func Calc(a, b int, f FuncType) (result int) {
	result = f(a, b)
	return
}

func Add(a, b int) int {
	return a + b
}

func main() {
	//Appel de fonction, Le troisième argument est le nom de la fonction ,Paramètres de cette fonction, La valeur de retour doit être et FuncTypeLes types sont cohérents
	a := Calc(3, 3, Add)
	fmt.Println("a=", a)
}

Copier

Donc ce type de fonction ,À quoi bon?, N'est - ce pas plus facile d'appeler directement .Et puis..., On verra ce qu'il fait. .

2,Polymorphisme.

Les types de fonctions peuvent être appliqués aux Polymorphismes , Avant d'entrer dans l'exemple officiel , Commençons par un code d'addition ordinaire .

package main

import "fmt"

//Ajouter deux nombres
func Add(a, b int) int {
	return a + b
}
// La fonction du programme principal appelle la fonction d'addition 
func Calc(a, b int) (result int) {
	fmt.Println("Calc")
	result = Add(a, b)
	return
}

func main() {
	a := Calc(3, 3)
	fmt.Println("a=", a)
}

Copier

Ensuite, regardez l'autre écriture ：

package main

import "fmt"

type FuncType func(int, int) int

//Ajouter deux nombres
func Add(a, b int) int {
	return a + b
}

//Soustraction de deux nombres
func Minus(a, b int) int {
	return a - b
}

//Multiplier deux nombres
func Mul(a, b int) int {
	return a * b
}

/*
Calculatrice, Quatre opérations sont possibles 
Fonction de rappel, La fonction a un argument qui est un type de fonction , Cette fonction est la fonction de rappel . Dans l'exemple ci - dessous ,Paramètresftest Est le type de fonction défini ci - dessus (FuncType)
Polymorphisme,Plusieurs formes,Appelez la même interface,Différentes performances, Différents résultats peuvent être obtenus .
*/

func Calc(a, b int, ftest FuncType) (result int) {
	fmt.Println("Calc")
	result = ftest(a, b)
	return
}

func main() {
	a := Calc(3, 3, Mul)
	fmt.Println("a=", a)
}

Copier

Description simple.

Pas très compréhensif au début. , Mais j'ai pratiqué quelques exemples , J'ai découvert quelques - uns de ces mystères .Demain La définition de l'entrée commence à comprendre ,Calc(3, 3, Mul) Sur la fonction ,Attention à l'arrière.Mul,équivalent àftestEmplacement, Après le remplacement ,Et vous verrez, Et l'exemple de l'addition que nous venons d'écrire , C'est presque pareil. .

8,Fonctions anonymes et fermetures.

La fermeture est une fonction “Capture” D'autres constantes et variables dans le même champ d'application . Cela signifie que lorsque la fermeture est appelée , Peu importe où le programme est appelé , Les fermetures peuvent utiliser ces constantes ou variables . Il ne se soucie pas si ces variables et constantes capturées ont dépassé la portée , Donc seule la fermeture l'utilise encore , Ces variables existent encore. .

InGoDans la langue, Toutes les fonctions anonymes （Go Dans la spécification linguistique, il s'agit de la quantité de surface numérique fonctionnelle. ）C'est fermé...Une fonction anonyme est une implémentation de fonction qui n'a pas besoin de définir un nom de fonction.

1, Reconnaître les fonctions et les fermetures anonymes .

package main

import "fmt"

func main() {
	a := 10
	str := "mike"

	//Fonction anonyme,Pas de nom de fonction, Ce qui suit n'est que la définition de la fonction 
	f1 := func() { //Type de dérivation automatique, Assigner une opération de fonction anonyme à f1
		fmt.Printf("a =%d, str =%s\n", a, str)
	}
	f1() // Utilisez cette méthode pour faire un appel .

	// Alias un type de fonction anonyme , Cette écriture n'est pas courante .
	type FuncType func() //La fonction n'a pas d'arguments,Aucune valeur de retour
	var f2 FuncType
	f2 = f1
	f2()

	// Définir une fonction anonyme et appeler 
	func() {
		fmt.Printf("a =%d, str =%s\n", a, str)
	}() //Derrière.() Indique que cette fonction anonyme est appelée 

	//Fonction anonyme avec paramètres
	f3 := func(i, j int) {
		fmt.Printf("i =%d, j =%d\n", i, j)
	}
	f3(3, 5)
	//Une autre écriture
	func(i, j int) {
		fmt.Printf("i =%d, j =%d\n", i, j)
	}(5, 3)

	//Fonction anonyme,Valeur de retour avec paramètre
	x, y := func(i, j int) (max, min int) {
		if i > j {
			max = i
			min = j
		} else {
			max = j
			min = i
		}
		return
	}(6, 8)
	fmt.Printf("x = %d, y = %d\n", x, y)
}

Copier

2, Caractéristiques de la capture fermée des variables externes .

package main

import "fmt"

func main() {
	a := 10
	str := "mike"
	func() {
		// Les fermetures saisissent les variables externes par référence 
		a = 666
		str = "go"
		fmt.Printf("a = %d, str = %s\n", a, str)
	}()

	fmt.Printf("a = %d, str = %s\n", a, str)
}

Copier

Résultats obtenus：

a = 666, str = go
a = 666, str = go

Copier

équivalent à une fonction anonyme , Modification de la valeur de la variable , Alors, en dehors de la fonction anonyme , La valeur change également .

Pour vérifier cette fonctionnalité , Maintenant vous pouvez faire une comparaison .

Regardez d'abord à travers un type de fonction normal ：

package main

import "fmt"

func test01() int {
	var a int // Quand une variable n'est pas initialisée ,Par défaut0
	a++
	return a * a	//Fin de l'appel de fonction,aLibération automatique.
}
func main() {
	fmt.Println(test01())
	fmt.Println(test01())
	fmt.Println(test01())
	fmt.Println(test01())
	fmt.Println(test01())
}

Copier

Le résultat est：

$ go run 15_Caractéristiques de la fermeture.go

1
1
1
1
1

Copier

Attention à la phrase ci - dessus ,Appel terminé, La valeur de la variable est automatiquement libérée , Pour obtenir les résultats ci - dessus .

Voici un autre exemple：

package main

import "fmt"
// La valeur de retour de la fonction est une fonction anonyme , Renvoie un type de fonction 
func test02() func() int {
	var a int // Quand une variable n'est pas initialisée ,Par défaut0
	return func() int {
		a++
		return a * a
	}
}
func main() {
	// La valeur de retour supérieure est une fonction anonyme , Renvoie un type de fonction , Donc ici, à travers une variable f Pour appeler la fonction anonyme retournée （Fonction de fermeture）
	//En ce moment, Il ne se soucie pas si ces variables ou constantes capturées sont hors de portée , Tant que la fermeture est toujours utilisée , Ces variables seront toujours là .
	f := test02()
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println(f())
}

Copier

Résultats obtenus：

$ go run 15_Caractéristiques de la fermeture.go

1
4
9
16
25

Copier

En même temps, faites attention à ce qui précède , Fermeture de chaque appel , Alors les dernières valeurs seront sauvegardées , Comme le montrent les résultats ,Chaque appel,a Les valeurs initiales sont toutes les nouvelles valeurs obtenues après la dernière fermeture .

9, Appel différé defer.

1,Compris.defer.

Mots clésdefer Pour retarder une fonction ou une méthode （ Ou la fonction anonyme actuellement créée ）Mise en œuvre, Délai jusqu'à la fin de la fonction .Attention!,defer Une instruction ne peut apparaître qu'à l'intérieur d'une fonction ou d'une méthode .

package main

import "fmt"

func main() {
	//deferAppel différé,Indique qu'il y amain Appelé avant la fin de la fonction , C'est - à - dire mettre à la fin de l'exécution 
	defer fmt.Println("aaaaaaa")
	fmt.Println("bbbbbbb")
}

Copier

defer Les déclarations sont souvent utilisées pour traiter les opérations par paires ,Comme ouvrir、Fermer,Connexion、Déconnecter,Verrouillage、Relâchez la serrure.,,Attendez.,Adoptiondefer,Quelle que soit la complexité de la logique fonctionnelle,Est garanti dans n'importe quel chemin d'exécution,Ressources libérées,Libérer des ressourcesdeferDéclarations, Doit suivre directement l'instruction de demande de ressources .

2,PlusieursdeferOrdre d'exécution.

S'il y a plus d'une fonction deferDéclarations,Ils vont prendreSortie avant et arrière（ C'est - à - dire défini d'abord ,Mise en œuvre postérieure）Exécution séquentielle, Même si une fonction ou un appel différé peut causer une erreur , Ces appels sont toujours exécutés .

package main

import "fmt"

func test(x int) {
	fmt.Println(100 / x) //xPour0Heure,Une exception s'est produite
}

func main() {

	defer fmt.Println("aaaaaaa")
	defer fmt.Println("bbbbbbb")
	defer test(0)
	defer fmt.Println("ccccccc")
}

Copier

Les résultats sont les suivants:：

$ go run 17_PlusieursdeferOrdre d'exécution.go

ccccccc
bbbbbbb
aaaaaaa
panic: runtime error: integer divide by zero

goroutine 1 [running]:
main.test(0x0)
        C:/Users/Administrator/Desktop/gocode/src/day2/17_PlusieursdeferOrdre d'exécution.go:6 +0xa9
main.main()
        C:/Users/Administrator/Desktop/gocode/src/day2/17_PlusieursdeferOrdre d'exécution.go:15 +0x15e
exit status 2

Copier

3,defer En combinaison avec une fonction anonyme .

Commençons par un exemple sans paramètres .

package main

import "fmt"

func main() {
	a := 10
	b := 20
	defer func() {
		fmt.Printf("a = %d, b = %d\n", a, b)
	}()

	a = 100
	b = 200
	fmt.Printf("Extérieur：a = %d, b = %d\n", a, b)
}

Copier

Résultats obtenus：

$ go run 18_defer Utilisation avec des fonctions anonymes .go

Extérieur：a = 100, b = 200
a = 100, b = 200

Copier

Ensuite, définissez deux paramètres pour la fonction anonyme ,Regardez les résultats..

package main

import "fmt"

func main() {
	a, b := 10, 20
	defer func(a, b int) {
		fmt.Printf("a = %d, b = %d\n", a, b)
	}(a, b)  //Quand la fonction s'exécute,ArrivéedeferÀ la Déclaration, Bien qu'il ne soit pas exécuté pour le moment , Mais le paramètre a été passé , Résultat à la sortie finale .

	a = 100
	b = 200
	fmt.Printf("Extérieur：a = %d, b = %d\n", a, b)
}

Copier

Résultats obtenus：

$ go run 18_defer Utilisation avec des fonctions anonymes .go

Extérieur：a = 100, b = 200
a = 10, b = 20

Copier

10,Obtenir les paramètres de la ligne de commande.

package main

import (
	"fmt"
	"os"
)

func main() {
	list := os.Args
	n := len(list)
	fmt.Println("Le nombre de paramètres est：", n)
}

Copier

Fais - le.：

$ go run 19_Obtenir les paramètres de la ligne de commande.go 1 2 3
Le nombre de paramètres est： 4

Copier

Vous pouvez imprimer ces paramètres séparément ：

package main

import (
	"fmt"
	"os"
)

func main() {
	list := os.Args
	n := len(list)
	fmt.Println("Le nombre de paramètres est：", n)

	for i := 0; i < n; i++ {
		fmt.Printf("list[%d] = %s\n", i, list[i])
	}
	// Impression itérative 
	for i, data := range list {
		fmt.Printf("list[%d] = %s\n", i, data)
	}
}

Copier

Résultats des opérations：

$ go build 19_Obtenir les paramètres de la ligne de commande.go

$ ./19_Obtenir les paramètres de la ligne de commande.exe 1 2 3

Le nombre de paramètres est： 4
list[0] = C:\Users\Administrator\Desktop\gocode\src\day2\19_Obtenir les paramètres de la ligne de commande.exe
list[1] = 1
list[2] = 2
list[3] = 3
list[0] = C:\Users\Administrator\Desktop\gocode\src\day2\19_Obtenir les paramètres de la ligne de commande.exe
list[1] = 1
list[2] = 2
list[3] = 3

Copier

11,Champ d'application.

1,Variables locales.

package main

import "fmt"

func test() {
	a := 10
	fmt.Println("a =", a)
}

/*
Champ d'application： Est l'étendue de l'action de la variable .
Défini dans{} Les variables à l'intérieur sont des variables locales , En même temps, {} Ça marche. .
 Exécuter la phrase pour définir la variable , Pour commencer à allouer de l'espace aux variables , Libération automatique après avoir quitté la portée 
*/

func main() {
	fmt.Println("a =", a)

	{
		i := 10
		fmt.Println("i = ", i)
	}
	fmt.Println("i = ", i)
	if b := 3; b == 3 {
		fmt.Println("b = ", b)
	}
	fmt.Println("b = ", b)
}

Copier

2,Variables globales.

package main

import "fmt"

// Une variable globale est une quantité définie en dehors d'une fonction 
// Les variables globales peuvent être utilisées n'importe où 

var a int

func main() {
	a = 10
	fmt.Println("a =", a)
	test()
}

func test() {
	fmt.Println("test a =", a)
}

Copier

3, Variable du même nom dans différents champs d'application .

package main

import "fmt"

var a byte //Variables globales
//1,Champ d'application différent, Autoriser la définition de variables du même nom 
//2, Principes d'utilisation des variables ,Principe de proximité.

func main() {
	var a int //Variables locales
	fmt.Printf("1: %T\n", a)

	{
		var a float64
		fmt.Printf("2: %T\n", a)
	}
	test()
}

func test() {
	fmt.Printf("3: %T\n", a)
}

Copier

12,Paramètres variables

//Paramètres variables
func add(a...int) int {	//0 Paramètres variables ou plus 

}

func add(a int, arg...int) int { //1 Paramètres variables ou plus 

}

func add(a, b int, arg...int) int { //2 Paramètres variables ou plus 

}
//Attention!：Parmi euxargC'est unslice,Peut passerarg[index] Pour obtenir les paramètres correspondants ,Adoptionlen(arg) Pour déterminer le nombre de paramètres 

Copier

Application de paramètres variables ：

package main

import "fmt"

// Paramètres variables de la fonction

func f(a ...interface{}) {
	// a C'est une tranche
	fmt.Printf("type:%T  value:%#v\n", a, a)
}
func main() {
	var s = []interface{}{1, 3, 5, 7, 9}
	f(s)    // Montre - moi.s Cette tranche est considérée comme un tout ,Comme argument de fonctiona Le premier élément de cette tranche 
	f(s...) //Montre - moi.s Les données de cette tranche s'étendent , Un par un comme argument de fonction a Les éléments de cette tranche 
}

Copier

Sortie du code ci - dessus :

type:[]interface {}  value:[]interface {}{[]interface {}{1, 3, 5, 7, 9}}
type:[]interface {}  value:[]interface {}{1, 3, 5, 7, 9}

Copier