Go Structs

Internal

• The Type System

Overview

A struct is a user-defined type that contains named fields (and possibly other type names, see embedded types below). The fields usually represent a has-a relationship. structs can also have methods associated with them.

• Are all users can define (in terms of types) structs, or there are other user-defined types?

Definition

The structs can be declare at package level or inside a function. The struct type definition is introduced by the type keyword, to indicated that this is a user-defined type, followed by the type name and the keyword struct. Each field has a name and a type.

type myStruct struct {
    i int
    s string
}

Fields with the same types can be collapsed:

type myStruct struct {
    ...
    i, j, k int
   ...
}

Initialization

Long Variable Declaration

var ms myStruct

If no explicit initialization follows, all the struct's fields are initialized with their zero value.

Short Variable Declaration

Literal

Struct literal initialization:

ms := myStruct{i: 5, s: "something"}

There is a shorter struct literal where the name of the fields are omitted, provided that the order is maintained:

ms := myStruct{5, "something"}

new()

new() initialization:

msPtr := new(myStruct)

Note new() returns a pointer to the structure and not the structure itself.

Fields

Fields can be access with the . operator.

Note that the . operator works with a regular struct variable as well as with a pointer to a struct: the compiler knows how to compensate for both of these cases.

ms := myStruct{1, "s"}
msPtr := new(myStruct)

// valid:
ms.i

// valid:
msPtr.i

Even if the enclosing struct type is exported by a package, not all fields are exported automatically, only those whose first character is an upper case letter. This behavior makes possible to have "private" fields in a public structure, when the structure is used outside its package.

Embedded Types

An embedded type is initialized by declaring a name of a struct inside other struct - without associating it with a field. An embedded type is sometimes referred to as anonymous field. It models an is-a relationship. Example:

type A struct {
    f1 int
}

type B struct {
    A
    f2 int
}

All methods that are associated with the embedded type also work with the embedding type. For example, if there's a:

func (a A) m1() {
    ...
}

m1() also works with B instances.