Skip to main content
 首页 » 编程设计

Golang Struct 示例教程

2022年07月19日118zhenyulu

Golang Struct 示例教程

结构体是包括一组属性或字段的用户定义类型。，用来组织相关数据为一个整体。结构体可以描述现实世界实体的一组属性。
如果你有面向对象编程背景，可以认为结构体是轻量级的类，支持组合但不支持继承。

1. 定义结构体类型

下面定义新的结构体：

type Person struct { 
	FirstName string 
	LastName  string 
	Age       int 
}

type关键词定义新的类型，接着是用户类型名称，后面关键字struct表明正在定义结构体。结构体的花括号内包括一组属性，每个属性有名称和类型。

注，相同类型可以合并：

type Person struct { 
	FirstName, LastName string 
	Age       int 
}

2. 声明并初始化结构体

2.1 声明结构体变量

和其他数据类型一样，可以声明struct类型变量：

// 定义 'Person' 类型变量 
var p Person // 所有属性为默认值

上面代码创建Person类型变量，变量默认值为零值。对结构体来说零值就是所有属性都保持各自类型零值。因此，字符串属性为“”，Age为0。

2.2 初始化结构体

也可以定义结构体变量时初始化：

var p = Person{"New", "Sing", 26}

注意，属性值需要按照一定顺序，且不能是部分字段值，错误如下：

var p = Person{"Rajeev"} // Compiler Error: too few values in struct initializer

2.3 命名字段初始化结构体

Go支持以键值对方式初始化结构体，是否按照顺序不重要：

var p = Person{FirstName: "Rajeev", LastName: "Singh", Age: 25}

我们可以以多行方式指定属性值增强可读性（此时必须有结尾的逗号）：

var p = Person{ 
	FirstName: "John", 
	LastName:  "Snow", 
	Age:       45, 
}

键值对方式初始化支持仅初始化部分字段，所有未初始化的字段值为零值：

var p = Person{FirstName: "Alien"} // LastName: "", Age: 0 

var p = Person{} // FirstName: "", LastName: "", Age: 0

2.4 完整示例

package main 
 
import ( 
	"fmt" 
) 
 
// Defining a struct type 
type Person struct { 
	FirstName string 
	LastName  string 
	Age       int 
} 
 
func main() { 
	// Declaring a variable of a `struct` type 
	var p Person // // All the struct fields are initialized with their zero value 
	fmt.Println(p) 
 
	// Declaring and initializing a struct using a struct literal 
	p1 := Person{"Rajeev", "Singh", 26} 
	fmt.Println("Person1: ", p1) 
 
	// Naming fields while initializing a struct 
	p2 := Person{ 
		FirstName: "John", 
		LastName:  "Snow", 
		Age:       45, 
	} 
	fmt.Println("Person2: ", p2) 
 
	// Uninitialized fields are set to their corresponding zero-value 
	p3 := Person{FirstName: "Robert"} 
	fmt.Println("Person3: ", p3) 
} 
 

# Output 
{  0} 
Person1:  {Rajeev Singh 26} 
Person2:  {John Snow 45} 
Person3:  {Robert  0}

3. 访问结构体变量及属性

本节介绍如果通过结构体变量和指针访问其属性，以及结构体变量及变量属性的可见性。

3.1 结构体变量访问属性

使用.访问结构体属性：

package main 
 
import ( 
	"fmt" 
) 
 
type Car struct { 
	Name, Model, Color string 
	WeightInKg         float64 
} 
 
func main() { 
	c := Car{ 
		Name:       "Ferrari", 
		Model:      "GTC4", 
		Color:      "Red", 
		WeightInKg: 1920, 
	} 
 
	// Accessing struct fields using the dot operator 
	fmt.Println("Car Name: ", c.Name) 
	fmt.Println("Car Color: ", c.Color) 
 
	// Assigning a new value to a struct field 
	c.Color = "Black" 
	fmt.Println("Car: ", c) 
} 

# Output 
Car Name:  Ferrari 
Car Color:  Red 
Car:  {Ferrari GTC4 Black 1920}

3.2 结构体指针访问属性

可以使用&操作符获取结构体变量指针：

package main 
 
import ( 
	"fmt" 
) 
 
type Student struct { 
	RollNumber int 
	Name       string 
} 
 
func main() { 
	// instance of student struct type 
	s := Student{11, "Jack"} 
 
	// Pointer to the student struct 
	ps := &s 
	fmt.Println(ps) 
 
	// Accessing struct fields via pointer 
	fmt.Println((*ps).Name) 
	fmt.Println(ps.Name) // Same as above: No need to explicitly dereference the pointer 
 
	ps.RollNumber = 31 
	fmt.Println(ps) 
} 

# Output 
&{11 Jack} 
Jack 
Jack 
&{31 Jack}

上面示例可以看到，通过结构体指针访问其属性无需显示解除引用。

3.3 使用new()方法创建结构体并返回指针

我们可以使用内置new方法创建结构体实例。new方法分配内存空间，并给每个属性设置零值，最后返回内存地址指针：

package main 
 
import "fmt" 
 
type Employee struct { 
	Id   int 
	Name string 
} 
 
func main() { 
	// You can also get a pointer to a struct using the built-in new() function 
	// It allocates enough memory to fit a value of the given struct type, and returns a pointer to it 
	pEmp := new(Employee) 
 
	pEmp.Id = 1000 
	pEmp.Name = "Sachin" 
 
	fmt.Println(pEmp) 
} 

# Output 
&{1000 Sachin}

3.4 暴露/隐藏结构体和结构体属性

任何结构体首字母为大写，则外部包可以直接访问。类似的结构体属性的首字母大写则暴露属性。
反之，所有以小写字母开头的仅在包内可见。请看示例：

example 
  main 
    main.go 
  model 
    address.go 
    customer.go

** customer.go**

package model 
 
type Customer struct {  // exported struct type 
	Id int				// exported field 
	Name string			// exported field 
	addr address        // unexported field (only accessible inside package `model`) 
	married bool  		// unexported field (only accessible inside package `model`) 
}

address.go

package model 
 
// Unexported struct (only accessible inside package `model`) 
type address struct { 
	houseNo, street, city, state, country string 
	zipCode                               int 
}

main.go入口程序：

package main 
 
import ( 
	"fmt" 
	"example/model" 
) 
 
func main() { 
	c := model.Customer{ 
		Id: 1,  
		Name: "Rajeev Singh", 
	} 
 
	c.married = true	// Error: can not refer to unexported field or method 
 
	a := model.address{} // Error: can not refer to unexported name 
 
	fmt.Println("Programmer = ", c); 
}

我们看到address 和 married 未暴露，不能在main包中访问。

4. 结构体是值类型

结构体是值类型。一个结构体变量赋值给另一个变量，则会产生一个拷贝给另一个变量。类似的，传递结构体给另一个函数，函数获得该结构体的拷贝。当然可以显示传递指针，避免拷贝大对象。

4.1 值类型拷贝

package main 
 
import "fmt" 
 
type Point struct { 
	X float64 
	Y float64 
} 
 
func main() { 
	// Structs are value types. 
	p1 := Point{10, 20} 
	p2 := p1 // A copy of the struct `p1` is assigned to `p2` 
	fmt.Println("p1 = ", p1) 
	fmt.Println("p2 = ", p2) 
 
	p2.X = 15 
	fmt.Println("\nAfter modifying p2:") 
	fmt.Println("p1 = ", p1) 
	fmt.Println("p2 = ", p2) 
} 

# Output 
p1 =  {10 20} 
p2 =  {10 20} 
 
After modifying p2: 
p1 =  {10 20} 
p2 =  {15 20}

4.2 结构体变量比较

两个结构体如果相应属性相对则变量相等：

package main 
 
import "fmt" 
 
type Point struct { 
	X float64 
	Y float64 
} 
 
func main() { 
	// Two structs are equal if all their corresponding fields are equal. 
	p1 := Point{3.4, 5.2} 
	p2 := Point{3.4, 5.2} 
 
	if p1 == p2 { 
		fmt.Println("Point p1 and p2 are equal.") 
	} else { 
		fmt.Println("Point p1 and p2 are not equal.") 
	} 
}

因为结构体是值类型，结果变量相等：

# Output 
Point p1 and p2 are equal.

总结

本文介绍Golang结构体，通过示例介绍定义、实例化、访问属性。结构体是值对象，实际应用对于大结构体可以使用结构体指针传递参数，避免拷贝大对象影响性能。


本文参考链接：https://blog.csdn.net/neweastsun/article/details/107286465
  文章来源：
  https://www.itguest.com/post/aebd2b1.html
阅读延展