Que signifie la fonction dans le langage Go ?

Dans le langage Go, une fonction est un segment de code (bloc) organisé et réutilisable utilisé pour implémenter une seule fonction spécifique ou associée ; son objectif principal est d'améliorer la modularité de l'application et le taux de réutilisation du code ; gestion et développement modulaire. Les fonctions utilisent généralement des paramètres et des valeurs de retour pour interagir avec l'appelant ; les paramètres transmettent des données à la fonction, renvoient des valeurs et la fonction transmet les données traitées à l'appelant.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Une fonction est un segment de code organisé et réutilisable utilisé pour implémenter une fonction unique ou associée, ce qui peut améliorer la modularité de l'application et le taux de réutilisation du code.

Aperçu des fonctions

Fonction, fonction, bloc de code indépendant utilisé pour implémenter des fonctions spécifiques. L'objectif principal est la réutilisation du code (réutilisation), une meilleure gestion du code et le développement modulaire. Les fonctions utilisent généralement des paramètres et des valeurs de retour pour interagir avec l'appelant. Les paramètres transmettent des données à la fonction, renvoient une valeur et la fonction transmet les données traitées à l'appelant. Les fonctions en langage Go sont appelées citoyens de première classe. Cela signifie qu'il prend en charge les fonctions d'ordre élevé, les fonctions anonymes, les fermetures et d'autres fonctionnalités, et peut répondre à des fonctionnalités avancées telles que les interfaces.

Définition de fonction

La fonction constitue la structure logique de l'exécution du code. Dans le langage Go, les composants de base d'une fonction sont : le mot-clé func, le nom de la fonction, la liste des paramètres, la valeur de retour, le corps de la fonction et l'instruction de retour, chacun Un programme contient de nombreuses fonctions et les fonctions sont des blocs de code de base.

Syntaxe :

• Définition :

func 函数名(形参列表)(返回值类型列表) {
  函数体，通常会有return语句，返回值
}

• Appel :

函数名(实参列表)

Nom de la fonction : L'identifiant de la fonction, utilisé pour trouver la fonction, et en interne est une adresse pointant vers la fonction code. Liste de paramètres formels : composée de variables et de types. Liste de types de valeurs de retour : le type de valeur de retour de la fonction doit être spécifié. Corps de la fonction : l'instruction spécifique qui implémente la fonction. instruction return : instruction de valeur de retour

Ce qui précède est une fonction nommée et ne peut pas être définie dans d'autres fonctions.

Paramètres de fonction

sont utilisés pour transmettre des données à la fonction lors de l'appel de la fonction. Paramètres réels, paramètres réels. Paramètres donnés lors de l'appel. Fait référence à des paramètres avec des données réelles spécifiques. Paramètres formels, paramètres formels. Paramètres utilisés lors de la définition. Cela signifie que la fonction nécessite des paramètres, mais que les paramètres n'ont aucune donnée réelle lorsqu'ils sont définis. Lors de l'appel, le processus d'attribution de valeurs aux variables de paramètres formelles à l'aide de paramètres réels se produit, appelé passage de paramètres. Lors de l'exécution de la fonction, les paramètres formels ont des données spécifiques, et les paramètres formels sont équivalents aux variables déclarées au sein de la fonction.

Le transfert de paramètres est divisé en deux méthodes : le transfert de valeur et le transfert d'adresse. Lorsque l'adresse est transmise, le paramètre formel doit être défini comme un type de pointeur et le paramètre d'adresse doit être obtenu lors de l'appel. Exemple de code :

func funcTest(p1 int, p2 *int) {
  p1++
  *p2++
  fmt.Println(p1, *p2)
}
func main() {
  var (
    a1 = 42
    a2 = 42
  )
  funcTest(a1, &a2)
  // 参数赋值过程
  fmt.Println(a1, a2)
}

Ce qui précède affichera

43 43
42 43

Transmission de la valeur, la fonction obtiendra une copie des paramètres réels. Lorsque l'adresse est passée, la fonction obtiendra l'adresse réelle du paramètre, de sorte que la modification de la variable via l'adresse dans la fonction affectera également les paramètres réels.

Go prend en charge le repos...un nombre indéfini de paramètres. Lors de la définition, placez le nombre indéfini de paramètres formels à la fin de la liste des paramètres formels et utilisez ...Type :

定义：
func funcTest(op string, nums ...int) {
  fmt.Println(nums) // [4, 1, 55, 12], slice切片型数据
}
调用
funcTest("someOp", 4, 1, 55, 12)

Les paramètres reçus sont de type slice. .

Valeur de retour de la fonction

L'instruction return est utilisée pour générer une valeur de retour. Le type de valeur de retour doit être déterminé lorsque la fonction est définie et les retours à valeurs multiples sont pris en charge. Syntaxe de démonstration :

func funcTest() (int, string) {
  return 42, "Hank"
}

Vous pouvez déclarer la variable renvoyée lors de la définition. Cette méthode s'appelle nommée return, et la démonstration est :

func funcTest() (num int, title string) {
  num = 42
  title = "Hank"
  return
}

Il n'est pas nécessaire de renvoyer des données, il suffit de les renvoyer directement !

Variables de fonction

La fonction peut être considérée comme un type de pointeur spécial, qui peut être enregistré dans des variables comme les autres types. La fonction est accessible via les identifiants de fonction et les variables. La démonstration est la suivante :

func funcTest() {
  fmt.Println("func() type")
}
func main() {
  fmt.Printf("%T, (%v)\n", funcTest, funcTest)
  fn := funcTest
  fmt.Printf("%T, (%v)\n", fn, fn)
  funcTest()
  fn()
}

Résultat de l'exécution :

func(), (0x48fe20)
func(), (0x48fe20)
func() type
func() type

On voit que l'identifiant de fonction est un pointeur vers la fonction. Peut être affecté à d'autres variables.

Paramètres de fonction

Les fonctions peuvent également être utilisées comme paramètres d'autres fonctions. La démonstration est la suivante :

func funcSuccess() {
}
func funcAsync(handle func()) {
  // 调用函数参数
  handle()
}
// 传递函数到其他函数
funcAsync(success)

Ce type de syntaxe de fonction de rappel est très utile lorsqu'il s'agit de logique asynchrone.

Fonctions anonymes

Vous pouvez définir des fonctions anonymes. Les fonctions anonymes peuvent être enregistrées dans des variables, passées en arguments ou appelées immédiatement. Si une fonction est utilisée temporairement, une fonction anonyme est un bon choix. Exemple de syntaxe :

赋值给变量
fn := func() {
}
fn()

// 作为参数
someFunc(func() {
  })

// 立即调用
func() {
  }()

Closure

由于匿名函数可以定义在其他函数内，同时变量的作用域为层叠的，也就是匿名函数可以会访问其所在的外层函数内的局部变量。当外层函数运行结束后，匿名函数会与其使用的外部函数的局部变量形成闭包。示例代码：

var fn func()
func outer() {
  v := 42
  fn = func() {
    v ++
    fmt.Print(v)
  }
}

outer()
fn() // 43

此例中，fn 对应的匿名函数与 outer() 的局部变量 v，就形成了闭包。

函数调用示意图

var v = "global"
func funcTest(v) {
  v = "funcTest"
  fmt.Println(v)
}
func main() {
  v := "main"
  funcTest(v)
}

代码编译期间，会将函数代码存放在内存代码区。 函数被调用时，在运行期间会在函数运行栈区开辟函数栈，内部由局部变量标识符列表（就是局部变量），上层标识符列表引用等信息。直到运行结束，此空间才会被出栈，释放。 函数内部调用了新函数，新函数的执行空间入栈，要等到新函数执行空间出栈，调用他的函数才会被出栈。 以上代码的运行逻辑图如下：

递归调用

函数内部调用函数本身。称之为递归调用。示例代码：

func funcTest() {
  fmt.Println("run")
  funcTest()
}

定义实现递归调用函数时，通常需要定义一个出口。用来确定何时不再进行递归调用了。一旦满足条件，则调用停止。例如：

func funcTest(v) {
  fmt.Println(v, "run")
  v ++
  if v <= 10 {
    funcTest()
  }
}

典型的应用有，树状菜单的处理，遍历目录，快速排序等。 递归调用的优势是编码简单，与描述的业务逻辑保持一致。

【相关推荐：Go视频教程】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!