您当前的位置:首页 > 电脑百科 > 程序开发 > 语言 > Go语言

golang基本数据类型讲解

时间:2023-05-20 16:49:19  来源:  作者:干饭人小羽

Go语言中,数据类型分为**静态类型**和**底层类型**,感觉底层类型是golang实现的时候所使用的C语言的类型,而静态类型仅仅是针对于go语言本身而言所定义好的类型。具体的信息可以查看$
GOROOT/src/runtime/runtime.h 可以看到golang中的byte类型,通过`typedef uint8 byte`来定义,这样在golang中直接使用反射



package main

import (

	"fmt"

	"reflect"

)

func main() {

	var b byte = 'D'

	fmt.Println(reflect.TypeOf(b))

}

//output: uint8
 

这里通过反射得到的是uint8,8个bit表示的无符号整数类型。

string

可以看到string类型的结构体就是



struct String

{

    byte* str;

    intgo len;

}
 

字符数组存储实际的数据,len存储长度。通过结构体就可以看到,定义好string变量之后是不能动态增加的,因为len已经写入进去了。

strconv golang中string与基本数据类型之间的转化
fmt.sprintf 函数也可以将interface类型转化为string类型

http://blog.csdn.NET/siddontang/article/details/23541587
string之间的类型的比较 strings.Equal??

slice

slice为了实现动态增长,又多添加了一个元素cap,这个元素表示已经分配的元素,就是相当于总的空间,len表示对于用户使用而言这个slice的实际长度。这个和JAVA中的Arraylist感觉有点类似,就是先分配一个空间,之后看空间不够的话,再动态扩展,但是扩展的过程对使用者来说是不可见的:



struct Slice

{

    byte* array;

    uintgo len;

    uintgo cap;

}
 

注意slice的第一个参数是一个byte指针,实际上指向的就是底层数组的对应的位置。
这里补充一点,关于初始化的问题,make函数可以用于对slice、map 以及 channel对象进行初始化操作,这三个对象的背后使用了必须要初始化的结构,比如对于slice , 要是不初始化的话,各个值都是nil 显然是没没法使用的。关于make与new的区别可以参考这个博客

下面是一个slice和string转化的例子,可以用来更好地了解slice与string以及底层数组的关系,不同的生成slice的方式,内部的操作是不同的。



package main

import (

	"fmt"

	"unsafe"

)

func main() {

	//example 1

	var slice []int32 = make([]int32, 5, 10)

	//p是指向slice类型的一个指针

	//这里是模拟一个slice类型 然后转化过来

	p := (*struct {

		array uintptr

		len   int

		cap   int

	})(unsafe.Pointer(&slice))

	//para v will print the go type

	//If the value is a struct,

	//the %+v variant will include the struct’s field names

	fmt.Printf("output:%+vn", p)

	//example 2

	//声明数组的时候 没有显式指定数组的长度 而是通过特殊的标记 ...

	//告诉编译器 让编译器去自动地计算

	var array = [...]int32{1, 2, 3, 4, 5}

	//数组进行截取 转化为slice 此时自动给len 和 cap 赋了值

	var sliceb = array[2:4]

	fmt.Printf("before modify: array=%+v, slice = %+vn", array, sliceb)

	//此时 slice 中用的底层数组和 array 是同一个

	//此时 slice[0]的位置 指向的实际是底层数组中 元素3所在的位置

	sliceb[0] = 678

	fmt.Printf("after modify: array=%+v, slice = %+vn", array, sliceb)

	//example 3

	//注意 如果使用的是Append方式生成新的slice

	//就不会有类似的效果 因为采用append方式会分配新的底层数组

	array = [...]int32{1, 2, 3, 4, 5}

	var slicec = array[1:3]

	slicec = append(slicec, 6, 7, 8)

	//可以对比这次结果 发现 两次array的输出是一样的 并没有因为 slice的修改而对array造成影响

	fmt.Printf("before modify: array=%+v, slice = %+vn", array, sliceb)

	slicec[0] = 123

	fmt.Printf("after modify: array=%+v, slice = %+vn", array, sliceb)

	//注意 从slice 生成slice 的时候原理也是类似的 直接用slicea=sliceb[para1:para2]的语法

	//使用的是同一个底层的数组 要是通过append方式 则会重新分配底层数组

}

/* 输出:

output:before modify: array=[1 2 3 4 5], slice = [3 4]

after modify: array=[1 2 678 4 5], slice = [678 4]

before modify: array=[1 2 3 4 5], slice = [3 4]

after modify: array=[1 2 3 4 5], slice = [3 4]

*/
 

map

map类型、slice类型、以及通道类型,都是引用类型,引用类型就是说这个结构总会持有一个指针,保持对底层某个结构的引用。作为对比,数组类型就是值类型。对于引用类型,在使用的时候,具体声明了之后,还要进行初始化,只有这样才能建立起和底层数据结构之间的联系。使用字典的时候,要不就直接声明+初始化,要不就声明之后使用make初始化。

//直接声明加赋值

mb := map[int]string{1: "hello", 2: "go"}

//直接声明并初始化

m := make(map[string]int)

之后就可以直接使用了。

array

array定义的时候,通过[n]类型进行定义,可以在定义的时候就把值赋进去,比如[3]strng{"a","b","c"} 还可以在[]中使用...标记,这样编译器会自动识别数组的长度,并且进行初始化。

interface以及类型转化

接口类型的实现比较复杂,整理出几条关于接口的要点,实际中,关于断言表达式的地方总是用的不太好。这个帖子关于断言说的比较好。这个文章介绍也比较好。

go 语言是编译型的,有一次写了这样的代码 :

containerpid = fmt.Sprintf("%d", containerpid)

之后是对containerpid进行一些字符串的操作,比如字符串的拼接,在编译的时候就会报如下的错误:

invalid operation: "teststring" + containerpid (mismatched types string and interface {})

主要原因是因为go并不是那种动态执行的语言,因为是要先编译好再执行,在编译器看来,这个contaierid还是没有转化成strig类型(??) 除非不使用同名的变量,另外新起一个变量名字,这样编译时才能通过。

(1)普通类型向接口类型的转化是隐式的,接口类型向普通类型转换需要类型断言。由于interface{}包含了0个方法,所以任何类型都实现了interface{}接口,这就是为什么可以将任意类型值赋值给interface{}类型的变量,包括nil,下面是隐式转化的例子:

package main

import (

	"fmt"

	"reflect"

)

func main() {

	var val interface{} = "hello"

	fmt.Println(reflect.TypeOf(val)) //output: string

	fmt.Println(val)

	val = []byte{'a', 'b', 'c'}

	fmt.Println(reflect.TypeOf(val)) //output: string

	fmt.Println(val)

}

(2)在显式的类型转化中,一种方式是使用comma-ok的断言语法,由于golang中不像java哪有那样采用泛型声明的方式,因此好多时候不能确定这个类型到底实现了哪些接口,于是可以采用断言表达式,注意 x.(T) 这样的断言类型转化,x 必须是一个接口类型的变量,T 是一个对应的实际的类型,比如下面这个程序,生成一个interface{}类型的数组,之后通过隐式转化,可以往里面放入任何类型的变量,之后还可以再使用用断言表达式检测对应的类型。

package main

import (

	"fmt"

)

type Test []interface{}

func main() {

	test := make(Test, 5)

	test[0] = "a"

	test[1] = 2

	test[2] = true

	test[3] = []byte("test")

	for index, element := range test {

		if value, ok := element.(string); ok {

			fmt.Printf("test[%d] is type of string the value is %vn", index, value)

		} else if value, ok := element.([]byte); ok {

			fmt.Printf("test[%d] is type of string the []byte is %vn", index, value)

		}

	}

}

(3)在使用实例实现interface的时候,还要注意值方法和指针方法的区别。interface这里的使用,多多少少可以看出一些动态语言的设计风格,就是所谓的"鸭子类型",即不是通过显式的指明继承自某个接口或者类,而是由当前类型实现方法的属性集合来决定。理解上就是,感觉比静态的类型逼格高一点,总之我的interface就写在那里,你要是想继承我,使用我的方法,就把这些方法实现了就行,并不要求你显示的声明,继承自我,怎样怎样。有些动态类型的语言在运行期才能进行类型的语法检测,go语言在编译期间就可以检测。比如下面这个例子:

package main

import (

	"fmt"

	"reflect"

	"sort"

)

type Sortable interface {

	Len() int

	Less(i, j int) bool

	Swap(i, j int)

}

type SortStringA [3]string

type SortStringB [3]string

func (self SortStringA) Len() int {

	return len(self)

}

func (self SortStringA) Less(i, j int) bool {

	return self[i] < self[j]

}

func (self SortStringA) Swap(i, j int) {

	self[i], self[j] = self[j], self[i]

}

func (self SortStringA) Sort() {

	sort.Sort(self)

}

func (self *SortStringB) Len() int {

	return len(self)

}

func (self *SortStringB) Less(i, j int) bool {

	return self[i] < self[j]

}

func (self *SortStringB) Swap(i, j int) {

	self[i], self[j] = self[j], self[i]

}

func (self *SortStringB) Sort() {

	//调用sort包中的 Sort方法 传入的参数只要是一个实现了 sort.interface的类型的实例即可

	sort.Sort(self)

}

func main() {

	sa := SortStringA{"2", "3", "1"}

	sb1 := &SortStringB{"2", "3", "1"}

	sb2 := SortStringB{"2", "3", "1"}

	fmt.Println(reflect.TypeOf(sa))

	sorta, ok := interface{}(sa).(Sortable)

	fmt.Println(reflect.TypeOf(sorta))

	fmt.Println(ok) //output:true

	sa.Sort()

	fmt.Printf("SortStringA after sort %v:n", sa)

	sort.Sort(sa)

	fmt.Printf("SortStringA after sort %v:n", sa)

	//在golang 的源码包中

	fmt.Println(reflect.TypeOf(sb1))

	sort.Sort(sb1)

	sorted := sort.IsSorted(sb1)

	fmt.Printf("sb1 (type:SortStringB) after sort %v :, is sorted : %v n", *sb1, sorted)

	sb2.Sort()

	fmt.Printf("sb2 (type:SortStringB) after sort : %vn", sb2)

}

/*output:

main.SortStringA

main.SortStringA

true

SortStringA after sort [2 3 1]:

SortStringA after sort [2 3 1]:

*main.SortStringB

sb1 (type:SortStringB) after sort [1 2 3] :, is sorted : true

sb2 (type:SortStringB) after sort : [1 2 3]

感觉这一段代码还是能够说明一些问题的:

  • 首先定义了一个sortstable的 接口 这个接口中有三个方法,这三个方法同sort包中的基本类型sort.interface中定义的三个方法是一样的,之后分别用值方法与指针方法对这三个方法进行了实现。
  • 可以看到,采用值方法时,因为方法调用的时候,采用的是指传递,原来的变量中sa的数据并没有排序。同时还测试了一下断言表达式,通过comma-ok的表达式,sa类型可以转化为sortable类型,这里体现了其动态性,但是采用反射输出的时候,还显示的是其本身声明时候的类型main.SortStringA,这里又体现了其强静态类型(类型一但确定就不再改变),两者结合起来使Go语言在保持强静态类型的安全和高效的同时,也能灵活安全地在不同相容类型之间转换。(这个文章讲一些interface原理性的内容,比较好)注意里面的典型的interface+switch+断言的使用方式。
  • 由于sortable中的三个方法和sort.interface中定义的三个方法一样,因此sa sb相当于都实现了sort.interface方法,可以直接调用sort包中的函数。但是要注意,具体实现的时候,前一个是SortStringA本身实现了三个方法,后一个是SortStringB指针实现了三个方法,因此 SortStringB指针类型实现了 sort.Interface 调用的时候传递过去的要是指针才行,否则编译报错。比如直接sort.Sort(sb2)会报错
SortStringB does not implement sort.Interface (Len method has pointer receiver)


Tags:golang   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,不构成投资建议。投资者据此操作,风险自担。如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除。
▌相关推荐
1. 引言反射是现代编程语言中非常重要的一个特性,尤其是在面向对象编程语言中此前的文章中,我们看到 golang 如何实现面向对象的封装: 通过 GoLang 实现面向对象思想如果能够...【详细内容】
2023-05-24  Tags: golang  点击:(2)  评论:(0)  加入收藏
在go语言中,数据类型分为**静态类型**和**底层类型**,感觉底层类型是golang实现的时候所使用的c语言的类型,而静态类型仅仅是针对于go语言本身而言所定义好的类型。具体的信息...【详细内容】
2023-05-20  Tags: golang  点击:(0)  评论:(0)  加入收藏
golang 命令详解github地址1. build 编译包和依赖项2. clean 删除对象文件和缓存的文件3. doc与godoc 显示包文档4. env 打印Go语言的环境信息5. fix与go tool fix 会把指定...【详细内容】
2023-05-20  Tags: golang  点击:(0)  评论:(0)  加入收藏
在生产环境中,如mysql数据库服务、rabbit-mq消息队列服务、redis缓存服务等。为了安全,这些服务的通常端口都是不对外网开放的。有时候,我们需要本地访问这些服务,要如何设置呢?...【详细内容】
2023-05-16  Tags: golang  点击:(23)  评论:(0)  加入收藏
Golang中的sync包实现了两种锁:互斥锁(Mutex)和读写锁(RWMutex)。互斥锁(sync.Mutex) 使用Lock方法加锁,使用Unlock方法解锁,Golang从1.18新增了TryLock方法,用于尝试获取锁,返回成功或...【详细内容】
2023-05-15  Tags: golang  点击:(21)  评论:(0)  加入收藏
作者:xindong本文针对Golang与Java的基础语法、结构体函数、异常处理、并发编程及垃圾回收、资源消耗等各方面的差异进行对比总结,有不准确、不到位的地方还请大家不吝赐教。...【详细内容】
2023-04-07  Tags: golang  点击:(47)  评论:(0)  加入收藏
在 Golang 中,要判断两个 slice 是否相等是不能直接使用 == 运算符的(== 只能说明 两个 slice 是否指向同一个底层数组)。如果两个 slice 的底层数组相同,但长度或容量不同,则仍...【详细内容】
2023-03-31  Tags: golang  点击:(65)  评论:(0)  加入收藏
前言大家好,我是星期八,是一个每天都要在镜子前给自己梳仅剩三根头发的三年码农本次我们来安排一下如何在win平台上配置Go语言开发环境。整体来说,Go配置环境还是挺轻松的,和Py...【详细内容】
2023-03-29  Tags: golang  点击:(60)  评论:(0)  加入收藏
rune类型在看一些开源项目的源代码时,经常看到rune类型的使用,本文就详细说下rune类型,首先看下golang源码的注释:// rune is an alias for int32 and is equivalent to int32 i...【详细内容】
2023-03-18  Tags: golang  点击:(38)  评论:(0)  加入收藏
这篇文章是Go语言学习资料的精髓,可以让你终身受益,汇集Golang各种资料的精髓,以下是一些初学者如何学习golang的方法和学习资料。如果你是新手,以下就是学习Golang的过程:1.了解...【详细内容】
2023-03-16  Tags: golang  点击:(25)  评论:(0)  加入收藏
▌简易百科推荐
0.1、索引https://waterflow.link/articles/16640805249861、未知的枚举值我们现在定义一个类型是unit32的Status,他可以作为枚举类型,我们定义了3种状态type Status uint32co...【详细内容】
2023-05-24  干饭人小羽    Tags:go语言   点击:(0)  评论:(0)  加入收藏
1. 引言反射是现代编程语言中非常重要的一个特性,尤其是在面向对象编程语言中此前的文章中,我们看到 golang 如何实现面向对象的封装: 通过 GoLang 实现面向对象思想如果能够...【详细内容】
2023-05-24  干饭人小羽  今日头条  Tags:golang   点击:(2)  评论:(0)  加入收藏
原型设计模式是面向对象编程中的一种设计模式,它的主要目的是通过复制现有对象来创建新对象,从而避免昂贵的对象创建过程,提高程序的性能和效率。原型设计模式包括深拷贝和浅拷...【详细内容】
2023-05-22  阿琪说    Tags:Go   点击:(3)  评论:(0)  加入收藏
在go语言中,数据类型分为**静态类型**和**底层类型**,感觉底层类型是golang实现的时候所使用的c语言的类型,而静态类型仅仅是针对于go语言本身而言所定义好的类型。具体的信息...【详细内容】
2023-05-20  干饭人小羽    Tags:golang   点击:(0)  评论:(0)  加入收藏
golang 命令详解github地址1. build 编译包和依赖项2. clean 删除对象文件和缓存的文件3. doc与godoc 显示包文档4. env 打印Go语言的环境信息5. fix与go tool fix 会把指定...【详细内容】
2023-05-20  干饭人小羽    Tags:golang   点击:(0)  评论:(0)  加入收藏
工厂模式是面向对象编程中的一种设计模式,它的主要目的是将对象的创建与使用分离开来,从而提高程序的可维护性和可扩展性。工厂模式包括工厂方法模式、抽象工厂模式和简单工厂...【详细内容】
2023-05-20  阿琪说    Tags:工厂模式   点击:(4)  评论:(0)  加入收藏
在遍历 Map 时,并不是固定地从 0 号 Bucket 开始遍历,每次都是从一个随机值序号的 Bucket 开始遍历,并且是从这个 Bucket 的一个随机序号的 Cell 开始遍历。Go 语言中的 map 是...【详细内容】
2023-05-19     AlwaysBeta  Tags:Go 语言   点击:(13)  评论:(0)  加入收藏
在生产环境中,如mysql数据库服务、rabbit-mq消息队列服务、redis缓存服务等。为了安全,这些服务的通常端口都是不对外网开放的。有时候,我们需要本地访问这些服务,要如何设置呢?...【详细内容】
2023-05-16  互联网解决方案服务  今日头条  Tags:golang   点击:(23)  评论:(0)  加入收藏
Go 语言中的 map 是一个非常常用的数据结构,它允许我们快速地存储和检索键值对。然而,在并发场景下使用 map 时,还是有一些问题需要注意的。本文将探讨 Go 语言中的 map 是否...【详细内容】
2023-05-15  AlwaysBeta  微信公众号  Tags:Go 语言   点击:(16)  评论:(0)  加入收藏
Golang中的sync包实现了两种锁:互斥锁(Mutex)和读写锁(RWMutex)。互斥锁(sync.Mutex) 使用Lock方法加锁,使用Unlock方法解锁,Golang从1.18新增了TryLock方法,用于尝试获取锁,返回成功或...【详细内容】
2023-05-15  路多辛  今日头条  Tags:Golang   点击:(21)  评论:(0)  加入收藏
站内最新
站内热门
站内头条