# Golang: Struct

By Xah Lee. Date: . Last updated: .

Struct is user-defined type. It defines a collection of “fields”, each field is a name and a value of a specific type.

Struct is similar to golang map, except that number of keys and key names are fixed.

Once you defined a struct type (with a given name), you can create struct of that name.

Note, `struct` is very important in golang. Because methods, and interface, are based on it.

## Define a New Struct Type

Here's how to define a struct.

```type Name struct { name1 type1 name2 type2 … } ```

here's how to create a struct you just defined:

`struct_name{val1, val2 …}`

or

`struct_name{name1:val1, name2:val2 …}`

```package main

import "fmt"

// define a struct named PP
type PP struct {
x int
y int
}

func main() {
// create a struct PP
var x PP = PP{1, 2}

// print struct with value only
fmt.Printf("%v\n", x) // {1, 2}

// print struct with field name and value
fmt.Printf("%+v\n", x) // {x:1 y:2}
}```

## Create Struct: Struct Literals

A struct literal lets you create a value of a given struct type.

For example, if you have this struct type

`type PP struct{ x, y int }`

you can create a value by

`var p1 = PP{x:3, y:4}`

or

`var p1 = PP{}`

and use `PP.x=3` etc to fill the field values later.

```package main

import "fmt"

// define a struct type
type PP struct{ x, y int }

func main() {

// create a struct of PP
var p1 = PP{x: 3, y: 4}

fmt.Printf("%#v\n", p1) // main.PP{x:3, y:4}

}```

If a key is omitted, it defaults to its zero value.

[see Zero Value]

```package main

import "fmt"

type PP struct{ x, y int }

func main() {
var p1 = PP{y: 4}
fmt.Printf("%#v\n", p1) // main.PP{x:0, y:4}
}```

Alternatively, you can omit keys and only use values.

`var p1 = PP{3, 4}`

If you omit keys, the order must be the same as the struct type is defined, and none of element must contain a key.

```package main

import "fmt"

type PP struct{ x, y int }

func main() {
var tt = PP{3, 4}
fmt.Printf("%#v\n", tt) // main.PP{x:3, y:4}
}```

## Get/Set Field Value

Struct fields are accessed using a dot.

• `struct_name.field_name` → return the value
• `struct_name.field_name` = val → set new value
```package main

import "fmt"

type PP struct {
x int
y int
}

func main() {

v := PP{3, 4}

// get a field value
fmt.Println(v.x) // 3

// set a field value
v.x = 4
fmt.Println(v.x) // 4
}```

## Print Struct

• `fmt.Printf("%v\n", struct)` → print struct value only
• `fmt.Printf("%+v\n", struct)` → print both name and value
• `fmt.Printf("%#v\n", struct)` → print in golang syntax
```package main

import "fmt"

// using print struct

func main() {

type PP struct {
x int
y int
}

var stc = PP{1, 2}
fmt.Printf("%T\n", stc)  // main.PP
fmt.Printf("%v\n", stc)  // {1 2}
fmt.Printf("%+v\n", stc) // {x:1 y:2}
fmt.Printf("%#v\n", stc) // main.PP{x:1, y:2}
}```

## Reference

The Go Programming Language Specification - The Go Programming Language#Struct_types

If you have a question, put \$5 at patreon and message me.