Quelle est la différence entre les fonctions et les méthodes en langage Go

La différence entre les fonctions et les méthodes en langage Go : pour les fonctions ordinaires, lorsque le récepteur est un type valeur, les données de type pointeur ne peuvent pas être transmises directement ; pour les méthodes, lorsque le récepteur est un type valeur, le type pointeur peut être transmis ; être utilisé directement comme méthode d'appel de variable.

L'environnement d'exploitation de cet article : système Windows10, Go 1.11.2, ordinateur Thinkpad T480.

Explication officielle de la différence entre fonctions et méthodes : Une méthode est une fonction qui contient un récepteur. Le récepteur peut être une valeur d’un type nommé ou structuré ou un pointeur. Toutes les méthodes d'un type donné appartiennent à l'ensemble de méthodes de ce type.

Différences :

1. Pour les fonctions ordinaires : lorsque le récepteur (paramètre de fonction) est un type valeur, les données de type pointeur ne peuvent pas être transmises directement, et vice versa.

func function_name([parameter list]) [return_types] {
   函数体
}

2. Pour les méthodes (telles que les méthodes struct) : Lorsque le récepteur est de type valeur, vous pouvez appeler directement la méthode avec une variable de type pointeur, et vice versa

func (variable_name variable_data_type) function_name() [return_type]{
   /* 函数体*/
   }

Vous pouvez voir méthodes et fonctions La différence est que la méthode après le mot-clé func est le récepteur au lieu du nom de la fonction. Le récepteur peut être un type défini par vous-même. Ce type peut être une structure, une interface ou même nous pouvons redéfinir les types de données de base.

Fonctions Go

Les fonctions sont des blocs de code de base qui exécutent une tâche.

Le langage Go a au moins une fonction main().

Vous pouvez diviser différentes fonctions en fonctions Logiquement, chaque fonction effectue une tâche spécifiée.

La déclaration de fonction indique au compilateur le nom, le type de retour et les paramètres de la fonction.

Les fonctions Go peuvent renvoyer plusieurs valeurs.

La bibliothèque standard du langage Go fournit une variété de fonctions intégrées qui peuvent être utilisées. Par exemple, la fonction len() peut accepter des arguments de différents types et renvoyer la longueur de ce type. Si nous transmettons une chaîne, la longueur de la chaîne est renvoyée. Si nous transmettons un tableau, le nombre d'éléments contenus dans le tableau est renvoyé.

1. Passage de valeur : le passage de valeur signifie copier une copie des paramètres réels et les transmettre à la fonction lors de l'appel d'une fonction, de sorte que si les paramètres sont modifiés dans la fonction, les paramètres réels ne seront pas affectés. .

2. Passage par référence : Passer par référence signifie transmettre l'adresse des paramètres réels à la fonction lors de l'appel de la fonction. Ensuite, la modification des paramètres dans la fonction affectera les paramètres réels.

Méthodes Go

Il existe à la fois des fonctions et des méthodes dans le langage Go. Une méthode est une fonction qui contient un récepteur, qui peut être une valeur d'un type nommé ou structuré ou un pointeur. Toutes les méthodes d'un type donné appartiennent à l'ensemble de méthodes de ce type.

Ce qui suit définit un type de structure et une méthode de ce type :

package mainimport (   "fmt"  )/* 定义结构体 */type Circle struct {
  radius float64
}func main() {  var c1 Circle
  c1.radius = 10.00
  fmt.Println("Area of Circle(c1) = ", c1.getArea())
}//该 method 属于 Circle 类型对象中的方法func (c Circle) getArea() float64 {  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

(Partage de vidéos d'apprentissage : Introduction à la programmation)

Ci-dessus Le résultat de l'exécution du code est :

Area of Circle(c1) =  314

Exemple

 package structTest  
      
    //普通函数与方法的区别（在接收者分别为值类型和指针类型的时候）  
    //Date：2014-4-3 10:00:07  
      
    import (  
        "fmt"  
    )  
      
    func StructTest06Base() {  
        structTest0601()  
        structTest0602()  
    }  
      
    //1.普通函数  
    //接收值类型参数的函数  
    func valueIntTest(a int) int {  
        return a + 10  
    }  
      
    //接收指针类型参数的函数  
    func pointerIntTest(a *int) int {  
        return *a + 10  
    }  
      
    func structTest0601() {  
        a := 2  
        fmt.Println("valueIntTest:", valueIntTest(a))  
        //函数的参数为值类型，则不能直接将指针作为参数传递  
        //fmt.Println("valueIntTest:", valueIntTest(&a))  
        //compile error: cannot use &a (type *int) as type int in function argument  
      
        b := 5  
        fmt.Println("pointerIntTest:", pointerIntTest(&b))  
        //同样，当函数的参数为指针类型时，也不能直接将值类型作为参数传递  
        //fmt.Println("pointerIntTest:", pointerIntTest(b))  
        //compile error:cannot use b (type int) as type *int in function argument  
    }  
      
    //2.方法  
    type PersonD struct {  
        id   int  
        name string  
    }  
      
    //接收者为值类型  
    func (p PersonD) valueShowName() {  
        fmt.Println(p.name)  
    }  
      
    //接收者为指针类型  
    func (p *PersonD) pointShowName() {  
        fmt.Println(p.name)  
    }  
      
    func structTest0602() {  
        //值类型调用方法  
        personValue := PersonD{101, "Will Smith"}  
        personValue.valueShowName()  
        personValue.pointShowName()  
      
        //指针类型调用方法  
        personPointer := &PersonD{102, "Paul Tony"}  
        personPointer.valueShowName()  
        personPointer.pointShowName()  
      
        //与普通函数不同，接收者为指针类型和值类型的方法，指针类型和值类型的变量均可相互调用  
    }

Recommandations associées : tutoriel Golang

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!