结构体定义的一般方式如下：
type identifier struct {
field1 type1
field2 type2
...
}type T struct {a, b int} 也是合法的语法，它更适用于简单的结构体。
结构体里的字段都有 名字，像 field1、field2 等，如果字段在代码中从来也不会被用到，那么可以命名它为 _。
结构体的字段可以是任何类型，甚至是结构体本身，也可以是函数或者接口。可以声明结构体类型的一个变量，然后像下面这样给它的字段赋值：
var s T
s.a = 5
s.b = 8数组可以看作是一种结构体类型，不过它使用下标而不是具名的字段。
type test struct {
name string
age int
}
func main() {
var array [5]test
array[0] = test{name: "hh", age: 1}
fmt.Println(array[0])
fmt.Println(array)
}
{hh 1}
[{hh 1} { 0} { 0} { 0} { 0}]使用 new
使用 new 函数给一个新的结构体变量分配内存，它返回指向已分配内存的指针：var t *T = new(T)，如果需要可以把这条语句放在不同的行（比如定义是包范围的，但是分配却没有必要在开始就做）。
var t *T
t = new(T)写这条语句的惯用方法是：t := new(T)，变量 t 是一个指向 T 的指针，此时结构体字段的值是它们所属类型的零值。
声明 var t T 也会给 t 分配内存，并零值化内存，但是这个时候 t 是类型 T。在这两种方式中，t 通常被称做类型 T 的一个实例（instance）或对象（object）。
package main
import "fmt"
type struct1 struct {
i1 int
f1 float32
str string
}
func main() {
ms := new(struct1)
ms.i1 = 10
ms.f1 = 15.5
ms.str= "Chris"
fmt.Printf("The int is: %d\n", ms.i1)
fmt.Printf("The float is: %f\n", ms.f1)
fmt.Printf("The string is: %s\n", ms.str)
fmt.Println(ms)
}输出：
The int is: 10
The float is: 15.500000
The string is: Chris
&{10 15.5 Chris}使用 fmt.Println 打印一个结构体的默认输出可以很好的显示它的内容，类似使用 %v 选项。
就像在面向对象语言所作的那样，可以使用点号符给字段赋值：structname.fieldname = value。
同样的，使用点号符可以获取结构体字段的值：structname.fieldname。
在 Go 语言中这叫 选择器（selector）。无论变量是一个结构体类型还是一个结构体类型指针，都使用同样的选择器符（selector-notation） 来引用结构体的字段：
type myStruct struct { i int }
var v myStruct // v是结构体类型变量
var p *myStruct // p是指向一个结构体类型变量的指针
v.i
p.i初始化一个结构体实例（一个结构体字面量：struct-literal）的更简短和惯用的方式如下：
ms := &struct1{10, 15.5, "Chris"}
// 此时ms的类型是 *struct1或者：
var ms struct1
ms = struct1{10, 15.5, "Chris"}混合字面量语法（composite literal syntax）&struct1{a, b, c} 是一种简写，底层仍然会调用 new ()，这里值的顺序必须按照字段顺序来写。在下面的例子中能看到可以通过在值的前面放上字段名来初始化字段的方式。表达式 new(Type) 和 &Type{} 是等价的。
时间间隔（开始和结束时间以秒为单位）是使用结构体的一个典型例子：
type Interval struct {
start int
end int
}初始化方式：
intr := Interval{0, 3} (A)
intr := Interval{end:5, start:1} (B)
intr := Interval{end:5} (C)在（A）中，值必须以字段在结构体定义时的顺序给出，& 不是必须的。（B）显示了另一种方式，字段名加一个冒号放在值的前面，这种情况下值的顺序不必一致，并且某些字段还可以被忽略掉，就像（C）中那样。
结构体类型和字段的命名遵循可见性规则，一个导出的结构体类型中有些字段是导出的，另一些不是，这是可能的。
下图说明了结构体类型实例和一个指向它的指针的内存布局：
type Point struct { x, y int }使用 new 初始化：
作为结构体字面量初始化：
类型 struct1 在定义它的包 pack1 中必须是唯一的，它的完全类型名是：pack1.struct1。
下面的例子显示了一个结构体 Person，一个方法，方法有一个类型为 *Person 的参数（因此对象本身是可以被改变的），以及三种调用这个方法的不同方式：
package main
import (
"fmt"
"strings"
)
type Person struct {
firstName string
lastName string
}
func upPerson(p *Person) {
p.firstName = strings.ToUpper(p.firstName)
p.lastName = strings.ToUpper(p.lastName)
}
func main() {
// 1-struct as a value type:
var pers1 Person
pers1.firstName = "Chris"
pers1.lastName = "Woodward"
upPerson(&pers1)
fmt.Printf("The name of the person is %s %s\n", pers1.firstName, pers1.lastName)
// 2—struct as a pointer:
pers2 := new(Person)
pers2.firstName = "Chris"
pers2.lastName = "Woodward"
(*pers2).lastName = "Woodward" // 这是合法的
upPerson(pers2)
fmt.Printf("The name of the person is %s %s\n", pers2.firstName, pers2.lastName)
// 3—struct as a literal:
pers3 := &Person{"Chris","Woodward"}
upPerson(pers3)
fmt.Printf("The name of the person is %s %s\n", pers3.firstName, pers3.lastName)
}输出：
The name of the person is CHRIS WOODWARD
The name of the person is CHRIS WOODWARD
The name of the person is CHRIS WOODWARD在上面例子的第二种情况中，可以直接通过指针，像 pers2.lastName="Woodward" 这样给结构体字段赋值，没有像 C++ 中那样需要使用 -> 操作符，Go 会自动做这样的转换。
注意也可以通过解指针的方式来设置值：(*pers2).lastName = "Woodward"