Change value of pointered argument inside a function

I'm stuck on something that seems/should be easy in Go.

I wrote a small go playground to explain my problem more easily => https://play.golang.org/p/Sm0SzrvEZS_o

    package main

    import (
	    "github.com/sirupsen/logrus"
    )

    type toto struct {
    	name string
    }

    func transform (data ...interface{}) {
    	logrus.Info("data before ", data)
    	
    	data[0] = "tutu"
    	
    	logrus.Info("data after ", data)
    }

    func main() {
    	var titi toto
	
    	logrus.Info("titi before ", titi) // -> empty
	
    	transform(&titi)
	
    	logrus.Info("titi after ", titi) // -> should have a name but don't
    }

The goal is to pass a struct to a function, modifying in it and continue to use it in the caller function. Sadly, the argument is modified inside the child function but don't move into the caller.

I'm a beginner in this language, maybe I just missed something somewhere... Many thanks in advance for your help

This seems to do it:

package main

type toto struct { name string }

func transform (data ...interface{}) {
   t := data[0].(*toto)
   t.name = "tutu"
}

func main() {
   var titi toto
   transform(&titi)
   println(titi.name == "tutu")
}

Sounds like you want a pointer.

In your example you use an array of interface{}, is there a particular reason for this? In general you should be explicit with your types in Go, especially since you're dealing with a simple struct.

package main

import (
	"log"
)

type toto struct {
	Name string
}

// to help with printing
func (t *toto) String() string {
	return t.Name
}

// transform takes an array of pointers to the toto struct
func transform(totos ...*toto) {
	log.Printf("totos before: %v", totos)

	// unsafe array access!
	totos[0].Name = "tutu"

	log.Printf("totos after: %v", totos)
}

func main() {
	// variables in Go are usually defined like this
	titi := toto{}

	transform(&titi)
}

In Go, the variable that's passed as a parameter in a function is actually a copy of the variable, not the actual variable itself. If you want to modify the variable that's passed, you need to pass it in as a pointer.

Personally, whenever I create a function that accepts a struct, I set the function to accept a pointer to an instance of that struct. This has the benefits of being more memory efficient (since my program doesn't have to create copies of the variable every time the function is called) and it allows me to modify the instance of the struct that I pass.

This is how I would do it:

package main

import (
	"github.com/sirupsen/logrus"
)

type toto struct {
	name string
}

func transform (t *toto) {
	logrus.Info("t before: ", t)
	
    // since t is a pointer to a toto struct, 
    // I can directly assign "tutu" to the "name" field 
    // using the "dot" operator 
	t.name = "tutu"
	
	logrus.Info("t after: ", t)
}

func main() {
    // init a pointer to a toto instance
	titi := &toto{}
	
	logrus.Info("titi before: ", titi) // -> empty
	
    // this works because transform() accepts a pointer
    // to a toto struct and and titi is a pointer to a toto instance
	transform(titi)
	
	logrus.Info("titi after (as a pointer): ", titi) // -> not empty
	logrus.Info("titi after (as a value): ", *titi) // -> also not empty
}