Differenza tra funzioni e metodi in Golang

Le parole funzione e metodo sono usate quasi in modo intercambiabile, ma ci sono sottili differenze nella loro implementazione e utilizzo quando usate in Golang.
Provenendo da Java o da qualsiasi altro background di linguaggio orientato agli oggetti, il primo istinto è quello di utilizzare struct e metodi per tutto poiché gli oggetti hanno sempre un comportamento definito dai loro metodi.

Ma è un approccio corretto in Golang dove abbiamo sia funzioni che metodi?
Capiamo prima cos'è una funzione e cos'è un metodo in Golang .

Una funzione accetta alcuni parametri come input e produce un output.
Per lo stesso input, la funzione produrrà sempre lo stesso output.
Ciò significa che non dipende dallo stato. Il tipo viene sempre passato come argomento alla funzione.

Sintassi:

Inoltre, due diverse funzioni con lo stesso nome non possono esistere nello stesso pacchetto.

package main

import "math"

type Rectangle struct {
 Width  float64
 Height float64
}

type Circle struct {
 Radius float64
}

// `Area` is a function where we're passing the `Rectangle` as an argument
func Area(r Rectangle) float64 {
 return 2 * r.Height * r.Width
}

// `Area` is a function where we're passing the `Circle` as an argument
func Area(c Circle) float64 {
 return math.Pi * c.Radius * c.Radius
}

Un metodo d'altra parte in Go è una funzione che è collegata a uno specifico argomento del ricevitore (tipo) (Esempio: struct ). Definisce il comportamento del tipo e dovrebbe utilizzare lo stato del tipo. L'output di un metodo dipende dal tipo di ricevitore. I metodi sono noti anche come funzioni del ricevitore . In questo caso, il ricevitore può essere di tipo struct o non struct .

Sintassi:

In Golang sono consentiti metodi diversi con lo stesso nome con un destinatario diverso.

package main

import (
 "fmt"
 "math"
)

type Rectangle struct {
 Width  float64
 Height float64
}

// The `Rectangle` type is the receiver of the `Area` method
func (r Rectangle) Area() float64 {
 return r.Width * r.Height
}

type Circle struct {
 Radius float64
}

// The `Circle` type is the receiver of the `Area` method
func (c Circle) Area() float64 {
 return math.Pi * c.Radius * c.Radius
}

type Triangle struct {
 Base   float64
 Height float64
}

// The `Triangle` type is the receiver of the `Area` method
func (t Triangle) Area() float64 {
 return 0.5 * t.Base * t.Height
}

func main() {
 r := Rectangle{
  Width:  10.0,
  Height: 10.0,
 }
 fmt.Printf("Area of rectangle %#v is = %g \n", r, r.Area())
 c := Circle{
  Radius: 10,
 }
 fmt.Printf("Area of Circle %#v is = %g \n", c, c.Area())
 t := Triangle{
  Base:   12,
  Height: 6,
 }
 fmt.Printf("Area of triangle %#v is = %g", t, t.Area())
}

package main

import (
 "fmt"
 "math"
)

type Vertex struct {
 X, Y float64
}

func (v Vertex) Abs() float64 {
 return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// The `Vertex` pointer type is the receiver of the `Scale` method
func (v *Vertex) Scale(f float64) {
 v.X = v.X * f
 v.Y = v.Y * f
}

func main() {
 v := Vertex{3, 4}
 v.Scale(10)
 fmt.Println(v.Abs())
}

Sebbene abbiamo esaminato alcune delle principali differenze e casi d'uso per funzioni e metodi in Go, ci sono sempre alcune eccezioni!

Alla fine, la differenza tra funzioni e metodi sta nel modo in cui viene letto il codice risultante. Se tu o il tuo team ritenete che un modo sia migliore dell'altro, allora questa è l'astrazione corretta. È importante non prendere nessuna di queste regole come scolpita nella pietra.