Go语言数据类型

1.01

已于 2022-12-25 21:27:41 修改

阅读量1.2k

点赞数

分类专栏： Go语言文章标签：开发语言

于 2022-07-02 23:53:38 首次发布

本文链接：https://blog.csdn.net/weixin_43743711/article/details/125570592

版权

Go语言专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1、布尔型

布尔型的值只可以是常量 true 或者 false。

var ok bool  = true

布尔型数据和整型数据不能进行相互转换；
声明的布尔型变量如不指定初始化值，默认是false。

var a bool //a is false

2、数字类型

整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。

整型：
Go语言内置了12种整数类型，如byte、int、int8、int16、int32（-2147483648 到 2147483647）、int64、uint、uint8、uint16、uint32、uint64、uintptr，这里特别注意不同类型的整型必须进行强制类型转换，其中byte相当于uint8。

var a int = 10
var b int64 = 20
b = a //错误

整型支持算术运算和位操作，算术表达式和位操作表达式的结果依旧是整型，如：

var a int = (2+3)*4
var b int = 1000>>3

浮点型：
Go语言内置了两种浮点数类型，为float32、float64

var b := 10.00  //浮点数字面量会被自动推断为float64类型

注意：计算机很难进行浮点数的精确表示和存储，不应该使用==或者!=进行比较操作，应该使用math标准库进行高精度科学计算。

复数类型：
Go语言内置的复数类型有两种，为complex64和complex128，其中前者是由两个float32构成的，后者是由两个float64构成的，复数在计算机里面使用两个浮点数表示，一个表示实部，一个表示虚部。

var valuel complex64 = 3.1 + 5i

//三个内置函数处理函数
var v = complex(2.2,4)   //构造一个复数
a := real(v)    //返回复数实部 
b := image(v)   //返回复数虚部

3、字符串类型:

字符串就是一串固定长度的字符连接起来的字符序列，是一个不可改变的字节序列，创建后不能再次修改。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。

Go语言中，字符串（string类型）是 UTF-8 字符的序列（当字符为 ASCII 码表上的字符时则占用 1 个字节，其它字符根据需要占用 2-4 个字节，汉字是三个字节）。

字符串数据结构
字符串在 Go 语言中的接口其实非常简单，每一个字符串在运行时都会使用如下的 reflect.StringHeader 表示，其中包含指向字节数组的指针和数组的大小：

type StringHeader struct {
	Data uintptr
	Len  int
}

与切片的结构体相比，字符串只少了一个表示容量的 Cap 字段，而正是因为切片在 Go 语言的运行时表示与字符串高度相似，所以我们经常会说字符串是一个只读的切片类型。

type SliceHeader struct {
	Data uintptr
	Len  int
	Cap  int
}

因为字符串作为只读的类型，我们并不会直接向字符串直接追加元素改变其本身的内存空间，所有在字符串上的写入操作都是通过拷贝实现的。

注意：

字符串尾部不包含NULL字符，这一点与C/C++不一样；

基于字符串创建的切片和原字符串指向相同的底层字符数组，一样不能修改，对字符串的切片操作返回的子串仍然是string，而非slice。

字符串和切片的转换：字符串可以转换为字节数组，也可以转换为Unicode的字节数组。如下：

a := "你好，世界！"
b := []byte(a)
c := []rune(a)

字符串修改的方法：

/*
修改字符串
注意：字符串是无法被修改的，只能复制原字符串，在复制的版本上修改，修改完成之后可以使用 string() 函数将其转为字符串即可
方法1：转换为[]byte()
方法2：转换为[]rune()
方法3：新字符串代替原字符串的子字符串,用strings包中的strings.Replace()
*/
func main() {
	//方法1
	s1 := "abcdefgabc"
	s2 := []byte(s1)
	s2[1] = 'B'
	fmt.Println(string(s2)) //aBcdefgabc
	//方法2
	s3 := []rune(s1)
	s3[1] = 'B'
	fmt.Println(string(s3)) //aBcdefgabc
	//方法3
	new := "ABC"
	old := "abc"
	s4 := strings.Replace(s1, old, new, 2)
	fmt.Println(s4) //ABCdefgABC
}

字符串遍历：

func main(){
	strChinese :="你好"
	for i:=0;i<len(strChinese) ;i++  {
		fmt.Printf("%d:[%c]\n",i,strChinese[i])
	}//fmt.Println(utf8.RuneCountInString(strChinese)) 输出长度

	//会遍历每一个字节，一个汉字为3个字节,相当于遍历字节数组
	
	for i,c:=range strChinese{
		fmt.Printf("%d:[%c]\n",i,c)
	}
	//相当于遍历rune数组
}

将字符串转为一个整数：

调用 strconv 包中的相关函数
可以使用字符串底层为 uint8 类型整数的这个特点通过 int，int64 或者其他函数将其转为整数，通过遍历整数类型的字符串可以发现得到的是对应字符的 ascii 值，将 ascii 值与 15 进行与运算就可以得到当前位对应的整数值，最终就可以得到字符串 s 对应的整数值：

package main
 
import "fmt"
 
func main() {
	// 在声明字符串s的时候使用":="快速初始化s
	s := "0123456789"
	// 使用索引遍历字符串
	for i := 0; i < len(s); i++ {
		// 使用Printf格式化输出
		fmt.Printf("%v ", s[i])
	}
	fmt.Println()
	s1 := "392932"
	n := 0
    // 将s1转位int类型整数
	for i := 0; i < len(s1); i++ {
		n = n*10 + int(s1[i]&15)
	}
	fmt.Printf("%v", n)
}

字符串常用操作：
主要是分隔字符串，判断是否存在某个子串，是否存在某个前缀或者某个后缀，找到某个子串第一次出现的位置，拼接字符串等操作，可以使用 Sprintf 来拼接字符串等

package main
 
import (
	"fmt"
	"strings"
)
 
func main() {
	// 1. len(str)获取字符串的长度
	s := "Hello World!"
	fmt.Println(len(s))
 
	// 2. strings.Split()按照分隔符切分字符串, 函数的返回值是按照分隔符切分之后的字符串切片
	s1 := "I am a student"
	s2 := strings.Split(s1, " ")
	for i := 0; i < len(s2); i++ {
		fmt.Print(s2[i], " ")
	}
	fmt.Println()
 
	// 3. Contains()判断字符串中是否包含子串substr
	fmt.Println(strings.Contains(s1, "am"))
 
	// 4. HasPrefix(),HasSuffix()判断是否包含前缀与后缀
	fmt.Println(strings.HasPrefix("abbbcas", "abb"))
	fmt.Println(strings.HasSuffix("abbbcas", "cas"))
 
	// 5. strings.Index()返回子串第一次出现的位置, 不存在返回-1
	// strings.LastIndex()返回子串最后一次出现的位置, 不存在返回-1
	s3 := "abbabbabbab"
	fmt.Println(strings.Index(s3, "abb"))
	fmt.Println(strings.LastIndex(s3, "abb"))
 
	// 6. join()对string切片的元素添加分隔符的操作, 返回的是添加分隔符之后的字符串
	s4 := []string{"I", "am", "a", "student"}
	fmt.Println(s4)
	fmt.Println(strings.Join(s4, " "))
}

[]byte以及[]rune类型：

byte 是uint8类型的别名，uint8 类型，代表了 ASCII 码的一个字符。Go语言字符串的底层是byte[]字节数组，在默认的utf-8编码中，英文字符占8位，一个字节，而中文是3个字节。

Go语言支持 Unicode（UTF-8），因此字符同样称为 Unicode 代码点或者 runes，并在内存中使用 int32 来表示。
rune在Go内部是int32类型的别名，占用4个字节；

在文档中，一般使用格式 U+hhhh 来表示，其中 h 表示一个 16 进制数。
在书写 Unicode 字符时，需要在 16 进制数之前加上前缀\u或者\U。
如果需要使用到 4 字节，则使用\u前缀，如果需要使用到 8 个字节，则使用\U前缀。

Unicode函数：
判断是否为字母：unicode.IsLetter(ch)
判断是否为数字：unicode.IsDigit(ch)
判断是否为空白符号：unicode.IsSpace(ch)

注意：

对于英文字符串，不管是用rune类型还是byte类型，不管是字符串的长度还是取值，都是相同的。
对于中文字符来说，rune类型的操作就比byte类型的操作更加友好很多，我们可以通过[:]操作直接取出中文的对应数量，而byte取出来却是乱码。

package main

import (
	"fmt"
)

func main() {
	testStr := "this is a test!"
	testStr1 := "这是一个测试"
	fmt.Println("The length of str is: ",len(testStr))
	fmt.Println("字符串长度为: ",len(testStr1))
}

The length of str is:  15
字符串长度为:  18

数据类型，点击查阅。

4、派生类型:

包括：指针类型（Pointer）、数组类型、结构化类型(struct)、Channel 类型
函数类型、切片类型、接口类型（interface）、Map 类型

切片类型：

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。实质上，切片就是变长数组。

结构：

type SliceHeader struct {
 
    Data uintptr //第一个是字符串指向的底层字节数组，
 
    Len int //第二个是字符串的字节的长度
 
    Cap int  //切片指向的内存空间的最大容量（对应元素的个数不是字节数）
 
}

声明方式：

var name [] T

T : 表切片元素类型，可以是整型、浮点型、布尔型、切片、map 、函数等。

切片的元素使用“ ［］ ”进行访问，在方括号中提供切片的索引即可访问元素，索引的范围从 0开始，且不超过切片的最大容量。

代码如下：

a := make([]int , 3,3) //创建一个长度为3,容量为3的整型切片。
 
a[0] = 1 //为切片元素赋值。

其他方式：

var (
 
    a []int // nil切片, 和 nil 相等, 一般用来表示一个不存在的切片
 
    b = []int{} // 空切片, 和 nil 不相等, 一般用来表示一个空的集合
 
    c = []int{1, 2, 3} // 有3个元素的切片, len和cap都为3
 
    d = c[:2] // 有2个元素的切片, len为2, cap为3
 
    e = c[0:2:cap(c)] // 有2个元素的切片, len为2, cap为3
 
    f = c[:0] // 有0个元素的切片, len为0, cap为3
 
    g = make([]int, 3) // 有3个元素的切片, len和cap都为3
 
    h = make([]int, 2, 3) // 有2个元素的切片, len为2, cap为3
 
    i = make([]int, 0, 3) // 有0个元素的切片, len为0, cap为3
 
)

函数操作：

内置函数len()返回切片长度
内置函数cap()返回切片底层数组容量
内置函数append()对切片追加元素
内置函数copy()用于复制一个切片

package main

import (
    "fmt"
)

func main() {
    //创建切片
    var number []int
    printSlice(number)

    //允许追加空切片
    number = append(number,0)
    printSlice(number)

    //向切片添加一个元素
    number = append(number,1)
    printSlice(number)

    //同时添加多个元素
    number = append(number,2,3,4)
    printSlice(number)

    //创建的新的切片是之前的切片容量的两倍
    number1 := make([]int,len(number),(cap(number))*2)

    //拷贝number的内容到number1中
    copy(number1,number)
    printSlice(number1)
}

func printSlice(x []int) {
    fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

指针类型：

一个指针变量指向了一个值的内存地址。

类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：

var var_name *var-type

var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。以下是有效的指针声明：

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

当一个指针被定义后没有分配到任何变量时，它的值为 nil；nil 指针也称为空指针；nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。

if(ptr == nil)    /* ptr 是空指针 */

注意：
Go语言同样支持多级指针 **var-type;

结构体指针访问结构体字段仍然用“ . ”点操作符，Go语言没有“->”操作符

Go语言支持垃圾回收，所以禁止指针运算，因为会给垃圾回收带来很多不便。

函数中允许返回局部变量的地址，因为Go编译器使用“栈逃逸”机制将这种局部变量的空间分配在堆上，如下：

func sum(a , b int) *int{
	sum := a + b
	return &sum  //允许，sum会被分配在heap上
}

其他：
Go 指针数组你可以定义一个指针数组来存储地址
Go 指向指针的指针 Go 支持指向指针的指针
Go 向函数传递指针参数通过引用或地址传参，在函数调用时可以改变其值
https://www.runoob.com/go/go-pointers.html

数组类型：

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。

数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。

声明方式：

var arr [2]int  //声明数组，元素默认值都为0

arr := [3]int{1,2,3} //指定长度和初始化字面量

arr := [...]int{1,2,3} //不指定长度，由后面的初始化列表数量来确定长度

arr := [3]int{1:1,2:3} //指定总长度，并通过索引值进行初始化，没有初始化元素时使用默认值

arr := [...]int{1:1,2:3} //不指定长度，通过索引值初始化，由最后的索引值确定长度

注意：

数组创建完长度就固定了，不可以再追加元素
数组是值类型的，数组赋值或作为函数参数都是值拷贝
数组长度是数组的组成部分，[10]int和[20]int表示不同的类型
可以根据数组创建切片

结构化类型(struct)

struct结构中的类型可以是任意类型；struct的存储空间是连续的，其中字段按照声明时的顺序存放（注意字段之间有对齐要求）

struct类型字面量：

struct {
	FileName FieldType
	FileName FieldType
	FileName FieldType
}

自定义struct类型：

type TypeName struct{
	FileName FieldType
	FileName FieldType
	FileName FieldType
}

struct初始化：

type Person struct{
	Name string 
	Age int
}

type Student struct{
	*Person
	Number int 
}

p := &Person{
	Name : "xxx",
	Age : 12,
}

s := Student{
	Person : p,
	Number : 110,
}

struct{}{}  //匿名struct初始化

点击查看struct文章！

map类型

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

map的类型格式是：map[K]T，其中K可以是任意可以进行比较的类型，T是值类型

创建方式：

使用字面量创建，如下：

ma := map[string]int{"a":1,"b":2}

使用内置的make函数创建，如下：

make(map[K]T)  //map的容量使用默认值
make(map[K]T,len) //map的容量使用给定的len值

ma := make(map[string]int,10)

操作方式：

访问格式：mapName[key]
删除格式：使用内置函数delete(mapName,key)
用range可以遍历map，但不保证顺序

mp := make(map[int]string)
mp[1] = "xxx"
mp[2] = "yyy"
delete (mp,1)

for k,v := range mp{
	...
}

注意：

Go内置的map不是并发安全的，并发安全的map可以使用标准包sync中的map
不要直接修改map value内某个元素的值，如果想修改map的某个键值，则必须整体赋值，想map中的value是结构体，如想修改结构体里的某值，则必须修改完后再将整个结构体赋值给map

Channel 类型

接口类型：

接口是一个编程规约，也是一组方法签名的集合。

接口内部存放的具体类型变量被称为接口指向的“实例”。

空接口：

由于空接口的方法集为空，所以任何类型都被认为实现了空接口，任意类型的实例都可以赋值或者传递给空接口，包括非命名类型的实例。

注意： 非命名类型由于不能定义自己的方法，所以方法集为空，因此其类型变量除了传递给空接口，不能传递给任何其他接口。

接口声明：

特点：

接口的命名一般以“er”结尾
接口定义的内部方法声明不需要func引导
在接口定义中，只有方法声明没有方法实现

接口字面量类型声明：

interface {
	MethodSignature1
	MethodSignature2
}

使用type关键字声明：

type InterfaceName interface{
	MethodSignature1
	MethodSignature2
}

可以内嵌匿名接口字段，就是一个接口定义里面包括其他接口，如下：

type  Reader interface{
	Read(p []byte)(n int,err error)
}

type ReadFinallyer interface{
	Reader 
}

接口初始化：

没有初始化的接口变量，其默认值是nil

实例赋值接口
如果具体类型实例的方法集是某个接口的方法集的超集，则称该具体类型实现了接口，可以将该具体类型的实例直接赋值给接口类型的变量。

接口变量赋值给接口变量
已经初始化的接口类型变量a直接赋值给另一种接口变量b，要求b的方法集是a的方法集的子集，此时接口变量b绑定的具体实例是接口变量a绑定的具体实例的副本。

type Printer interface{
	Print()
}

type s struct{}

func (s S) Print(){
	....
}

func main(){
	var i Printer
	i = S{}  //i = new(S)
	i.Print()
}

接口的动态类型和静态类型
动态类型：接口绑定的具体实例的类型称为接口的动态类型，接口可以绑定不同类型的实例，所以接口的动态类型是随着其绑定的不同类型实例而发生变化的

静态类型
在这里插入图片描述
类型断言：

类型查询：

空接口

Go语言的空接口有点像C语言中的void *，只不过void * 是指针，而Go语言的空接口内部封装了指针而已。

空接口组成（两个字段）：实例类型、指向绑定实例的指针

用途：Go语言没有泛型，如果一个函数需要接收任意类型的参数，则参数类型可以使用空接口类型，这是弥补没有泛型的一种手段。

空接口是反射的基础，后续知识再补充。

注意：当空接口的两个字段都为nil时，空接口才为nil