Valeur de la méthode de la fonction Golang et méthode de mise en œuvre de l'expression de la méthode

Valeurs de méthode et méthodes d'implémentation d'expression de méthode des fonctions Golang

Dans Golang, les fonctions sont des citoyens de première classe. Cela signifie que les fonctions sont syntaxiquement similaires aux autres valeurs et peuvent être stockées dans des variables, transmises aux fonctions et renvoyées par les fonctions. En plus de cela, Golang fournit également des méthodes pour étendre le comportement des types. Une méthode est une fonction spéciale qui existe sur un type et peut accéder aux champs et méthodes du type. Dans cet article, nous discuterons des méthodes d'implémentation de la valeur de méthode et de l'expression de méthode des fonctions Golang.

Valeurs de méthode et expressions de méthode

Tout d'abord, examinons les valeurs de méthode et les expressions de méthode. La valeur de la méthode est une valeur de fonction à laquelle est lié un récepteur. Elle est similaire à une fonction normale, mais elle contient également un récepteur, qui est spécifié lors de la définition de la fonction. Par conséquent, la valeur de la méthode peut être transmise et stockée comme une fonction normale, mais elle conserve également une référence au récepteur.

Ce qui suit est un exemple :

type Rect struct {
  width, height float64
}

func (r Rect) Area() float64 {
  return r.width * r.height
}

func main() {
  r := Rect{3, 4}

  // 获取 Rect 类型的 Area 方法值
  f := r.Area
  // 调用方法值
  fmt.Println(f())
}

Dans l'exemple ci-dessus, nous définissons un type nommé Rect et définissons un type nommé Area pour sa méthode. Ce récepteur de méthode Area est de type Rect, il ne peut donc être appelé qu'à partir d'instances de Rect. Dans la fonction main, nous créons une instance Rect r et obtenons sa valeur de méthode Area, la stockons dans un variable nommée f. Puisque f est une valeur de fonction, nous pouvons l'appeler comme une fonction normale, mais elle conserve également une référence à l'instance r, elle est donc automatiquement transmise lors de l'appel de Enter < code>r. Rect 的类型，并为它定义了一个名为 Area 的方法。这个 Area 方法接收者是 Rect 类型，因此它只能被 Rect 的实例调用。在 main 函数中，我们创建了一个 Rect 实例 r，并获取了它的 Area 方法值，将其存储在名为 f 的变量中。由于 f 是一个函数值，我们可以像调用普通函数一样调用它，但它还保留了对 r 实例的引用，因此它会在调用时自动传入 r。

类似方法值，方法表达式是绑定了接收者的函数表达式。它与方法值类似，但是它不依赖于任何实例，可以在没有实例时被调用。方法表达式使用类型名作为接收者。

下面是使用方法表达式的例子：

type Rect struct {
  width, height float64
}

func (r Rect) Area() float64 {
  return r.width * r.height
}

func main() {
  // 获取 Rect 类型的 Area 方法表达式
  f := Rect.Area
  fmt.Println(f(Rect{3, 4}))
}

在上面的例子中，我们使用 Rect.Area 获取 Rect 类型的 Area 方法表达式。由于方法表达式不依赖于任何实例，因此我们可以直接传递一个 Rect 实例，调用时会自动将它作为接收者。

实现方法的方式

在 Golang 中，有两种方式来实现方法：值接收者和指针接收者。值接收者是将值作为接收者传递给方法，指针接收者是将指针作为接收者传递给方法。值接收者会对方法中的字段进行值拷贝，而指针接收者会将指针作为接收者传递，以便在方法中直接修改字段的值。

下面是采用值接收者的例子：

type Rect struct {
  width, height float64
}

func (r Rect) Scale(factor float64) {
  r.width *= factor
  r.height *= factor
}

func main() {
  r := Rect{3, 4}
  r.Scale(2)
  fmt.Println(r.width, r.height)
}

在上面的例子中，我们定义了名为 Scale 的值接收者方法。它接收一个浮点数 factor，并将 Rect 的宽度和高度乘以它。在调用方法时，由于使用了值接收者，r 实例的值被拷贝到方法中，并对它进行修改。因此，即使在方法中修改了宽度和高度，我们在函数的外部仍然可以访问原始值。

下面是采用指针接收者的例子：

type Rect struct {
  width, height float64
}

func (r *Rect) Scale(factor float64) {
  r.width *= factor
  r.height *= factor
}

func main() {
  r := &Rect{3, 4}
  r.Scale(2)
  fmt.Println(r.width, r.height)
}

在上面的例子中，我们定义了名为 Scale 的指针接收者方法。它接收一个浮点数 factor，并将 Rect 的宽度和高度乘以它。在调用方法时，由于使用了指针接收者，r

Semblables aux valeurs de méthode, les expressions de méthode sont des expressions de fonction liées aux récepteurs. Elle est similaire à une valeur de méthode, mais elle ne dépend d’aucune instance et peut être appelée lorsqu’il n’y a pas d’instance. Les expressions de méthode utilisent des noms de types comme récepteurs.

Ce qui suit est un exemple d'utilisation d'une expression de méthode :

rrreee

Dans l'exemple ci-dessus, nous utilisons Rect.Area pour obtenir la Area de type Rect > Expression de méthode. Puisque l'expression de la méthode ne dépend d'aucune instance, nous pouvons passer directement une instance <code>Rect et elle sera automatiquement utilisée comme récepteur lors de son appel. 🎜🎜Modes d'implémentation des méthodes🎜🎜Dans Golang, il existe deux manières d'implémenter les méthodes : les récepteurs de valeurs et les récepteurs de pointeurs. Un récepteur de valeur transmet une valeur en tant que récepteur à une méthode, et un récepteur de pointeur transmet un pointeur en tant que récepteur à une méthode. Le récepteur de valeur copiera la valeur du champ dans la méthode, tandis que le récepteur du pointeur passera le pointeur en tant que récepteur afin que la valeur du champ puisse être modifiée directement dans la méthode. 🎜🎜Voici un exemple d'utilisation d'un récepteur de valeur : 🎜rrreee🎜Dans l'exemple ci-dessus, nous avons défini une méthode de récepteur de valeur nommée Scale. Il reçoit un nombre à virgule flottante factor et multiplie la largeur et la hauteur du Rect par celui-ci. Lorsqu'une méthode est appelée, grâce à l'utilisation d'un récepteur de valeur, la valeur de l'instance r est copiée dans la méthode et modifiée. Ainsi même si la largeur et la hauteur sont modifiées au sein de la méthode, on a toujours accès aux valeurs d'origine en dehors de la fonction. 🎜🎜Ce qui suit est un exemple d'utilisation d'un récepteur de pointeur : 🎜rrreee🎜Dans l'exemple ci-dessus, nous avons défini une méthode de récepteur de pointeur nommée Scale. Il reçoit un nombre à virgule flottante factor et multiplie la largeur et la hauteur du Rect par celui-ci. Lorsqu'une méthode est appelée, grâce à l'utilisation de récepteurs de pointeurs, le pointeur vers l'instance r est passé dans la méthode et ses champs peuvent être modifiés directement. Par conséquent, la valeur modifiée est également accessible en dehors de la fonction. 🎜🎜Conclusion🎜🎜Les valeurs de méthode et les expressions de méthode des fonctions Golang sont très utiles. Elles peuvent grandement améliorer la lisibilité et la réutilisabilité du code. De plus, lors de la mise en œuvre d'une méthode, nous devons choisir entre utiliser un récepteur de valeur ou un récepteur de pointeur, en fonction des spécificités du code. Ce qui précède est une introduction aux valeurs de méthode et aux méthodes d'implémentation d'expression de méthode des fonctions Golang. J'espère que cela sera utile à votre travail de développement. 🎜

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!