Go语言内置数据类型详解-优快云博客

内置数据类型

布尔类型

bool

// Type.go
package main

import (
	"fmt"
)

func main() {
	var isGirl bool //声明bool类型变量isGirl
	isGirl = true   //isGirl赋值为true
	isGirl = false  //isGirl赋值为false

	if isGirl {
		fmt.Println("You are a girl!")
	} else {
		fmt.Println("You are a boy!")
	}
}

bool类型不能接受其他类型的赋值，不支持自动或强制的类型转换。

整型

int8
byte
int16
int
uint
uintptr

输入图片说明

int和int32被认为是两种不同的类型，编译器不会做隐式类型转换
两个不同类型的整型数不能直接比较，会有编译错误，如int32 和int64类型变量不能比较

##浮点类型

float32 等价于C语言的float类型
float64 等价于C语言的double类型

声明变量时如果使用类型自动推导，则浮点类型自动设为float64。如 fvar := 12.0 // 此时fvar变量类型为float64

复数类型

complex64
complex128

	var value1 complex64 //由2个float32构成的复数
	value1 = 3.2 + 12i

	value2 := 3.2 + 12i        //由2个float64构成的complex128类型
	value3 := complex(3.2, 12) //同value2

字符串

string

	var str string       //声明一个字符串变量
	str = "Hello World!" // 字符串赋值，注意字符串初始化后不能被修改
	ch := str[0]         // 取字符串第一个字符

	fmt.Printf("The length of \"%s\" is %d\n", str, len(str))     //使用len内置函数计算字符串长度
	fmt.Printf("The first character of \"%s\" is %c.\n", str, ch) //Printf函数用法与C语言printf一致

	var strA string = "Hello "
	var strB string = "Go!"
	var hiGo string = strA + strB //字符串拼接
	fmt.Printf("\"%s\" + \"%s\" = \"%s\"", strA, strB, hiGo)

	n := len(hiGo)
	for i := 0; i < n; i++ { // 字符串遍历
		ch := hiGo[i]
		fmt.Println(i, ch)
	}

字符类型

rune 代表单个Unicode字符

错误类型

error

指针

pointer

数组

array

	var byteArray [32]byte //长度为32的byte数组，每个元素为一个字节
	byteArray[0] = 'a'
	fmt.Println("byteArray values:", byteArray)

	var twoDimension [3][5]int // 二维数组
	twoDimension[0][0] = 10
	fmt.Println("twoDimension values:", twoDimension)

	//使用range遍历数组，range第一个返回值为元素下标，第二个返回值为元素值
	for i, v := range byteArray {
		fmt.Println("byteArray element[", i, "]=", v)
	}

可以使用len函数计算数组长度，len(array)
数组为值类型，即赋值和参数传递时将产生一次复制动作

切片

slice

func sliceDefineDemo() {
	var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	//基于已存在的数组创建切片
	var mySlice []int = myArray[:5] //取数组的前5个元素
	mySlice = myArray[:]            //取数组的全部元素
	mySlice = myArray[5:]           //取从第5个元素开始所有元素
	fmt.Print(mySlice)

	//直接创建数组切片，不需要依赖数组
	mySlice1 := make([]int, 5)       //创建初始元素个数为5的数组切片，元素初始值为0
	mySlice2 := make([]int, 5, 10)   //创建初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间
	mySlice3 := []int{1, 2, 3, 4, 5} //直接创建并初始化包含5个元素的数组切片
	fmt.Print(mySlice1)
	fmt.Print(mySlice2)
	fmt.Print(mySlice3)

	//根据数组切片创建数组切片
	oldSlice := []int{1, 2, 3, 4, 5}
	newSlice := oldSlice[:3] //基于oldSlice前3个元素构建新数组切片
	fmt.Print(newSlice)
}

func sliceOptDemo() {
	mySlice := make([]int, 5, 10)

	fmt.Println("len(mySlice):", len(mySlice)) //获取切片当前长度
	fmt.Println("cap(mySlice):", cap(mySlice)) //获取切片分配的存储空间

	mySlice = append(mySlice, 1, 2, 3) //给mySlice加上3个元素，这里重新生成了一个数组切片

	mySlice2 := []int{8, 9, 10}
	mySlice = append(mySlice, mySlice2...) //给mySlice加上另一个数组切片

	slice1 := []int{1, 2, 3, 4, 5}
	slice2 := []int{5, 4, 3}

	copy(slice2, slice1) //只会复制slice1的前3个元素到slice2中
	fmt.Println("slice2: ", slice2)
	copy(slice1, slice2) //只会复制slice2的前3个元素slice1的前3个位置
	fmt.Println("slice1: ", slice1)
}

直接定义数组切片与定义数组的区别是否指定长长度，指定长度为定义数组，不指定长度为定义切片
切片的遍历方式同数组
切片长度超过当前分配的存储空间时会自动分配一块足够大的内存

字典

func mapDemo() {
	var scoreMap map[string]int     // 声明scoreMap变量，存储学生的分数
	scoreMap = make(map[string]int) //创建scroreMap
	//scoreMap = make(map[string]int, 100) //创建scroreMap，第二个参数为map的存储空间

	/*创建并初始化map
	scoreMap = map[string] int{
		"ZhangSan":60,
		"LiSi":100
	}
	*/

	//Map中插入数据
	scoreMap["ZhangSan"] = 60
	scoreMap["LiSi"] = 100

	//删除数据
	delete(scoreMap, "ZhangSan") //如果该成员不存在，没有副作用

	//查找LiSi的分数
	studentScore, isFound := scoreMap["LiSi"]
	if isFound {
		fmt.Printf("Found LiSi's score: %d", studentScore)
	}
}