- make 和 new 的区别:
make 用于创建切片、映射和通道,返回的是创建类型的引用。
new 用于创建任意类型的指针,返回的是该类型的指针。
// make 用法示例
slice := make([]int, 5) // 创建一个包含5个元素的整型切片
// new 用法示例
var pointer *int
pointer = new(int) // 创建一个整型指针,指向默认值 0
- 数组和切片的区别
数组的长度是固定的,在创建时必须指定长度;切片长度不固定,可以动态扩展。
数组是值类型,复制操作会复制整个数组;切片是引用类型,复制操作只会复制引用,不会复制底层数据。
数组和切片的索引方式不同,数组索引从0开始,切片索引可以从任意位置开始。
// 数组的创建和赋值示例
var arr [3]int // 创建一个包含3个元素的整型数组
arr[0] = 1
arr[1] = 2
arr[2] = 3
// 切片的创建和赋值示例
slice := []int{1, 2, 3} // 创建一个包含3个元素的整型切片
- for range 循环中地址是否会发生变化:
在 for range 循环中,如果循环的是切片或数组,那么每次循环中的元素都是原始数据的一个拷贝,地址不会发生变化。如果循环的是映射,那么每次循环中的元素是一个键值对,地址也不会发生变化。
// 切片的 for range 循环示例
slice := []int{1, 2, 3}
for i, v := range slice {
fmt.Printf("slice[%d] = %d, addr: %p\n", i, v, &v)
}
// 输出结果:
// slice[0] = 1, addr: 0xc000014160
// slice[1] = 2, addr: 0xc000014160
// slice[2] = 3, addr: 0xc000014160
// 映射的 for range 循环示例
m := map[string]int{"a": 1, "b": 2}
for k, v := range m {
fmt.Printf("m[%s] = %d, addr: %p\n", k, v, &v)
}
// 输出结果:
// m[a] = 1, addr: 0xc000014168
// m[b] = 2, addr: 0xc000014168
- defer 的工作方式和执行顺序:
defer 用于在函数返回之前执行一些操作,通常用于释放资源或记录日志。
多个 defer 语句的执行顺序是先进后出(类似于栈),即最后一个 defer 语句会最先执行,最先定义的 defer 语句会最后执行。
在执行 defer 语句时,函数的返回值已经确定,但是可以通过修改具名返回值来修改函数的返回值。
func demo() (result int) {
defer fmt.Println("defer 1, result:", result)
defer fmt.Println("defer 2, result:", result)
result = 1
fmt.Println("set result to 1")
return result + 1
}
// 输出结果:
// set result to 1
// defer 2, result: 2
// defer 1, result: 2
- uint 类型溢出
在 Go 语言中,整数类型分为有符号整数类型和无符号整数类型。其中,uint 类型是无符号整数类型,表示非负整数。uint 类型会发生溢出,当一个无符号整数类型的值大于它能够表示的最大值时,它会发生溢出,导致值重新变为 0,然后继续增加。
var x uint8 = 255
fmt.Println(x, x+1, x+2) // 输出:255 0 1
- rune 类型介绍
rune 类型是 Go 语言中的内置类型,表示一个 Unicode 码点,也就是一个字符。在 Go 语言中,一个 rune 类型的值通常使用单引号来表示,例如 'a'。rune 类型的底层实现是 int32 类型。
var r rune = '好'
fmt.Printf("%c\n", r) // 输出:好
在上面的示例代码中,定义了一个 rune 类型的变量 r,并将其初始化为 '好',即一个汉字的 Unicode 码点。然后使用 %c 格式化占位符来输出 r 的值,可以看到,输出结果为 好。
- Go 中解析 tag 的实现方式和反射原理
Go 中的 tag 是用于给结构体中的字段添加元数据的一种方式。tag 通常用于在运行时解析结构体中的信息,例如在 ORM 库中,tag 可以用于指定数据库中表的名称和字段名。Go 语言提供了反射(reflection)机制,可以在运行时动态地获取类型信息和访问对象的成员和方法,可以通过反射机制实现 tag 的解析。
在 Go 语言中,反射的主要实现方式是使用 reflect 包。 reflect 包提供了两个重要的类型:Type 和 Value。Type 表示类型的元信息,包括名称、大小、方法等;Value 表示值的元信息,包括类型、值、字段、方法等。
当使用反射机制解析结构体时,可以使用 reflect 包中的 TypeOf 和 ValueOf 函数来获取类型和值的元信息。然后,可以通过 TypeOf 函数获取结构体的类型信息,通过 ValueOf 函数获取结构体的值信息。接着,可以使用 Type 和 Value 类型的方法来获取结构体的字段和方法等信息。
type User struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
u := User{Name: "Alice", Age: 18}
t := reflect.TypeOf(u)
v := reflect.ValueOf(u)
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
value := v.Field(i)
fmt.Printf("%s: %v\n", field.Tag.Get("json"), value.Interface())
}
}
在上面的示例代码中,定义了一个名为 User 的结构体,其中包含了两个字段:Name 和 Age,并在它们上面添加了 json tag。然后,在 main 函数中,创建了一个 User 类型的变量 u,并使用 reflect.TypeOf 和 reflect.ValueOf 函数获取 u 的类型和值信息。接着,使用 t.NumField 方法获取 User 结构体中的字段数量,并使用 t.Field 方法和 v.Field 方法获取每个字段的类型信息和值信息。最后,使用 field.Tag.Get("json") 方法获取每个字段上的 json tag 的值,并使用 value.Interface() 方法获取每个字段的值。可以看到,输出结果是:
name: Alice
age: 18
t := reflect.TypeOf(User{})
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
jsonTag := field.Tag.Get("json")
bsonTag := field.Tag.Get("bson")
fmt.Printf("%s: %s, %s\n", field.Name, jsonTag, bsonTag)
}
- 调用函数传入结构体时,应该传值还是指针?
在 Go 语言中,调用函数时传递结构体,应该根据实际情况考虑传值还是传指针。如果结构体较小,传值比较方便,而且可以避免指针的额外开销。但是,如果结构体较大,传指针可以避免结构体的复制,提高程序的性能。
需要注意的是,在 Go 语言中,所有的参数传递都是值传递,包括指针类型。因此,即使传递一个指针类型的参数,函数内部也会复制该指针的值,而不是指针指向的值。
type User struct {
Name string
Age int
}
func modifyUser1(u User) {
u.Name = "Bob"
u.Age = 20
}
func modifyUser2(u *User) {
u.Name = "Bob"
u.Age = 20
}
func main() {
u := User{Name: "Alice", Age: 18}
// 传值
modifyUser1(u)
fmt.Println(u) // 输出:{Alice 18}
// 传指针
modifyUser2(&u)
fmt.Println(u) // 输出:{Bob 20}
}
在上面的示例代码中,定义了一个 User 结构体,然后分别定义了两个函数 modifyUser1 和 modifyUser2,分别接收值类型和指针类型的参数。然后定义了一个 User 类型的变量 u,并将其初始化为 {Alice 18}。接着,分别调用了 modifyUser1 和 modifyUser2 函数,并将 u 作为参数传递进去。可以看到,当传值类型的参数时,函数内部对 u 的修改并没有影响到原来的 u 变量。而当传指针类型的参数时,函数内部对 u 的修改可以直接反映到原来的 u 变量上。
- 关于 context:
context 结构是怎样的?
context 的使用场景和用途是什么?
在 Go 语言中,context 是一个标准库中的包,用于在不同的 goroutine 之间传递请求范围的数据、取消信号以及截止时间等信息。在并发编程中,context 是非常重要的一部分,能够帮助更好地控制和管理 goroutine 的行为。
context 包中定义了一个 Context 接口,该接口定义了四个方法:
Deadline() (deadline time.Time, ok bool):返回当前 context 的截止时间。
Done() <-chan struct{}:返回一个只读的 channel,当 context 被取消或者超时时,该 channel 会被关闭。
Err() error:返回 context 取消的原因。
Value(key interface{}) interface{}:返回指定 key 对应的值。
Context 接口还有一个实现:context.Background(),用于创建一个空的 context。此外,还有一个 context.WithCancel(parent Context) (ctx Context, cancelFunc func()) 方法,用于创建一个派生的 context 和取消函数,可以通过调用取消函数来取消 context 的操作。
context 的使用场景和用途是多种多样的,例如:
在 HTTP 服务中使用 context 可以传递请求范围的数据,例如用户的认证信息、请求 ID 等,这些数据可以在后续的处理中使用。
在数据库查询操作中使用 context 可以设置查询的超时时间,如果查询时间超过了指定的时间,就会被取消,避免查询操作一直阻塞。
在服务调用中使用 context 可以传递调用链信息,例如追踪 ID、父子调用关系等,可以帮助进行分布式跟踪和日志记录。
在测试中使用 context 可以设置测试的超时时间,如果测试时间超过了指定的时间,就会被取消,避免测试无限制地运行。
- unsafe 介绍
unsafe 是 Go 语言中一个特殊的包,其中包含了一些不安全的操作,这些操作涉及指针运算、类型转换等操作,可以绕过 Go 语言中的类型安全检查,直接操作内存,可能会引起一些未定义的行为。
在 Go 语言中,通常不会直接使用 unsafe 包,因为这会导致程序变得不稳定、不可移植,容易出现难以调试和排查的问题。但是,在某些特殊的场景下,可能需要使用 unsafe 包来实现一些高性能的操作,例如:
访问和修改结构体的私有字段
绕过数组边界检查,实现更高效的内存操作
将任意类型的指针转换成 uintptr 类型的指针,进行指针运算
突破 Go 语言的类型系统,实现类型之间的相互转换
在使用 unsafe 包时,需要格外小心,遵循一些基本的规则,例如:
不要对指针进行未经检查的偏移或解引用操作
不要将指针转换成不同类型的指针,除非可以保证类型安全
不要将指针转换成 uintptr 类型的指针,除非必须进行指针运算
总之,在使用 unsafe 包时,需要慎重考虑,并且确保操作的正确性和安全性。如果可能,应该尽量避免使用 unsafe 包,使用 Go 语言的安全机制来保证程序的正确性和稳定性。
package main
import (
"fmt"
"unsafe"
)
type Person struct {
name string
age int
}
func main() {
p := Person{name: "Alice", age: 18}
// 访问私有字段 name
namePtr := (*string)(unsafe.Pointer(&p))
fmt.Printf("name: %v\n", *namePtr)
// 修改私有字段 name
*namePtr = "Bob"
fmt.Printf("name: %v\n", p.name)
}
在这个例子中,定义了一个 Person 结构体,其中包含了两个字段 name 和 age,其中 name 字段是私有的,外部无法直接访问。然后,使用 unsafe 包中的 Pointer 和 unsafe.Pointer 函数,将 Person 结构体的地址转换成一个 unsafe.Pointer 类型的指针,再将这个指针转换成一个 *string 类型的指针,即可访问结构体中的私有字段 name。最后,通过修改指针所指向的值,实现了对私有字段 name 的修改。
需要注意的是,这种方式实现了对私有字段的访问和修改,但同时也绕过了 Go 语言中的类型安全检查,可能会引起一些未定义的行为。因此,建议只在极少数情况下使用 unsafe 包,同时需要格外小心,确保程序的正确性和安全性。
标签:知识点,name,fmt,unsafe,Golang,Go,类型,指针 From: https://www.cnblogs.com/sening/p/17332348.html