Implications of defining a struct inside a function vs outside?

Are there any implications (GC churn, performance, or otherwise) to defining a struct inside a function vs. having it defined outside? For example:

type Outside struct {
  Foo string `json:"foo"`
}

func SomeFunc(b []byte) error {
  outside := Outside{}

  if err := json.NewDecoder(b).Decode(&outside); err != nil {
	return err
  }

  ...
}

vs.

func SomeFunc(b []byte) error {

  type inside struct {
    Foo string `json:"foo"`
  }

  if err := json.NewDecoder(b).Decode(&inside); err != nil {
	return err
  }

  ...
}

Would there be any situation where one is preferred over the other?

To me the main drawback for a type defined in a function is that you cannot define methods on that type.

See this example https://play.golang.org/p/cgH01cRwDv6:

package main

import (
	"fmt"
)

func main() {
	type MyType struct {
		Name string
	}

	// You cannot define a method on your type
	// defined in a function, can you?

	func (m MyType) String() string {
	  return m.Name
	}

	m := MyType{Name: "Hello, World!"}
	fmt.Println(m)
}

The above example will fail with the error prog.go:15:27: expected ';', found 'IDENT' string (and 1 more errors).

There is no performance difference – it's only a difference of scope (i.e., where the type definition can be seen). If you only need the type within a single function, it's fine to define it there.

As others have noted, if you define a type at the package level (i.e., outside of a function) with a name beginning with a capital letter, it will be exported (i.e., visible outside the package). If the name doesn't begin with a capital letter, it will only be visible within the package.

My understanding is the difference is just in accessibility.

• A struct defined starting with an upper case letter will be exportable, meaning it can be accessed from other packages.
• A struct defined starting with a lower case letter can be accessed from anything within the same package but not externally.
• A struct defined in a function inline can only be accessed/initialized by that function.

For me I once defined a struct inside a function for marshalling JSON byte array ([]byte) into the struct instance, and extract a message from the instance.

Obviously it is not required to define the struct. I could have extracted the message by marshalling the JSON byte array into interface{} and then cast recursively to get the required message.

By defining the struct, extraction of the message becomes very easy

    var errDetail struct {
		Message string `json:"message"`
		Success bool   `json:"success"`
	}
	
    json.Unmarshal(*bytes, &errDetail)
	
	if errDetail.Message == "" {
		fmt.Println("error message is not present")
		return nil
	}
	return errDetail.Message


</details>



# 答案5
**得分**: 1

作用域是不同的，你可以在Golang规范中查看[这里][1]：

最相关的部分是：

> Go使用块进行词法作用域：
>
> 在顶层（任何函数之外）声明的常量、类型、变量或函数（但不包括方法）的标识符的作用域是包块。
>
> 在函数内部声明的类型标识符的作用域从TypeSpec中的标识符开始，到最内层包含块的结束为止。

如果你使用`go tool compile -S -N hello.go`来检查生成的汇编代码，你会发现在包级别定义的类型名称和在函数内部定义的类型名称是不同的。

**包级别**

```golang
package main

import (
	"fmt"
)

type Point struct {
	X, Y int
}

func main() {
	fmt.Printf("%v\n", Point{X: 1, Y: 2})
}

然后尝试编译并找到这一行：type."".Point SRODATA size=144。

函数内部

package main

import (
	"fmt"
)


func main() {
	type Point struct {
		X, Y int
	}
	fmt.Printf("%v\n", Point{X: 1, Y: 2})
}

然后尝试找到这一行：type.*"".Point·1 SRODATA size=56

这意味着它们在编译后得到了不同的名称。

package main

import (
	"fmt"
)

type Point struct {
	X, Y int
}

func main() {
	fmt.Printf("%v\n", Point{X: 1, Y: 2})
}

package main

import (
	"fmt"
)


func main() {
	type Point struct {
		X, Y int
	}
	fmt.Printf("%v\n", Point{X: 1, Y: 2})
}

答案6

得分: 1

如其他人所提到的，这主要是为了限制变量的作用域。如果你要在函数内部使用一个结构体，你也可以使用匿名结构体。

package main

import (
	"fmt"
)

func main() {

	m := struct {
		greeting string
		name     string
	}{
		greeting: "hello",
		name:     "world",
	}

	fmt.Printf("%v %v\n", m.greeting, m.name)
}

如果你只打算在函数内部使用该结构体，你可以定义结构体的字段并立即给它们赋值。

package main

import (
	"fmt"
)

func main() {

	m := struct {
		greeting string
		name     string
	}{
		greeting: "hello",
		name:     "world",
	}

	fmt.Printf("%v %v\n", m.greeting, m.name)
}

答案7

得分: 0

对于Konrad Kleine的问题，你仍然可以通过一些变通方法来解决，就像这样：https://play.golang.org/p/50yv66LUNRt

package main

import (
	"fmt"
)

func main() {
	type MyType struct {
		Name   string
		String func() string
	}
	InitMyType := func(m *MyType) {
		m.String = func() string {
			return m.Name
		}
		return
	}

	m := MyType{Name: "Hello, World!"}
	initMyType(&m)

	fmt.Println(m.String())
}

我同意，区别只是可访问性。

但这仍然非常有用，特别是当你只需要一个临时结构体，或者在进行单元测试时，一个包中有许多类似的结构体，你不需要一个个为它们命名。

package main

import (
	"fmt"
)

func main() {
	type MyType struct {
		Name string
		String func() string
	}
	InitMyType := func(m *MyType) {
		m.String = func() string {
	 		return m.Name
		}
		return 
	}
	
	m := MyType{Name: "Hello, World!"}
	initMyType(&m)
	
	fmt.Println(m.String())
}