高朗结构

A 结构 (“结构”的缩写)是具有声明的数据类型的数据字段的集合。 高朗可以通过组合一个或多个类型(包括内置类型和用户定义类型)来声明和创建自己的数据类型。结构中的每个数据字段都以已知类型声明,该类型可以是内置类型或其他用户定义类型。

结构是在Golang中创建具体的用户定义类型的唯一方法。通过组合一组固定的唯一字段来声明结构类型。结构可以改善模块化,并允许在系统周围创建并传递复杂的数据结构。您也可以将Structs视为用于创建数据记录(例如员工记录或电子商务产品)的模板。

声明以关键字开头 类型,然后是新结构的名称,最后是关键字 结构。在大括号内,使用名称和类型指定了一系列数据字段。

类型 identifier 结构{
  field1 data_type
  field2 data_type
  field3 data_type
}

声明结构类型

结构类型 长方形 声明具有三个不同数据类型的数据字段。在这里,使用的struct不会实例化该类型的新实例。

package main
 
import "fmt"
 
类型 长方形 结构 {
	length  float64
	breadth float64
	color   
}
 
func main() {
	fmt.Println(rectangle{10.5, 25.10, "red"})
}

长方形 结构及其字段不会导出到其他软件包,因为标识符以小写字母开头。在Golang中,如果名称以大写字母开头,则标识符将导出到其他软件包,否则,可访问性将仅限于软件包内。


创建结构类型的实例

变种 关键字初始化变量 直肠。使用 表示法,将值分配给struct字段。

package main
 
import "fmt"
 
类型 长方形 结构 {
	length  int
	breadth int
	color   
 
	geometry 结构 {
		area      int
		perimeter int
	}
}
 
func main() {
	变种 直肠 长方形 // 点 notation
	rect.length = 10
	rect.breadth = 20
	rect.color = "Green"
 
	rect.geometry.area = 直肠.length * 直肠.breadth
	rect.geometry.perimeter = 2 * (rect.length + 直肠.breadth)
 
	fmt.Println(rect)
	fmt.Println("Area:\t", 直肠.geometry.area)
	fmt.Println("Perimeter:", 直肠.geometry.perimeter)
}

将该结构打印到终端,显示已分配的值。


使用Struct文字创建Struct实例

创建一个实例 长方形 通过使用struct文字并将值分配给struct的字段来实现struct。

package main

import "fmt"

类型 长方形 结构 {
	length  int
	breadth int
	color   
}

func main() {
	变种 直肠1 = 长方形{10, 20, "Green"}
	fmt.Println(rect1)

	变种 直肠2 = 长方形{length: 10, color: "Green"} // breadth value skipped
	fmt.Println(rect2)

	rect3 := 长方形{10, 20, "Green"}
	fmt.Println(rect3)

	rect4 := 长方形{length: 10, breadth: 20, color: "Green"}
	fmt.Println(rect4)

	rect5 := 长方形{breadth: 20, color: "Green"} // length value skipped
	fmt.Println(rect5)
}

使用new关键字进行结构实例化

一个实例 结构 也可以使用 关键词。然后可以使用点符号将数据值分配给数据字段。

package main
 
import "fmt"
 
类型 长方形 结构 {
	length  int
	breadth int
	color   
}
 
func main() {
	rect1 := (rectangle) // 直肠1 is a pointer to an instance of 长方形
	rect1.length = 10
	rect1.breadth = 20
	rect1.color = "Green"
	fmt.Println(rect1)
 
	变种 直肠2 = (rectangle) // 直肠2 is an instance of 长方形
	rect2.length = 10
	rect2.color = "Red"
	fmt.Println(rect2)
}

的两个实例 长方形 实例化了struct 直肠1 指向实例化结构的地址,并且 直肠2 是它表示的结构的名称。


使用指针地址运算符的结构实例化

创建一个实例 长方形 通过使用指针地址运算符的struct表示为 & 符号。

package main

import "fmt"

类型 长方形 结构 {
	length  int
	breadth int
	color   
}

func main() {
	变种 直肠1 = &rectangle{10, 20, "Green"} // Can't skip any value
	fmt.Println(rect1)

	变种 直肠2 = &rectangle{}
	rect2.length = 10
	rect2.color = "Red"
	fmt.Println(rect2) // breadth skipped

	变种 直肠3 = &rectangle{}
	(*rect3).breadth = 10
	(*rect3).color = "Blue"
	fmt.Println(rect3) // length skipped
}

嵌套结构类型

通过使用其他Struct类型作为Struct字段的类型来创建Struct类型,可以嵌套Struct。将一个结构嵌套在另一个结构中可能是对更复杂的结构建模的有用方法。

package main

import "fmt"

类型 Salary 结构 {
	Basic, HRA, TA float64
}

类型 雇员 结构 {
	FirstName, LastName, Email 
	Age                        int
	MonthlySalary              []Salary
}

func main() {
	e := 雇员{
		FirstName: "Mark",
		LastName:  "Jones",
		Email:     "[email protected]",
		Age:       25,
		MonthlySalary: []Salary{
			Salary{
				Basic: 15000.00,
				HRA:   5000.00,
				TA:    2000.00,
			},
			Salary{
				Basic: 16000.00,
				HRA:   5000.00,
				TA:    2100.00,
			},
			Salary{
				Basic: 17000.00,
				HRA:   5000.00,
				TA:    2200.00,
			},
		},
	}
	fmt.Println(e.FirstName, e.LastName)
	fmt.Println(e.Age)
	fmt.Println(e.Email)
	fmt.Println(e.MonthlySalary[0])
	fmt.Println(e.MonthlySalary[1])
	fmt.Println(e.MonthlySalary[2])
}

在结构类型的定义中使用字段标签

在定义 结构 类型,可选 值可以添加到每个字段声明中。

package main
 
import (
    "fmt"
    "encoding/json"
)
 
类型 雇员 结构 {
    FirstName   `json:"firstname"`
    LastName    `json:"lastname"`
    City  `json:"city"`
}
 
func main() {
    json_string := `
    {
        "firstname": "Rocky",
        "lastname": "Sting",
        "city": "London"
    }`
 
    emp1 := (Employee)
    json.Unmarshal([]byte(json_string), emp1)
    fmt.Println(emp1)
 
    emp2 := (Employee)
    emp2.FirstName = "Ramesh"
    emp2.LastName = "Soni"
    emp2.City = "Mumbai"
    jsonStr, _ := json.Marshal(emp2)
    fmt.Printf("%s\n", jsonStr)
}

标签表示为原始字符串值(包装在一对 `` ),并被常规代码执行忽略。


将方法添加到结构类型

您还可以将方法添加到 结构 类型使用 方法接收者。一个方法 EmpInfo 被添加到 雇员 结构。

package main

import "fmt"

类型 Salary 结构 {
	Basic, HRA, TA float64
}

类型 雇员 结构 {
	FirstName, LastName, Email 
	Age                        int
	MonthlySalary              []Salary
}

func (e 雇员) EmpInfo()  {
	fmt.Println(e.FirstName, e.LastName)
	fmt.Println(e.Age)
	fmt.Println(e.Email)
	for _, info := range e.MonthlySalary {
		fmt.Println("===================")
		fmt.Println(info.Basic)
		fmt.Println(info.HRA)
		fmt.Println(info.TA)
	}
	return "----------------------"
}

func main() {

	e := 雇员{
		FirstName: "Mark",
		LastName:  "Jones",
		Email:     "[email protected]",
		Age:       25,
		MonthlySalary: []Salary{
			Salary{
				Basic: 15000.00,
				HRA:   5000.00,
				TA:    2000.00,
			},
			Salary{
				Basic: 16000.00,
				HRA:   5000.00,
				TA:    2100.00,
			},
			Salary{
				Basic: 17000.00,
				HRA:   5000.00,
				TA:    2200.00,
			},
		},
	}

	fmt.Println(e.EmpInfo())
}

为结构字段指定默认值

可以通过使用构造函数来实现分配自定义默认值的方法。除了直接创建结构外, 信息 函数可以用来创建一个 雇员 具有自定义默认值的struct 名称年龄 领域。

package main

import "fmt"

类型 雇员 结构 {
	Name 
	Age  int
}

func (obj *Employee) 信息() {
	if obj.Name == "" {
		obj.Name = "John Doe"
	}
	if obj.Age == 0 {
		obj.Age = 25
	}
}

func main() {
	emp1 := 雇员{Name: "Mr. Fred"}
	emp1.Info()
	fmt.Println(emp1)

	emp2 := 雇员{Age: 26}
	emp2.Info()
	fmt.Println(emp2)
}

这是一种技术,而不是Golang规范的一部分。


在Go编程语言中查找结构类型

反映 软件包支持以检查结构的基础类型。

package main

import (
	"fmt"
	"反映"
)

类型 长方形 结构 {
	length  float64
	breadth float64
	color   
}

func main() {
	变种 直肠1 = 长方形{10, 20, "Green"}
	fmt.Println(reflect.TypeOf(rect1))         // main.rectangle
	fmt.Println(reflect.ValueOf(rect1).Kind()) // 结构

	rect2 := 长方形{length: 10, breadth: 20, color: "Green"}
	fmt.Println(reflect.TypeOf(rect2))         // main.rectangle
	fmt.Println(reflect.ValueOf(rect2).Kind()) // 结构

	rect3 := (rectangle)
	fmt.Println(reflect.TypeOf(rect3))         // *main.rectangle
	fmt.Println(reflect.ValueOf(rect3).Kind()) // ptr

	变种 直肠4 = &rectangle{}
	fmt.Println(reflect.TypeOf(rect4))         // *main.rectangle
	fmt.Println(reflect.ValueOf(rect4).Kind()) // ptr
}

将结构与分配给数据字段的不同值进行比较

可以使用比较运算符比较相同类型的结构。

package main

import "fmt"

类型 长方形 结构 {
	length  float64
	breadth float64
	color   
}

func main() {
	变种 直肠1 = 长方形{10, 20, "Green"}
	rect2 := 长方形{length: 20, breadth: 10, color: "Red"}

	if 直肠1 == 直肠2 {
		fmt.Println("True")
	} else {
		fmt.Println("False")
	}

	rect3 := (rectangle)
	变种 直肠4 = &rectangle{}

	if 直肠3 == 直肠4 {
		fmt.Println("True")
	} else {
		fmt.Println("False")
	}
}

使用值和指针参考复制结构类型

r2 将与 r1,它是 r1 而不是对其进行引用。对任何更改 r2 不适用于 r1 反之亦然。什么时候 r3 更新后,分配给的基础内存 r1 已更新。

package main

import "fmt"

类型 长方形 结构 {
	length  float64
	breadth float64
	color   
}

func main() {
	r1 := 长方形{10, 20, "Green"}
	fmt.Println(r1)

	r2 := r1
	r2.color = "Pink"
	fmt.Println(r2)

	r3 := &r1
	r3.color = "Red"
	fmt.Println(r3)

	fmt.Println(r1)
}
{10 20 Green}
{10 20 Pink}
&{10 20 Red}
{10 20 Red}

r1r3 两者都引用相同的基础内存,它们的值是相同的。打印的值 r3r1 显示值是相同的。