
Go语言中有丰富的数据类型,除了基本的整型、浮点型、布尔型、字符串外,还有数组、切片、结构体、函数、map、通道(channel)等。Go 语言的基本类型和其他语言大同小异。
整型
基本整型
类型 | 描述 |
uint8 | 无符号 8位整型 (0 到 255) |
uint16 | 无符号 16位整型 (0 到 65535) |
uint32 | 无符号 32位整型 (0 到 4294967295) |
uint64 | 无符号 64位整型 (0 到 18446744073709551615) |
int8 | 有符号 8位整型 (-128 到 127) |
int16 | 有符号 16位整型 (-32768 到 32767) |
int32 | 有符号 32位整型 (-2147483648 到 2147483647) |
int64 | 有符号 64位整型 (-9223372036854775808 到 9223372036854775807) |
特殊整型
类型 | 描述 |
uint | 32位操作系统上就是uint32,64位操作系统上就是uint64 |
int | 32位操作系统上就是int32,64位操作系统上就是int64 |
uintptr | 无符号整型,用于存放一个指针 |
数字字面量语法(Number literals syntax)
我们可以借助fmt函数来将一个整数以不同进制形式展示。
package main
import "fmt"
//整型
func main() {
var i1 = 101
//十进制
fmt.Printf("%d\n", i1)
fmt.Printf("%o\n", i1) //把十进制数转换成八进制
fmt.Printf("%x\n", i1) //把十进制数转换成十六进制
fmt.Printf("%b\n", i1) //把十进制数转换成二进制
// 八进制
i2 := 077
fmt.Printf("%d\n", i2)
//十六进制
i3 := 0x1234567
fmt.Printf("%d\n", i3)
//查看变量的类型
fmt.Printf("%T\n", i3)
//声明int8类型的变量
i4 := int8(9)
fmt.Printf("%T\n", i4)
}
浮点型
打印浮点数时,可以使用fmt包配合动词%f,代码如下:
package main
import "fmt"
//浮点型
func mian() {
// math.MaxFloat32 // float32
f1 := 1.23456
fmt.Printf("%T\n", f1) //默认go语言中的小数都是float64类型
f2 := float32(1.23456)
fmt.Printf("%T\n", f2) //显示声明float32类型
// f1 = f2 //floot32类型的值不能直接赋值给float64类型的变量
}
复数
complex64和complex128
var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)
复数有实部和虚部,complex64的实部和虚部为32位,complex128的实部和虚部为64位。
布尔值
Go语言中以bool类型进行声明布尔型数据,布尔型数据只有true(真)和false(假)两个值。
注意:
布尔类型变量的默认值为false。
Go 语言中不允许将整型强制转换为布尔型.
布尔型无法参与数值运算,也无法与其他类型进行转换。
package main
import "fmt"
//布尔值
func mian() {
b1 := true
var b2 bool
fmt.Printf("%T/n", b1)
fmt.Printf("%T value:%v\n", b2, b2)
}
字符串
Go语言中的字符串以原生数据类型出现,使用字符串就像使用其他原生数据类型(int、bool、float32、float64 等)一样。 Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(“)中的内容,可以在Go语言的源码中直接添加非ASCII码字符,例如:
//字符串
s := "Hello 你好"
//单独的字母、汉字、符号表示一个字符
c1 := 'h'
c2 := '1'
c3 := '你'
//字节: 1字节=8Bit(8个二进制位)
注意:go语言中的字符串是用双引号包裹的!!!
Go语言中单引号包裹的是字符!!
字符串转义符
Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等,如下表所示。
转义符 | 含义 |
\r | 回车符(返回行首) |
\n | 换行符(直接跳到下一行的同列位置) |
\t | 制表符 |
\’ | 单引号 |
\” | 双引号 |
\\ | 反斜杠 |
举个例子,我们要打印一个Windows平台下的一个文件路径:
package main
import "fmt"
func main() {
// \ 本来是具有特殊的含义的,我应该告诉程序我写的就是一个单纯的\
path1 := "\"D:\\GO\\src\\adminxe.com\\MoCoCN\\day01\""
fmt.Println(path1)
path2 := "'D:\\GO\\src\\adminxe.com\\MoCoCN\\day01'"
fmt.Println(path2)
}

多行字符串
Go语言中要定义一个多行字符串时,就必须使用反引号”`”
字符
// 多行的字符串
s2 := `
你说林深见鹿
亦可自度
後来清晨见雾
你未留住
`
fmt.Println(s2)
s3 := `D:\GO\\src\adminxe.com\MoCoCN\day01`
fmt.Println(s3)

反引号间换行将被作为字符串中的换行,但是所有的转义字符均无效,文本将会原样输出。
字符串的常用操作
方法 | 介绍 |
len(str) | 求长度 |
+或fmt.Sprintf | 拼接字符串 |
strings.Split | 分割 |
strings.contains | 判断是否包含 |
strings.HasPrefix,strings.HasSuffix | 前缀/后缀判断 |
strings.Index(),strings.LastIndex() | 子串出现的位置 |
strings.Join(a[]string, sep string) | join操作 |
求长度
//求长度
fmt.Println(len(s3))
拼接字符串
//字符串拼接
name := "MoCo"
world := "yyds"
ss := name + world
fmt.Println(ss)
ss1 := fmt.Sprintf("%s%s", name, world)
fmt.Println(ss1)
fmt.Printf("%s%s", name, world)
分割
//分割
ret := strings.Split(s3, "\\")
fmt.Println(ret)
判断是否包含
//包含
fmt.Println(strings.Contains(ss, "mocc"))
fmt.Println(strings.Contains(ss, "MoCo"))
前缀/后缀判断
//前缀
fmt.Println(strings.HasPrefix(ss, "MoCo"))
//后缀
fmt.Println(strings.HasSuffix(ss, "MoCo"))
子串出现的位置
//字串出现的位置
s4 := "abcdeb"
fmt.Println(strings.Index(s4, "c")) //C在这个字符串里出现的位置
fmt.Println(strings.LastIndex(s4, "b")) //b在这个字符串里最后出现的位置
join操作
//join拼接
fmt.Println(strings.Join(ret, "+"))
代码运行截图

byte和rune类型
组成每个字符串的元素叫做“字符”,可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号(’)包裹起来,如:
var a = '中'
var b ='x'
Go 语言的字符有以下两种:
uint8
类型,或者叫 byte 型,代表了ASCII
码
的一个字符。rune
类型,代表一个UTF-8
字符
。
当需要处理中文、日文或者其他复合字符时,则需要用到rune
类型。rune
类型实际是一个int32
。
Go 使用了特殊的 rune 类型来处理 Unicode,让基于 Unicode 的文本处理更为方便,也可以使用 byte 型进行默认字符串处理,性能和扩展性都有照顾。
package main
import "fmt"
// 遍历字符串
func main() {
s := "hello 你好"
for i := 0; i < len(s); i++ { //byte
fmt.Printf("%v(%c) ", s[i], s[i])
}
fmt.Println()
for _, r := range s { //rune
fmt.Printf("%v(%c) ", r, r)
}
fmt.Println()
}

修改字符串
要修改字符串,需要先将其转换成[]rune
或[]byte
,完成后再转换为string
。无论哪种转换,都会重新分配内存,并复制字节数组。
s5 := "白萝卜"
s6 := []rune(s5) // 把字符串强制转换成了一个rune切片
s6[0] = '红'
fmt.Println(string(s6)) // 把rune切片强制转换成字符串
c1 := "红"
c2 := '红' // rune(int32)
fmt.Printf("c1:%T c2:%T\n", c1, c2)
c3 := "H" //string
c4 := 'H' //int32
c5 := byte('H') // byte(uint8)
fmt.Printf("c3:%T c4:%T\n", c3, c4)
fmt.Printf("%d\n", c4)
fmt.Printf("c5:%T\n", c5)

字符串练习笔记代码(除byte和rune类型)
package main
import (
"fmt"
"strings"
)
func main() {
// \ 本来是具有特殊的含义的,我应该告诉程序我写的就是一个单纯的\
path1 := "\"D:\\GO\\src\\adminxe.com\\MoCoCN\\day01\""
fmt.Println(path1)
path2 := "'D:\\GO\\src\\adminxe.com\\MoCoCN\\day01'"
fmt.Println(path2)
// 多行的字符串
s2 := `
你说林深见鹿
亦可自度
後来清晨见雾
你未留住
`
fmt.Println(s2)
s3 := `D:\GO\\src\adminxe.com\MoCoCN\day01`
fmt.Println(s3)
//字符串相关操作
//求长度
fmt.Println(len(s3))
//字符串拼接
name := "MoCo"
world := "yyds"
ss := name + world
fmt.Println(ss)
ss1 := fmt.Sprintf("%s%s", name, world)
fmt.Println(ss1)
fmt.Printf("%s%s", name, world)
//分割
ret := strings.Split(s3, "\\")
fmt.Println(ret)
//包含
fmt.Println(strings.Contains(ss, "mocc"))
fmt.Println(strings.Contains(ss, "MoCo"))
//前缀
fmt.Println(strings.HasPrefix(ss, "MoCo"))
//后缀
fmt.Println(strings.HasSuffix(ss, "MoCo"))
//字串出现的位置
s4 := "abcdeb"
fmt.Println(strings.Index(s4, "c")) //C在这个字符串里出现的位置
fmt.Println(strings.LastIndex(s4, "b")) //b在这个字符串里最后出现的位置
//join拼接
fmt.Println(strings.Join(ret, "+"))
//字符串修改
s5 := "白萝卜"
s6 := []rune(s5) // 把字符串强制转换成了一个rune切片
s6[0] = '红'
fmt.Println(string(s6)) // 把rune切片强制转换成字符串
c1 := "红"
c2 := '红' // rune(int32)
fmt.Printf("c1:%T c2:%T\n", c1, c2)
c3 := "H" //string
c4 := 'H' //int32
c5 := byte('H') // byte(uint8)
fmt.Printf("c3:%T c4:%T\n", c3, c4)
fmt.Printf("%d\n", c4)
fmt.Printf("c5:%T\n", c5)
//类型转换
//只有整型和浮点型可以相互转换,字符串和切片能互相转换
n1 := 10 //int
var f float64
f = float64(n1)
fmt.Println(f)
fmt.Printf("%T\n", f)
}
byte和rune类型练习笔记代码
package main
import "fmt"
// 遍历字符串
func main() {
s := "hello 你好"
for i := 0; i < len(s); i++ { //byte
fmt.Printf("%v(%c) ", s[i], s[i])
}
fmt.Println()
for _, r := range s { //rune
fmt.Printf("%v(%c) ", r, r)
}
fmt.Println()
}
类型转换
Go语言中只有强制类型转换,没有隐式类型转换。该语法只能在两个类型之间
//类型转换
//只有整型和浮点型可以相互转换,字符串和切片能互相转换
n1 := 10 //int
var f float64
f = float64(n1)
fmt.Println(f)
fmt.Printf("%T\n", f)
参考链接
https://www.liwenzhou.com/posts/Go/02_datatype/
转载请注明:Adminxe's Blog » GO语言学习–基本数据类型