Métodos en Golang

Vaya a los métodos de soporte de idiomas. Los métodos Go son similares a la función Go con una diferencia, es decir, el método contiene un argumento de receptor. Con la ayuda del argumento del receptor, el método puede acceder a las propiedades del receptor. Aquí, el receptor puede ser de tipo estructura o no estructura. Cuando crea un método en su código, el receptor y el tipo de receptor deben estar presentes en el mismo paquete. Y no puede crear un método en el que el tipo de receptor ya esté definido en otro paquete, incluido el tipo incorporado como int, string, etc. Si intenta hacerlo, el compilador dará un error.

Sintaxis: 

func(reciver_name Type) method_name(parameter_list)(return_type){
// Code
}

Aquí, se puede acceder al receptor dentro del método.

Método con receptor de tipo de estructura

En el lenguaje Go, puede definir un método cuyo receptor sea de tipo estructura. Se puede acceder a este receptor dentro del método como se muestra en el siguiente ejemplo:

Ejemplo:

// Go program to illustrate the
// method with struct type receiver
package main
 
import "fmt"
 
// Author structure
type author struct {
    name      string
    branch    string
    particles int
    salary    int
}
 
// Method with a receiver
// of author type
func (a author) show() {
 
    fmt.Println("Author's Name: ", a.name)
    fmt.Println("Branch Name: ", a.branch)
    fmt.Println("Published articles: ", a.particles)
    fmt.Println("Salary: ", a.salary)
}
 
// Main function
func main() {
 
    // Initializing the values
    // of the author structure
    res := author{
        name:      "Sona",
        branch:    "CSE",
        particles: 203,
        salary:    34000,
    }
 
    // Calling the method
    res.show()
}

Producción: 

Author's Name:  Sona
Branch Name:  CSE
Published articles:  203
Salary:  34000

Método con receptor de tipo no estructural

En el lenguaje Go, puede crear un método con un receptor de tipo sin estructura siempre que el tipo y las definiciones del método estén presentes en el mismo paquete. Si se presentan en diferentes paquetes como int, string, etc., el compilador dará un error porque están definidos en diferentes paquetes.

Ejemplo:

// Go program to illustrate the method
// with non-struct type receiver
package main
 
import "fmt"
 
// Type definition
type data int
 
// Defining a method with
// non-struct type receiver
func (d1 data) multiply(d2 data) data {
    return d1 * d2
}
 
/*
// if you try to run this code,
// then compiler will throw an error
func(d1 int)multiply(d2 int)int{
return d1 * d2
}
*/
 
// Main function
func main() {
    value1 := data(23)
    value2 := data(20)
    res := value1.multiply(value2)
    fmt.Println("Final result: ", res)
}

Producción: 

Final result:  460

Métodos con receptor de puntero

En el lenguaje Go, puede crear un método con un receptor de puntero . Con la ayuda de un receptor de puntero, si se realiza un cambio en el método, se reflejará en la persona que llama, lo que no es posible con los métodos del receptor de valor.

Sintaxis: 

func (p *Type) method_name(...Type) Type {
// Code
}

Ejemplo:

// Go program to illustrate pointer receiver
package main
 
import "fmt"
 
// Author structure
type author struct {
    name      string
    branch    string
    particles int
}
 
// Method with a receiver of author type
func (a *author) show(abranch string) {
    (*a).branch = abranch
}
 
// Main function
func main() {
 
    // Initializing the values
    // of the author structure
    res := author{
        name:   "Sona",
        branch: "CSE",
    }
 
    fmt.Println("Author's name: ", res.name)
    fmt.Println("Branch Name(Before): ", res.branch)
 
    // Creating a pointer
    p := &res
 
    // Calling the show method
    p.show("ECE")
    fmt.Println("Author's name: ", res.name)
    fmt.Println("Branch Name(After): ", res.branch)
}

Producción:

Author's name:  Sona
Branch Name(Before):  CSE
Author's name:  Sona
Branch Name(After):  ECE

El método puede aceptar tanto el puntero como el valor

Como sabemos que en Go, cuando una función tiene un argumento de valor, solo aceptará los valores del parámetro, y si intenta pasar un puntero a una función de valor, no lo aceptará y viceversa. Pero un método Go puede aceptar tanto el valor como el puntero, ya sea que se defina con un puntero o un receptor de valor. Como se muestra en el siguiente ejemplo:

Ejemplo:

// Go program to illustrate how the
// method can accept pointer and value
 
package main
 
import "fmt"
 
// Author structure
type author struct {
    name   string
    branch string
}
 
// Method with a pointer
// receiver of author type
func (a *author) show_1(abranch string) {
    (*a).branch = abranch
}
 
// Method with a value
// receiver of author type
func (a author) show_2() {
 
    a.name = "Gourav"
    fmt.Println("Author's name(Before) : ", a.name)
}
 
// Main function
func main() {
 
    // Initializing the values
    // of the author structure
    res := author{
        name:   "Sona",
        branch: "CSE",
    }
 
    fmt.Println("Branch Name(Before): ", res.branch)
 
    // Calling the show_1 method
    // (pointer method) with value
    res.show_1("ECE")
    fmt.Println("Branch Name(After): ", res.branch)
 
    // Calling the show_2 method
    // (value method) with a pointer
    (&res).show_2()
    fmt.Println("Author's name(After): ", res.name)
}

Producción: 

Branch Name(Before):  CSE
Branch Name(After):  ECE
Author's name(Before) :  Gourav
Author's name(After):  Sona

Diferencia entre método y función