go nil介绍

已于 2022-11-09 10:29:48 修改
阅读量977 收藏
点赞数
分类专栏： go语言 文章标签： golang 数据库 开发语言
于 2022-11-09 00:34:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daliucheng/article/details/127761672
版权

go nil介绍

先从下面的一段代码开始

下面的代码是模拟了启动多线程去查数据库，之后汇总的操作

数据库：mysql

orm框架：ent

代码：

package main

import (
	"awesomeProject/ent"
	"awesomeProject/ent/user"
	"context"
	"fmt"
	"github.com/go-sql-driver/mysql"
	"log"
	"sync"
)

func main() {
	config := mysql.Config{
		User:                 "root",
		Passwd:               "toor333666",
		Net:                  "tcp",
		Addr:                 "localhost:3306",
		DBName:               "test",
		AllowNativePasswords: true,
	}

	client, err := ent.Open("mysql", config.FormatDSN())
	if err != nil {
		log.Fatalf("failed opening connection to sqlite: %v", err)
	}
	defer client.Close()
	// 创建表
	if err := client.Schema.Create(context.Background()); err != nil {
		log.Fatalf("failed creating schema resources: %v", err)
	}
	// 初始化数据
	ctx := context.Background()
	for i := 0; i < 10; i++ {
		for j := 0; j < 3; j++ {
			client.User.Create().SetName(fmt.Sprintf("name-%d",j)).SetAge(j).SaveX(ctx)
		}
	}
	// 查找数据，比如这里相差各个年龄段的数据，之后做汇总，
	searchAges := []int{1,2,122}
	users := make([]interface{}, len(searchAges))
  
	var waitGroup sync.WaitGroup // 这就是java中的countdownlatch
	waitGroup.Add(len(searchAges))

	for idx, age := range searchAges {
		go func(idx,age int) {
			var ts []*ent.User
			err := client.User.Query().Where(user.AgeEQ(age)).Select(
				user.FieldID,user.FieldName,user.FieldAge).Scan(ctx,&ts)
			if err != nil{ 
				users[idx] = err
			}else{
				users[idx] = ts
			}
			waitGroup.Done()
		}(idx,age)
	}
	waitGroup.Wait()

	res := make([]*ent.User, 0)
	for _, item := range users {
		if err,ok:= item.(error);ok{
			panic(err)
		}
		if users,ok := item.([]*ent.User);ok{
			res = append(res, users...)
		}
	}
	println(fmt.Sprintf("%v", res))
	
	client.User.Delete().ExecX(ctx)
}

go.mod如下:

module awesomeProject

go 1.18

require (
	entgo.io/ent v0.11.4
	github.com/go-sql-driver/mysql v1.6.0
)

require (
	ariga.io/atlas v0.7.3-0.20221011160332-3ca609863edd // indirect
	github.com/agext/levenshtein v1.2.1 // indirect
	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
	github.com/go-openapi/inflect v0.19.0 // indirect
	github.com/google/go-cmp v0.5.6 // indirect
	github.com/google/uuid v1.3.0 // indirect
	github.com/hashicorp/hcl/v2 v2.13.0 // indirect
	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
	github.com/zclconf/go-cty v1.8.0 // indirect
	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
	golang.org/x/text v0.3.7 // indirect
)

代码很简单，有疑问的地方如下如所示：

在这里插入图片描述
上面的代码中searchAges参数122是没有数据的，所以结果中必然有一个是没有数据的，但item为nil，断言居然成功了。

那么，接下来就说说go中nil。

从感觉上来看，会将它和Java中的null联系起来，但go的nil和其他语言中（Java，Python）的null可不是一回事。

零值

go中，变量声明就有默认值，这个值叫做0值，

  • 0 for numeric types,
  • false for the boolean type, and
  • "" (the empty string) for strings.
  • nil for interfaces, slices, channels, maps, pointers and functions.

nil没有默认的类型

go中其他的标志符基本都有一个默认的类型比如，

比如false，true它们的类型是bool类型，iota的类型是int。

nil没有默认的类型，编译器会从上下文的信息中来推断他的类型，并且在之前

代码:

// 下面的代码会编译成功，编辑器可以从上下文中推断出nil的类型
	_ = (*struct{})(nil) // 这里代码的意思是类型转化，这里能转化不报错，说明类型是正确的。也就是说nil的类型和强转的类型是一样的
	_ = []int(nil)
	_ = map[int]bool(nil)
	_ = chan string(nil)
	_ = (func())(nil)
	_ = interface{}(nil)

 // 下面的和上面的等价的
	var _ *struct{} = nil
	var _ []int = nil
	var _ map[int]bool = nil
	var _ chan string = nil
	var _ func() = nil
	var _ interface{} = nil

 // 编译会失败，信息不足够，编译器也不知道是什么类型。
	var _ = nil

nil在go中不是一个关键词

nil值在一个上下文中可以被替换掉，代码如下

	nil := 123
	fmt.Println(nil) // 123

	// 下面的编译会失败，在当前的上下文中
  // nil已经是一个int的值了，代表的是int类型
	var _ map[string]int = nil

不同类型的空值大小可能不同

同一类型的所有值的内存布局总是相同的。此类型下的 nil和非nil的值大小相等，但是不同类型的nil可能不一样。

代码：

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var p *struct{} = nil
	fmt.Println( unsafe.Sizeof( p ) ) // 8

	var s []int = nil
	fmt.Println( unsafe.Sizeof( s ) ) // 24

	var m map[int]bool = nil
	fmt.Println( unsafe.Sizeof( m ) ) // 8

	var c chan string = nil
	fmt.Println( unsafe.Sizeof( c ) ) // 8

	var f func() = nil
	fmt.Println( unsafe.Sizeof( f ) ) // 8

	var i interface{} = nil
	fmt.Println( unsafe.Sizeof( i ) ) // 16
}

上面运行的结果不是不变的，编译器和架构会影响。以上打印的结果适用于64位体系结构和标准 Go 编译器。对于32位体系结构，打印大小将减半。

两个不同类型的nil可能无法比较

例如，下面示例中的两个比较都无法编译。原因是，在每次比较中，两个操作数都不能隐式转换为另一个操作数的类型。

go的比较规则可以看这个官网文档

简而言之。如果其中一个值可以隐式转换为另一个值的类型，则两个值是可比的。

代码：

// 编译会失败，类型不匹配
var _ = (*int)(nil) == (*bool)(nil)         // error
var _ = (chan int)(nil) == (chan bool)(nil) // error

下面的代码可以编译

type IntPtr *int
// 他俩底层的类型都是IntPtr*
var _ = IntPtr(nil) == (*int)(nil)

// go中每一个interface{}可以表示所有
var _ = (interface{})(nil) == (*int)(nil)

// 当向通道可以转换为单向通道，并且他俩底层的数据类型一致
var _ = (chan int)(nil) == (chan<- int)(nil)
var _ = (chan int)(nil) == (<-chan int)(nil)

两个相同类型的 Nil 值可能无法比较

在 Go 中，映射、切片和函数类型不支持比较。比较无法比较的类型的两个值(包括空值)是非法的。 这是语法限制，其实和nil值感觉不是很大。

下列比较无法编译。

var _ = ([]int)(nil) == ([]int)(nil)
var _ = (map[string]int)(nil) == (map[string]int)(nil)
var _ = (func())(nil) == (func())(nil)

下面是ok的

	var _ = ([]int)(nil) == nil
	var _ = (map[string]int)(nil) == nil
	var _ = (func())(nil) == nil

两个nil值可能不相等

如果比较的nil中有一个是接口值，结果总等于false，因为他们的底层的类型不一致，编译器不能推断出来，我们知道go的接口的底层有一对数据（类型和实际的值。）对于下面的例子中

interface{}(nil) 的一对数据为(type=nil,value=nil)

(*int)(nil) )的一对数据为 (type=*int,value=nil)

fmt.Println( (interface{})(nil) == (*int)(nil) ) // false

从nil值中检索数据不会Panic

从空映射值中检索元素将始终返回零元素值。

fmt.Println( (map[string]int)(nil)["key"] ) // 0
fmt.Println( (map[int]bool)(nil)[123] )     // false
fmt.Println( (map[int]*int64)(nil)[123] )   //

从nil的Channels、Maps、Slices、数组指针遍历是合法的

遍历map和slices类型的nil的步长为0

遍历数组指针的步长是它对应的数组的长度

遍历一个nil的channel会堵塞当前线程

代码：

for range []int(nil) {
	fmt.Println("Hello")
} // 不会输出


for range map[string]string(nil) {
	fmt.Println("world")
} // 不会出输出

for i := range (*[5]int)(nil) {
	fmt.Println(i)
} // 输出0,1,2,3,4


for range chan bool(nil) { // 堵塞在这里，被死锁检测到。
	fmt.Println("Bye")
}

通过非接口的nil值来调用方法不会panic

代码：

package main

type Slice []bool

func (s Slice) Length() int {
	return len(s)
}

func (s Slice) Modify(i int, x bool) {
	s[i] = x // panic if s is nil
}

func (p *Slice) DoNothing() {
}

func (p *Slice) Append(x bool) {
	*p = append(*p, x) // panic if p is nil
}

func main() {
 // 下面的不会抛错
	_ = ((Slice)(nil)).Length
	_ = ((Slice)(nil)).Modify
	_ = ((*Slice)(nil)).DoNothing
	_ = ((*Slice)(nil)).Append


	_ = ((Slice)(nil)).Length()
	((*Slice)(nil)).DoNothing()

	// 下面的会报错，但是报错不是在调用方法的时候，而是在方法里面操作对象的时候报错
	/*
	((Slice)(nil)).Modify(0, true)
	((*Slice)(nil)).Append(true)
	*/
}

*new(T)的结果就是T类型下面的0值

package main

import "fmt"

func main() {
	fmt.Println(*new(*int) == nil)         // true
	fmt.Println(*new([]int) == nil)        // true
	fmt.Println(*new(map[int]bool) == nil) // true
	fmt.Println(*new(chan string) == nil)  // true
	fmt.Println(*new(func()) == nil)       // true
	fmt.Println(*new(interface{}) == nil)  // true
}

总结

在 Go 中，为了简单和方便，nil 被设计为一个标识符，可以用来表示某些类型的零值。他不是一个不变的值，而是随着不同类型有不同的类型，在日常的编码中，编译器会根据上下文来推导出。

回答代码中的问题

首先代码中出现问题的是interface{},按照上面说的「两个nil值可能不相等」来说，结果已经推出来了。在go中接口是一堆方法的集合，并且接口变量的底层是一对数据结构（类型，实际的值），断言，反射是来拿到它们在做处理，先看下面的代码

var p *int              // (type=*int,value=nil)
var i interface{}       // (type=nil,value=nil)

if i != p {             // (type=*int,value=nil) != (type=nil,value=nil)
// to successfully compare these values, both type and value must match
    fmt.Println("not a nil")
}
// 运行结果是   "not a nil"

这两虽然都是nil，但他们的类型不一致。

在看一段代码

var p *int              // (type=*int,value=nil)
	var i interface{}       // (type=nil,value=nil)

	if p != nil{ // (type=*int,value=nil) != (type=*int,value=nil)
		fmt.Println("not a nil p")
	}


	if i != nil {           // (type=nil,value=nil) != (type=nil,value=nil)
		fmt.Println("not a nil i1")
	}

	i = p                   // assign p to i

	// a hardcoded nil is always nil,nil (type,value)
	if i != nil {           // (type=*int,value=nil) != (type=nil,value=nil)
		fmt.Println("not a nil i2")
	}
// 运行结果是   "not a nil i"

类比一开始的代码，结合上面的分析，看下面的解释。

在这里插入图片描述### 如何处理这种情况

有三种方式，代码如下

import "reflect"
import "unsafe"

func do(v interface{}){
    // 可能有问题，因为这是接口类型的变量
    // 比如传递进来的是 (type=*int,value=nil)，永远不会为true，这里的nil是 (type=nil,value=nil)
    if v == nil {

    }
		
   // 这种方式是ok的，将nil值转换为同一类型下来比较
   // 但是这样的比较要对业务很熟悉，实际动起手来比较麻烦
    if v == (*int)(nil){
      
    }
		
  // 因为是nil，所以可以拿到 反射中的Value是否为nil
    if reflect.ValueOf(v).IsNil() {
    
    }
	// 通过unsafe来直接检查一个接口类型的变量的value部分是否为0，但是如果value不是可以为nil的那5中类型的话也不会报错
    if (*[2]uintptr)(unsafe.Pointer(&v))[1] == 0 {
   
    }

}

对于上面的代码，可以采取下面的方式来判断

在这里插入图片描述

相关博客：

Why Golang Nil Is Not Always Nil? Nil Explained

nils in Go

关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。
daliucheng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang nil接口和空接口
01-08
前言 接口： 接口类型 是由一组方法签名定义的集合。 接口类型的变量可以保存任何实现了这些方法的值。 类型通过实现一个接口的所有方法来...在一些语言中，这会触发一个空指针异常，但在 Go 中通常会写一些方法来优雅
Go语言interface 与 nil 的比较
09-21
在golang中，nil只能赋值给指针、channel、func、interface、map或slice类型的变量。如果未遵循这个规则，则会引发panic。
深度剖析 Go 的 nil
flynetcn的专栏
05-08 1964
The following article is from 奇伢云存储 Author 奇伢 前几天有小伙伴问我说，golang 里面很多类型使用 nil 来赋值和做条件判断，总是混淆记不住。你可能见过：： 很多文章和书会教你：Go 语言默认定义的类型赋值会被 nil； error 返回值经常用 return nil 的写法； 多种类型都可以使用 if 是否 != nil； 上面的事情在 Go 编程里随处可见，下面思考几个问题，看自己对 nil 这个知识点是否做到了知.
go-关于nil
jianlee1991的博客
08-10 466
在go语言中nil只是一个变量名，buildin/buildin.go 中 定义 // nil is a predeclared identifier representing the zero value for a // pointer, channel, func, interface, map, or slice type. var nil Type // Type must be a pointer, channel, func, interface, map, or slice ty...
go的nil是什么
m0_57236802的博客
03-15 398
不仅表示接口自身的零值，还表示该接口没有绑定任何实现，这在Go语言的错误处理和接口编程中非常常见。因此，理解和正确使用。可以赋值给一个指针类型的变量，也可以赋值给一个切片类型的变量，但它们代表的含义和用法会根据具体的类型而有所不同。被用作上述类型的零值时，它通常表示该变量还没有被初始化或分配到具体的内存空间。是一个预声明的标识符，用来表示某些类型的零值。本身并不拥有一个固定类型，其具体类型取决于它被赋值的目标类型。在Go中具有类型上下文敏感性。是编写安全和高效Go代码的重要部分。
Go语言中的nil是什么
huan
01-14 345
go
go语言中，到底nil是个什么货？
lcl20093466的博客
01-28 856
什么是nil？go中关于nil的定义为(buildin.go中)： var nil Type type Type int go定义变量时，会默认分配一个零值，如：bool->false、numbers -> 0 、string -> “” 。而nil则为指针、切片、map、通道、函数对象、接口对象的零值，nil可以代表多种对象，如下代码： var a = nil //此代码报错，因为编译器无法确定a的数据类型 var a = (int*)(nil) //代码正确
对Golang的nil的理解和认识
01-07
按照Go语言的规范，任何类型在未初始化的时候都对应一个零值： 布尔型零值为：false 整型零值为：0 字符串的零值为： 而指针，函数，interface，slice，channel，map的零值均为nil Go文档中说明：nil是预定义的...
iferr:生成“ if err！= nil {”块
05-13
= nil {”块 if err != nil {当前功能块， if err != nil {生成。 用法 安装和更新方式 $ go get -u github.com/koron/iferr 运行， if err != nil {对于1234字节的位置块，则获取。 $ iferr -pos 1234 < main....
你真的知道 GO 中 nil 代表什么吗？
m0_37322399的博客
09-28 673
本篇文章主要是，看看有没有你还不知道的情况呢？使用 Golang 的朋友都知道，在 Golang 的世界里面，nil 标识符可以作为多种数据结构的零值，通常我们会将 nil 就认为是空的意思，就像 C 语言里面的 NULL 一样此处说到，对应着的就是一个零值例如：整形的零值，是 0字符串的零值是 “”那么布尔类型的零值自然就是 false接下来分别从零值为 nil 的几种数据类型来聊聊的 nil 的那些事。
如何正确理解和使用 Golang 中 nil ？
路多辛的所思所想
12-15 1389
在 Golang 中，nil 是一个预定义的标识符，在不同的上下文环境中有不同的含义，但通常表示“无”、“空”或“零值”。nil 可以赋值给指针、切片、map、通道、函数以及接口类型的变量。理解 nil 的含义对于编写出健壮的 Go 程序至关重要，如果不能正确地处理 nil 可能会导致意外的问题。
Go 语言 nil 空值
GeeCode的博客
06-29 606
本文介绍了 Go 语言中nil空值的概念、用法和注意事项，并提供了相应的示例代码。nil在 Go 语言中被用于表示指针、接口和函数类型的零值或空值，但需要注意它的使用限制和可能导致的运行时错误。在实际开发中，我们需要谨慎使用nil，并且要确保我们的代码能够正确地处理nil值。
Go中的nil（零值）
qq_41661056的博客
11-22 701
package main import ( "fmt" "unsafe" ) //Go语言中 nil 是一个预先定义好的标识符，它是许多类型的零值表示， //有过其他编程语言开发经验的开发者也许会把 nil 看作其他语言中的 null（NULL）， //其实这并不是完全正确的，因为Go语言中的 nil 和其他语言中的 null 有很多不同点。 func main() { //1.ni...
Go 的 nil 值判断，千方百计，还是踩坑！
EDDYCJY的博客
07-07 1249
坚持思考，就会很酷今天奇伢给大家分享一个实际踩坑的一个示例，以为的 nil 并不是 nil。众所周知，Go 编程中 nil 值的判断可谓是随处可见：v:=findSomething() ifv!=nil{ //dosomething }nil 值究竟是什么？这个在之前的文章也分析过（深度剖析 Go 的 nil），并且也提到了在 interfac...
Go的nil：空值/零值
后面牵个人的博客
04-20 783
在Go语言中，布尔类型的零值（初始值）为 false，数值类型的零值为 0，字符串类型的零值为空字符串""，而指针、切片、映射、通道、函数和接口的零值则是 nil。 nil 是Go语言中一个预定义好的标识符，有过其他编程语言开发经验的开发者也许会把 nil 看作其他语言中的 null（NULL），其实这并不是完全正确的，因为Go语言中的 nil 和其他语言中的 null 有很多不同点。 nil 标...
Go之nil
weixin_44718747的博客
01-05 474
nil是go语言中预先的标识符 nil仅可以代表指针、通道(channel)、函数(function)、接口（interface）、映射(map)或切片(slice)的默认零值
golang：nil(空值/零值)
OceanStar的博客
12-12 928
前言 Golang 提供了database/sql包用于对sql数据库的访问，作为操作数据库的入口对象sql.DB，主要为我们提供了两个重要的功能： sql.DB通过为数据库驱动为我们提供管理底层数据库连接的打开和关闭操作 sql.DB为我们管理数据库连接池 需要注意的是，sql.DB表示操作数据库的抽象访问接口，而非一个数据库连接对象；它可以根据driver打开关闭数据库连接，管理连接池。正...
【go学习笔记】理解Go语言的nil 【转】
热门推荐
小白菜的专栏
07-11 1万+
最近在油管上面看了一个视频：Understanding nil，挺有意思，这篇文章就对视频做一个归纳总结，代码示例都是来自于视频。 nil是什么 相信写过Golang的程序员对下面一段代码是非常非常熟悉的了： if err != nil { // do something.... } 当出现不等于nil的时候，说明出现某些错误了，需要我们对这个错误进行一些处理，而如果等于n...
golang nil
最新发布
03-19
在Go语言中，nil是一个预定义的标识符，表示指针、切片、映射、通道、函数和接口类型的零值。它表示一个指针或引用类型的零值，即表示该类型的变量未指向任何有效的内存地址。 在Go语言中，nil可以用于以下几种情况： 1. 指针类型：当一个指针变量没有被初始化时，它的默认值就是nil。nil指针表示指向空地址，即没有指向任何有效的内存地址。 2. 切片类型：当一个切片变量没有被初始化时，它的默认值也是nil。nil切片表示一个空切片，即没有指向任何底层数组。 3. 映射类型：当一个映射变量没有被初始化时，它的默认值也是nil。nil映射表示一个空映射，即没有任何键值对。 4. 通道类型：当一个通道变量没有被初始化时，它的默认值也是nil。nil通道表示一个空通道，即没有任何数据传输。 5. 函数类型：当一个函数变量没有被初始化时，它的默认值也是nil。nil函数表示一个空函数，即没有任何可执行的代码。 6. 接口类型：当一个接口变量没有被初始化时，它的默认值也是nil。nil接口表示一个空接口，即没有实现任何方法。 需要注意的是，对于基本类型（如int、float、bool等），不能赋值为nil，因为它们不是引用类型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值