What advantage we get using method than a regular funtion call

Question

We can pass a struct to a function as a argument than a method. Then what is the significance of method in Go? Can anyone explain with example

In simple terms I'm curious to know a case where, " A method can perform which is not possible to implement using function." or what benefit with method logic.

Sample code for method or function call using struct package main

import (
    “fmt”
)

type Person struct {
    name string
    age int
}

// Function takes struct argument
func functionCall(first Person) {
    fmt.Println(“Normal Funtion call”, first)
}

//Method call on struct type
func (second Persoan) methodCall() {
    fmt.Println(“Method Function call”, second)
}

func main() {
    p1 := Person{“satish”, 23}
    p1.name = “kumar”
    functionCall(p1)
    p1.name = “Yes”
    p1.methodCall()
}

Output:
Normal Funtion call {kumar 23}
Method Function call {Yes 23}

Thanks for your reply. However, I am not looking for difference actually. I wanted to know where advantage of using method rather than function with arguments. Anything achievable with Method that can not be possible with function. — satish kumar, Nov 01 '21 at 06:45
Methods enable Go’s interface feature. Interfaces provide polymorphism. — Charlie Tumahai, Nov 01 '21 at 07:07

score 2 · Answer 1 · 2021-11-01T07:55:37.303

As Cerise mentioned, the 'USP' of methods is the fact that they are tied to interfaces and let you write 'object-oriented' code (for sake of completeness, struct embedding also lets you write 'object-oriented' code).

Taking the classic Stringer interface as an example, your 'Person' type can implement the Stringer interface merely by implementing a String() method. See this code example: https://tour.golang.org/methods/17

Now, the reason to do it this way (instead of writing a function) is that any instance of the 'Person' type can now be passed as an argument to code that accepts Stringer as input. To take a highly simplified example, let's assume there is some function in some library which provides some very complex behaviour which you need to call. But this function accepts args of type Stringer:

func SomeComplexFunction (s Stringer) {
    //some complex code
}

If 'Person' implements String(), you can pass instances of Person to this hypothetical function

p1 := Person{“satish”, 23}
SomeComplexFunction(p1)

The complex function is obviously not aware of your Person type, but can work with it due to the fact that Person implements the Stringer interface (by implementing Stringer's methods). In some cases, you could achieve the same by passing function as arguments ('C' style function pointers)... but the code complexity can go up a bit in doing so.

To take a more 'real-world' example, let's say you had types representing different products in a store and a Shipment Processor to handle shipments. To avoid having to change your shipment code every time you add a new product, you're best off using an interface (with methods) to provide this abstraction.

type MobilePhone struct {
    //fields 
}

func (o *MobilePhone) GetWeight() float64 {
    //return the product's weight
}

type Toy struct {
    //fields
}

func (o *Toy) GetWeight() float64 {
    //return the product's weight
}

type IShippable interface {
    GetWeight() float64
    //other shipment related methods
}

ShipmentProcessort(shipment IShippable) {
    //code to process shipment
}

score 1 · Answer 2 · answered Nov 01 '21 at 07:44

1

Function — a set of instructions that perform a task. Method — a set of instructions that are associated with an object.

You can use method to convey the ownership of logic/function. It can also help if you want to implement and interface.

answered Nov 01 '21 at 07:44

Devarshi Waghela

21
3

What advantage we get using method than a regular funtion call

2 Answers2