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

posted @ 2023-02-12 23:07 XIN-0808 阅读(350) 评论(0) 编辑收藏举报

刷新页面返回顶部

LI-XY

golang基本数据类型

1.整形

1.1 有符号（int）

1.2 无符号（unit）

1.3 其他整数类型

2.浮点型

3.布尔类型

4.字符类型

4.1 数字，字母，符号

4.2 汉字

4.3 转义字符

5. 字符串类型

5.1 字符串输出形式

5.2 字符串拼接

6.数据类型默认值

7.数据类型转换

7.1 基本数据类型转换

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

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

7.2.2 strconv包的函数

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

公告