Go: Am I creating too many values?

If I have a struct like this

type myStruct struct {
    mystring string
    myint int
}

and if I have a function that returns a new myStruct like this

func New() myStruct {
    s := myStruct{}

    s.mystring = "string"
    s.myint = 1

    return s
}

Because I first store it in the "s" variable before returning it, is my function actually making 2 myStruct values instead of one?

And if so, is it then a better practice to make sure I don't first store it in the variable?

The return statement will return a copy of the myStruct object value. If it is a small object then this is fine.

If you intend for the caller to be able to modify this object, and the struct will have methods that use a pointer as the receiver, then it makes more sense to return a pointer to your struct instead:

func New() *myStruct {
    s := myStruct{}

    s.mystring = "string"
    s.myint = 1

    return &s
}

You can see the copy happening when you compare the memory address of value vs pointer return types: http://play.golang.org/p/sj6mivYSHg

package main

import (
	"fmt"
)

type myStruct struct {
	mystring string
	myint    int
}

func NewObj() myStruct {
	s := myStruct{}
	fmt.Printf("%p\n", &s)

	return s
}

func NewPtr() *myStruct {
	s := &myStruct{}
	fmt.Printf("%p\n",s)
	return s
}

func main() {

	o := NewObj()
	fmt.Printf("%p\n",&o)

	p := NewPtr()
	fmt.Printf("%p\n",p)
}


0xf8400235a0 // obj inside NewObj()
0xf840023580 // obj returned to caller
0xf840023640 // ptr inside of NewPtr()
0xf840023640 // ptr returned to caller

I'm definitely not a Go expert (or even novice ), but as @max.haredoom mentioned, you can allocate variables in the function signature itself. In that way, you can also omit the s in the return:

package main

import "fmt"

type myStruct struct {
	mystring string
	myint    int
}

func New() (s myStruct) {
	s.mystring = "string"
	s.myint = 1

	return
}

func main() {
	r := New()
	fmt.Println(r)
}

// Outputs {string 1}

In the examples that I have come across in Effective Go, it does seem to be the most common way of doing things of this nature, but again, I am definitely not an authority on the subject (and will look for additional info on the actual performance).

I think I found the answer by using defer.

I updated the function so that there's a deferred modification to the myStruct value. This means it will happen after the return, but before it is received on the other end.

When I do this, the struct that is received by the caller does not show the updated value, so it appears as though I am indeed returning a copy.

func New() myStruct {
	s := myStruct{}

	defer func() {
		s.mystring = "new value" // defer an update to the value
	}()

	s.mystring = "string"
	s.myint = 1

	return s
}

func main() {

	b := New()

	fmt.Println(b) // still shows the original value
}

http://play.golang.org/p/WWQi8HpDny