golang基本数据类型

1.整形

• 默认整数类型为int
• 变量在选择时应遵循最小化原则

1.1 有符号（int）

类型	取值范围	占用空间（字节）
int8	-2^7到 2^7-1 （-128到127）	1
int16	-2^15到 2^15-1 （-32768到32767）	2
int32	-2^31到 2^31-1（-2147483648到2147483647）	4
int64	-2^63到 2^63-1 （-9223372036854775808到9223372036854775807）	8

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var a int8 = -10 //定义变量a为int8类型，值为-10
	fmt.Printf("a的类型为:%T\n", a)              //打印变量类型
	fmt.Println("占用字节数为:", unsafe.Sizeof(a)) //打印占用字节数
}

输出结果

a的类型为:int8
占用字节数为: 1

1.2 无符号（unit）

类型	取值范围	占用空间（字节）
uint8	0到2^8-1(0到255)	1
uint16	0到2^16-1（0到65535）	2
uint32	0到2^32-1（0到4294967295）	4
uint64	0到2^64-1（0到18446744073709551615）	8

package main

import "fmt"

func main() {
	var a uint8 = 256 //定义变量a为uint8类型，值为257
	fmt.Println(a) //打印a的值
}

输出结果

因为unit8的取值为0-255，a的值大于了255，所以报错溢出。

cannot use 256 (untyped int constant) as uint8 value in variable declaration (overflows)

1.3 其他整数类型

int：在32位操作系统等于int32，在64位操作系统等于int64

uint：在32位操作系统等于uint32，在64位操作系统等于uint64

rune：等于int32

byte：等于uint8

类型	取值范围	占用空间（字节）
int	32位：-2^31到 2^31-1（-2147483648到2147483647）	4
int	64位：-2^63到 2^63-1 （-9223372036854775808到9223372036854775807）	8
uint	32位：0到2^32-1（0到4294967295）	4
uint	64位：0到2^64-1（0到18446744073709551615）	8
rune	-2^31到 2^31-1（-2147483648到2147483647）	4
byte	0到2^8-1(0到255)	1

2.浮点型

float默认为float64。

float64比float32更精准。

类型	取值范围	占用空间（字节）
float32	-3.4e38到3.4e38	4
float64	-1.8e308到1.8e308	8

package main

import "fmt"

func main() {
	a := 0.5                    //定义a为浮点数
	fmt.Printf("a的类型为:%T\n", a) //输出a的数据类型
	var b float32 = 1.00000002  //定义b为float32
	fmt.Println("b的值为:", b)     //输出变量b的值
	var c float64 = 1.00000002  //定义b为float64
	fmt.Println("c的值为:", c)     //输出变量b的值
}

输出结果

a的类型为:float64
b的值为: 1
c的值为: 1.00000002

3.布尔类型

bool的值只有true和false

bool占用空间为1字节

boot一般用于流程判断

package main

import "fmt"

func main() {
	var f1 bool = 3 > 3
	fmt.Println(f1)
	var f2 bool = true
	fmt.Printf("f2的类型为:%T", f2)
}

输出结果

false
f2的类型为:bool

4.字符类型

• golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 byte 来保存。
• byte类型保存的范围为0-255，超过255的范围用int表示。
• byte类型默认输出为ASCII的码值。
• int类型默认输出的为Unicode的码值。
• 想显示对应的字符内容，必须采用格式化输出。

4.1 数字，字母，符号

package main

import "fmt"

func main() {
	var c1 byte = '9'       //输出为57
	var c2 byte = 'e'       //输出为101
	var c3 byte = '{'       //输出为123
	fmt.Println(c1, c2, c3) //默认输出的为
}

输出结果

57 101 123

输出结果对照ASCII码表的码值。

4.2 汉字

package main

import "fmt"

func main() {
	//var c4 byte = '李' //输出报错：cannot use '李' (untyped rune constant 26446) as byte value in variable declaration (overflows)
	//fmt.Println(c4)   //汉字‘李’，对应的码值为26446，byte类型只能表示0-255的码值，所以报错溢出。
	var c4 int = '李' //将byte类型改为int类型
	fmt.Println(c4)  //输出26446
	fmt.Printf("c4的值为:%c", c4) //格式化输出c4的值
}

输出结果

26446
c4的值为:李

查询UTF-8编码表：

http://www.mytju.com/classcode/tools/encode_utf8.asp

4.3 转义字符

使用转义字符’\’来将其后的字符转变为特殊字符。

符号	含义
\t	制表符（默认8个字符一个制表符）
\n	换行
\b	退格
\r	光标制动到最前面，然后替换后面的值
\	转义后面的符号

package main

import "fmt"

func main() {
	fmt.Println("012345\t6789") //输出结果为”012345  6789“，5后面有2个空格，补齐8位
	fmt.Println("012345\n6789")
	/*
		输出结果为
		012345
		6789
	*/
	fmt.Println("012345\b6789")  //输出结果为012346789，在5的时候退格，从6开始替换。
	fmt.Println("0123\r456789")  //输出结果为456789，在3的时候光标自动到0，从4开始替换。
	fmt.Println("012345\"67889") //输出结果为012345"67889，中间的“转义成常量输出。
}

输出结果

012345  6789
012345
6789
012346789
456789
012345"67889

5. 字符串类型

• 字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节链接起来的。
• Go语言的字符串的字节使用utf-8编码标识Unicode文本。
• 字符串一旦赋值了，其中的字符就不能修改了。在Go中字符串是不可变的。

5.1 字符串输出形式

package main

import "fmt"

func main() {
	// 没有特殊符号，直接输出。
	var s1 string = "li"
	fmt.Println("s1的值为：", s1)
	//有特殊符号
	//(1) 转义符\转义特殊符号输出。
	var s2 string = "li\"xin"
	fmt.Println("s2的值为：", s2)
	//（2）反引号`，直接输出反引号中的内容。
	var s3 string = `li"xin"`
	fmt.Println("s3的值为：", s3)
}

输出结果

s1的值为： li
s2的值为： li"xin
s3的值为： li"xin"

5.2 字符串拼接

package main

import "fmt"

func main() {
	//(1）少量字符串拼接
	var s4 string = "li" + "xin"
	fmt.Println("s4的值为：", s4)
	//(2)大量字符串拼接,拼接换行的时候+得留在最后
	var s5 string = "li" + "xin" +
		"yu"
	fmt.Println("s5的值为：", s5)
}

输出结果

s4的值为： lixin
s5的值为： lixinyu

6.数据类型默认值

类型	默认值
整数	0
浮点数	0
字符串	""
布尔	flase

package main

import "fmt"

func main() {
	var a int //定义一个整数类型a
	fmt.Println("整型a的默认值为: ", a)
	var b float32 //定义一个浮点类型b
	var c float64 //定义一个浮点类型c
	fmt.Println("浮点类型b的默认值为: ", b)
	fmt.Println("浮点类型c的默认值为: ", c)
	var d bool //定义一个布尔类型d
	fmt.Println("布尔型d的默认值为: ", d)
	var e string //定义一个字符串类型e
	fmt.Println("字符串类型e的默认值为:", e)
}

输出结果

整型a的默认值为:  0
浮点类型b的默认值为:  0
浮点类型c的默认值为:  0
布尔型d的默认值为:  false
字符串类型e的默认值为:

7.数据类型转换

• golang中不存在隐式类型转换，所有类型转换都必须显式的声明。
• 类型转换语法。
  
  表达式T(v)将值v转换为类型T。
  
  T : 就是数据类型。
  
  v : 就是需要转换的变量。

7.1 基本数据类型转换

package main

import "fmt"

func main() {
	var n1 int64 = 128       //定义n1变量为int64类型
	var n2 int32 = int32(n1) //将int64转为int32
	fmt.Println("n2的值为: ", n2)
	//n1的类型还是int64没变，只是将n1的值转为了int32
	fmt.Printf("n1的类型为:%T\n", n1)
	fmt.Printf("n2的类型为:%T\n", n2)

	//将int64转为int8
	var n3 int64 = 200        //定义变量n3的类型为int64，值为200
	var n4 int8 = int8(n3)    //将n3的值转为int8，赋值给n4
	fmt.Println("n4的值为:", n4) //由于int8的取值范围为-128到127，200大于int8的取值范围，所以虽然编译不会报错，但是数据会溢出

	var n5 int32 = 20             //定义变量n5的类型为int32
	var n6 int64 = int64(n5) + 20 //定义n6的类型为int64，将n5的值先转为int64，然后执行相加操作
	fmt.Println("n6的值为: ", n6)

	var n7 int64 = 20            //定义变量n5的类型为int64
	var n8 int8 = int8(n7) + 127 //定义n8的类型为int8，将n7的值先转为int8，然后执行相加操作
	fmt.Println("n8的值为: ", n8)   //编译不会报错，但是20+127=147超过了int8的取值范围，所以数据会溢出
	//var n9 int8 = int8(n7) + 128 //定义n9的类型为int8，将n7的值先转为int8，然后执行相加操作
	//fmt.Println("n9的值为: ", n9)   //编译报错“128 (untyped int constant) overflows int8”,因为128已经大于了int8的取值范围。

}

输出结果

n2的值为:  128
n1的类型为:int64
n2的类型为:int32
n4的值为: -56
n6的值为:  40
n8的值为:  -109

7.2 基本数据类型转为字符串类型

go语言标准库：https://studygolang.com/pkgdoc

7.2.1 fmt.Sprintf("%参数",表达式)方式

package main

import "fmt"

func main() {
	//整形转为字符串类型
	var n1 int = 10
	var s1 string = fmt.Sprintf("%d", n1)    //%d表示为十进制
	fmt.Printf("s1的类型为%T，s1的值为%q\n", s1, s1) //%T值的类型，%q，%t都为输出对应的值，但是%q会用双引号引起来。
	//浮点型转为字符串类型
	var n2 float32 = 1.1
	var s2 string = fmt.Sprintf("%f", n2) //%f表示有小数部分但无指数部分
	fmt.Printf("s2的类型为%T，s2的值为%q\n", s2, s2)
	//布尔转字符串类型
	var n3 bool = true
	var s3 string = fmt.Sprintf("%t", n3) //%t表示单词true或false
	fmt.Printf("s3的类型为%T，s3的值为%q\n", s3, s3)
	//字符类型转字符串
	var n4 byte = '{'
	var s4 string = fmt.Sprintf("%c", n4) //%c表示该值对应的unicode码值
	fmt.Printf("s4的类型为%T，s4的值为%q\n", s4, s4)
}

输出结果

s1的类型为string，s1的值为"10"
s2的类型为string，s2的值为"1.100000"
s3的类型为string，s3的值为"true"
s4的类型为string，s4的值为"{"

7.2.2 strconv包的函数

• func FormatBool(b bool) string (将bool转为string)
• func FormatInt(i int64, base int) string (将int转为string)
• func FormatUint(i uint64, base int) string (将uint转为string)
• func FormatFloat(f float64, fmt byte, prec, bitSize int) string (将float转为string)
  
  

package main

import (
	"fmt"
	"strconv"
)

func main() {
	//整形转为字符串类型
	var n1 int = 100
	//strconv.FormatInt需要传两个参数
	//第一个参数需要是int64类型的，所以需要转一下
	//第二个参数为需要转为什么进制的，取值为2-36
	var s1 string = strconv.FormatInt(int64(n1), 10)
	fmt.Printf("s1的类型为%T，s1的值为%q\n", s1, s1)
	//浮点型转为字符串类型
	var n2 float32 = 12.34
	//strconv.FormatFloat需要传两个参数
	//第一个参数需要是float64类型的，所以需要转一下
	/*
		第二个参数:
			'f'（-ddd.dddd,十进制）
			'b'（-ddddp±ddd，指数为二进制）
			'e'（-d.dddde±dd，十进制指数）
			'E'（-d.ddddE±dd，十进制指数）
			'g'（指数很大时用'e'格式，否则'f'格式）
			'G'（指数很大时用'E'格式，否则'f'格式）
	*/
	//第三个参数为保留的小数位
	//第四个参数为浮点型变量类型,64表示float64,32表示float32
	var s2 string = strconv.FormatFloat(float64(n2), 'f', 4, 64)
	fmt.Printf("s2的类型为%T，s2的值为%q\n", s2, s2)
	//bool转为字符串类型
	var n3 bool = true
	var s3 string = strconv.FormatBool(n3)
	fmt.Printf("s3的类型为%T，s3的值为%q\n", s3, s3)
}

输出结果

s1的类型为string，s1的值为"100"
s2的类型为string，s2的值为"12.3400"
s3的类型为string，s3的值为"true"

7.3 字符串类型转为基本数据类型

• func ParseBool(str string) (value bool, err error) (将字符串转为bool类型)
• func ParseInt(s string, base int, bitSize int) (i int64, err error) (将字符串转为int类型)
• func ParseUint(s string, base int, bitSize int) (n uint64, err error) (将字符串转为unit类型)
• func ParseFloat(s string, bitSize int) (f float64, err error) (将字符串转为float类型)
  
  

package main

import (
	"fmt"
	"strconv"
)

func main() {
	//字符串类型转整形
	var s1 string = "10"
	//第一个参数为字符串
	//第二个参数为需要转成的进制，取值为2-36
	//第三个参数表示结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64
	var n1 int64
	//ParseInt这个函数的返回值有两个：(i int64, err error)
	//i为转换的整形，err为转换的报错。
	//使用下划线（_）,忽略err的报错。
	n1, _ = strconv.ParseInt(s1, 10, 64)
	fmt.Printf("n1的类型为:%T,n1的值为：%v \n", n1, n1)
	//字符串类型转bool
	var s2 string = "true"
	var n2 bool
	n2, _ = strconv.ParseBool(s2)
	fmt.Printf("n2的类型为:%T,n2的值为：%v \n", n2, n2)
	//字符串类型转浮点型
	var s3 string = "123.456"
	var n3 float64
	//第一个参数为字符串
	//第二个参数为64是float64，32是float32（返回值可以不改变精确值的赋值给float32）。
	n3, _ = strconv.ParseFloat(s3, 64)
	fmt.Printf("n3的类型为:%T,n3的值为：%v \n", n3, n3)

	//string类型转为非有效数据类型
	var n4 string = "test"
	var b1 bool
	b1, _ = strconv.ParseBool(n4) //因为n4的值为test，非true或false，所以b1输出的为默认值false
	fmt.Printf("b1的类型为:%T,b1的值为：%v \n", b1, b1)
	var num1 int64
	num1, _ = strconv.ParseInt(n4, 10, 64) //因为n4的值为test，非整形，所以num1输出的为默认值0
	fmt.Printf("num1的类型为:%T,num1的值为：%v \n", num1, num1)
	var f1 float64
	f1, _ = strconv.ParseFloat(n4, 64) //因为n4的值为test，非浮点型，所以f1输出的为默认值0
	fmt.Printf("f1的类型为:%T,f1的值为：%v \n", f1, f1)
}

输出结果

n1的类型为:int64,n1的值为：10
n2的类型为:bool,n2的值为：true
n3的类型为:float64,n3的值为：123.456
b1的类型为:bool,b1的值为：false
num1的类型为:int64,num1的值为：0
f1的类型为:float64,f1的值为：0