golang- 5数据类型（int类型和float类型）

最新推荐文章于 2024-03-02 10:05:39 发布
最新推荐文章于 2024-03-02 10:05:39 发布
阅读量869 收藏
点赞数
分类专栏： golang学习 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35983015/article/details/120446186
版权 
package main

import (
	"fmt"
	"unsafe"
)

func main()  {
	//有符号整数类型：int8-int16-int32-int64
	//占用字节空间	1	 2	   4	  8
	var n1,n2 int8 = -128,127
	fmt.Println(n1,n2) //打印int8类型取值范围
	fmt.Printf("取值范围的类型是：%T",n1) //打印类型
	fmt.Println()
	fmt.Println("打印函数类型占用字节数:",unsafe.Sizeof(n1)) //打印函数类型占用字节数
	fmt.Println("int8取值范围是：-128-127,超出这个范围就会报错：constant 128 overflows int8")
	fmt.Println()

	fmt.Println("-------------------------------------------------------------------")
	//int16
	var(
		n3,n4 int16 = -32768,32767
	)
	fmt.Println("int16的取值范围是：",n3,"-",n4)
	fmt.Printf("取值范围的类型是：%T",n3) //打印类型
	fmt.Println()
	fmt.Println("打印函数类型占用字节数是：",unsafe.Sizeof(n3),"个字节")//打印函数类型占用字节数

	fmt.Println("-------------------------------------------------------------------")
	//int32
	var(
		n5,n6 int32 = -2147483648,2147483647

	)
	fmt.Println("int32的取值范围是：",n5,"-",n6)
	fmt.Printf("取值范围的类型是：%T",n5)
	fmt.Println()
	fmt.Println("打印函数类型占用的字节数是：",unsafe.Sizeof(n5),"个字节")

	fmt.Println("-------------------------------------------------------------------")

	//int64
	var(
		n7,n8 int64 = -9223372036854775808,9223372036854775807

	)
	fmt.Println("int64的取值范围是：",n7,"-",n8)
	fmt.Printf("取值范围的类型是：%T",n7)
	fmt.Println()
	fmt.Println("打印函数类型占用的字节数是：",unsafe.Sizeof(n7),"个字节")

	fmt.Println("-------------------------------------------------------------------")

	//系统默认使用的是int类型
	var (
		test,test1 = -9223372036854775808,9223372036854775807
	)
	fmt.Printf("系统默认使用的自动类型推断为： %T %T",test,test1)
	fmt.Println()
	fmt.Println("取值范围跟int64一样",test,"-",test1)
	fmt.Println("-------------------------------------------------------------------")

	//无符号整数类型：uint8-uint16-uint32-uint64
	//占用字节空间	1	 2	   4	  8

	//uint8
	var(
		u1,u2 uint8 = 0,255
	)
	fmt.Println("uint8的取值范围是：",u1,"-",u2)
	fmt.Printf("取值的类型是：%T ",u1)
	fmt.Println()
	fmt.Println("打印函数类型占用字节数是：",unsafe.Sizeof(u1),"个字节")
	fmt.Println("-------------------------------------------------------------------")

	//uint16
	var(
		u3,u4 uint16 = 0,65535
	)
	fmt.Println("uint16的取值范围是：",u3,"-",u4)
	fmt.Printf("取值的类型是：%T ",u3)
	fmt.Println()
	fmt.Println("打印函数类型占用字节数是：",unsafe.Sizeof(u3),"个字节")
	fmt.Println("-------------------------------------------------------------------")

	//uint32
	var(
		u5,u6 uint32 = 0,4294967295
	)
	fmt.Println("uint32的取值范围是：",u5,"-",u6)
	fmt.Printf("取值的类型是：%T ",u5)
	fmt.Println()
	fmt.Println("打印函数类型占用字节数是：",unsafe.Sizeof(u5),"个字节")
	fmt.Println("-------------------------------------------------------------------")

	//uint64
	var(
		u7,u8 uint64 = 0,18446744073709551615
	)
	fmt.Println("uint64的取值范围是：",u7,"-",u8)
	fmt.Printf("取值的类型是：%T ",u7)
	fmt.Println()
	fmt.Println("打印函数类型占用字节数是：",unsafe.Sizeof(u7),"个字节")
	fmt.Println("-------------------------------------------------------------------")


	//浮点类型：float32和float64 简单来说就是小数
	//	占字节	4		8
	var(
		f1 float32 = 3.14
		f2 float32 = -3.14
		f3 float32 = 314e-2
		f4 float32 = 314E-2

		//浮点数中会出现精度丢失的情况，通常情况下，建议使用：float64
		f5 float32 = 256.00000000066
		f6 float64 = 256.00000000066

		//系统默认使用的也是float64
		ftest = 3.1400000064
	)
	fmt.Println("可以表示正浮点数：",f1,"|","也可以表示负浮点数：",f2)
	fmt.Println("浮点数不仅可以用十进制表示，还可以使用科学计数法表示：",f3,f4,"并且科学计数法并不区分大小写")
	fmt.Println("float32：",f5,"|","float64:",f6,"为了避免精度丢失还是建议使用float64")
	fmt.Printf("系统使用的默认浮点数类型：%T", ftest)


}

对应的运行结果

GOROOT=C:\Users\jingxie\go\go1.16.6 #gosetup
GOPATH=C:\Users\jingxie\go\go1.16.6;C:\Users\jingxie\go #gosetup
C:\Users\jingxie\go\go1.16.6\bin\go.exe build -o C:\Users\jingxie\AppData\Local\Temp\___go_build_golang__1_.exe "C:\Users\jingxie\go\src\golang\5.int and float.go" #gosetup
C:\Users\jingxie\AppData\Local\Temp\___go_build_golang__1_.exe #gosetup
-128 127
取值范围的类型是：int8
打印函数类型占用字节数: 1
int8取值范围是：-128-127,超出这个范围就会报错：constant 128 overflows int8

-------------------------------------------------------------------
int16的取值范围是： -32768 - 32767
取值范围的类型是：int16
打印函数类型占用字节数是： 2 个字节
-------------------------------------------------------------------
int32的取值范围是： -2147483648 - 2147483647
取值范围的类型是：int32
打印函数类型占用的字节数是： 4 个字节
-------------------------------------------------------------------
int64的取值范围是： -9223372036854775808 - 9223372036854775807
取值范围的类型是：int64
打印函数类型占用的字节数是： 8 个字节
-------------------------------------------------------------------
系统默认使用的自动类型推断为： int int
取值范围跟int64一样 -9223372036854775808 - 9223372036854775807
-------------------------------------------------------------------
uint8的取值范围是： 0 - 255
取值的类型是：uint8 
打印函数类型占用字节数是： 1 个字节
-------------------------------------------------------------------
uint16的取值范围是： 0 - 65535
取值的类型是：uint16 
打印函数类型占用字节数是： 2 个字节
-------------------------------------------------------------------
uint32的取值范围是： 0 - 4294967295
取值的类型是：uint32 
打印函数类型占用字节数是： 4 个字节
-------------------------------------------------------------------
uint64的取值范围是： 0 - 18446744073709551615
取值的类型是：uint64 
打印函数类型占用字节数是： 8 个字节
-------------------------------------------------------------------
可以表示正浮点数： 3.14 | 也可以表示负浮点数： -3.14
浮点数不仅可以用十进制表示，还可以使用科学计数法表示： 3.14 3.14 并且科学计数法并不区分大小写
float32： 256 | float64: 256.00000000066 为了避免精度丢失还是建议使用float64
系统使用的默认浮点数类型：float64
进程 已完成，退出代码为 0

总结：

//基础结构
package main

import (
	"fmt"
	"math"
)

func main()  {
	fmt.Println("int类型有符号的取值范围：")
	//fmt.Println("int:", math.MinInt, "~", math.MaxInt) 报错，没有 math.MinInt math.MaxInt
	fmt.Println("int8:", math.MinInt8, "~", math.MaxInt8)
	fmt.Println("int16:", math.MinInt16, "~", math.MaxInt16)
	fmt.Println("int32:", math.MinInt32, "~", math.MaxInt32)
	fmt.Println("int64:", math.MinInt64, "~", math.MaxInt64)
	fmt.Println("------------------------------------------")
	fmt.Println("int类型无符号的取值范围：")
	fmt.Println("uint8:", "0","~", math.MaxUint8)
	fmt.Println("uint16:","0","~", math.MaxUint16)
	fmt.Println("uint32:","0","~", math.MaxUint32)
	fmt.Println("uint64:","0","~","18446744073709551615")
	//fmt.Println("uint64:","0","~", math.MaxUint64) 这样打印不行 因为math.MaxUint64是一个常量，而不是uint64
	//num := math.MaxUint64
	//fmt.Printf("%d", uint64(num))
	fmt.Println()
	fmt.Println("--------------------------------------------")
	fmt.Println("float浮点数类型取值范围：")
	fmt.Println("float32的最小值为:",math.SmallestNonzeroFloat32,"|"," 最大值为:", math.MaxFloat32)
	fmt.Println("float64的最小值为:",math.SmallestNonzeroFloat64,"|"," 最大值为:", math.MaxFloat64)
	fmt.Println("--------------------------------------------")



}

输出结果：

GOROOT=C:\Users\jingxie\go\go1.16.6 #gosetup
GOPATH=C:\Users\jingxie\go\go1.16.6;C:\Users\jingxie\go #gosetup
C:\Users\jingxie\go\go1.16.6\bin\go.exe build -o C:\Users\jingxie\AppData\Local\Temp\___go_build_test_go.exe C:\Users\jingxie\go\src\golang\test.go #gosetup
C:\Users\jingxie\AppData\Local\Temp\___go_build_test_go.exe #gosetup
int类型有符号的取值范围：
int8: -128 ~ 127
int16: -32768 ~ 32767
int32: -2147483648 ~ 2147483647
int64: -9223372036854775808 ~ 9223372036854775807
------------------------------------------
int类型无符号的取值范围：
uint8: 0 ~ 255
uint16: 0 ~ 65535
uint32: 0 ~ 4294967295
uint64: 0 ~ 18446744073709551615

--------------------------------------------
float浮点数类型取值范围：
float32的最小值为: 1.401298464324817e-45 |  最大值为: 3.4028234663852886e+38
float64的最小值为: 5e-324 |  最大值为: 1.7976931348623157e+308
--------------------------------------------

进程 已完成，退出代码为 0

净邪
关注
专栏目录
golang--基本数据类型,big.Int类型,类型转换
weixin_42248522的博客
07-30 9570
nil 是 interface、function、pointer、map、slice 和 channel 类型变量的默认初始值 不可以用"=="比较类型： slice（切片）、map（key-value集合）、func（函数） map的比较可以使用reflect.DeepEqual() m1 := map[string]string{"one": "a", "two": "b"} m2 := map[string]string{"two": "b", "one": "a"} // 1.map类型
Golang-基本数据类型
qq_38473355的博客
02-23 277
Golang-基本数据类型 一、整形 类型 描述 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
golang数据类型转换（int/float/string/interface/[]byte）
运维玄德公
01-13 2392
文章目录1. int --> float322. 字串和数字的转换（strconv）2.1 string -->int2.2 string -->int642.3 string --> float642.4 int --> string2.5 int64 --> string2.6 float64 --> string 1. int --> float32 代码 package main import "fmt" func main() { va
go语言中的基本数据类型详解 int系列 float系列
sifeiwl的博客
03-23 481
如何在程序中查看某个变量的字节大小和数据类型 fmt.Printf("n1 的类型 %T，占用的字节数是 %d",n1,unsafe.Sizeof(n1))golang程序中整形变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。golang的浮点类型有固定的范围和字段长度，不受具体os（操作系统）的影响。golang各整数类型分：有符号和无符号，int uint的大小和系统有关。int8 第一位表示符号 后面7位表示数值 所以它的范围是-
uint 与 int 的区别 （golang语言）
热门推荐
莫克陶的blog
01-01 1万+
package main import ( "fmt" _ "time" ) func main() { a := byte(255) //11111111 这是byte的极限， 因为 a := byte(256)//越界报错， 0~255正好256个数，不能再高了 b := uint8(255) //11111111 这是uint8的极限，因为 c := uint8(256)//越
GoLang 整型
qq_62649563的博客
11-11 424
2.求字节- fmt.Println(unsafe.Sizeof(num1)) //输出其字节数。1.Printf和Println,前者是输出该变量的类型，后者是内容。3.使用原则："保小不保大"
golang-base
01-23
2. **基本数据类型**：Go语言提供了整型（`int`、`uint`）、浮点型（`float32`、`float64`）、字符串（`string`）、布尔型（`bool`）等基本类型，以及指针（`*T`）、数组（`[n]T`）、切片（`[]T`）和映射（`map[K]V`...
golang-cheat-sheet：Go语法和功能概述
02-04
3. 结构体：结构体是一组相关数据类型的集合，可以理解为自定义的复杂数据类型。 三、包与导入 Go语言的模块化设计基于包（package），每个源文件都属于一个包。使用`import`关键字引入其他包，如`import "fmt"`。...
Golang：基本数据类型的转换
保暖透气大裤衩LeoLee的博客
08-22 337
Golang与Java、C等其他语言不同，在不同的数据类型的变量之间赋值的时候，需要显式的转换，也就是说Golang中数据类型不能自动转换。不管是低精度到高精度，还是高精度到低精度，都需要显式的转换。 基本语法 表达式：T(v)，T为数据类型，v是需要转换的为V类型的变量。 示例 var i8 int8 = 100 var f32 float32 = float32(i8) fmt.Printf("f32=%f\n", f32) var i32 int32 = int32(i8) fmt.Prin
编程笔记 Golang基础 045 math包
明月看潮生的博客
03-02 1061
Go 语言的标准库math提供了一系列基础数学函数和常量，用于进行科学计算、几何计算和其他数学相关的操作。以下是一些math包中的核心功能和函数。
Golang中变量的数据类型
m0_56719679的博客
04-19 617
2）.反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击，输出源代码的效果。4.在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的码值。说明 ：1.如果我们保存的字符在ASCLL表的，比如[0-1，a-z，A-Z]直接可以保存到byte。6.字符类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。存储:字符-->对应码值--->二进制----->存储。读取:二进制-->码值---->字符---->读取。3.Go语言的字符使用UTF-8编码。
golang 浮点型
shulei00的博客
08-03 494
golang 字符型数据整理
Go语言浮点类型（小数类型）
xyz的专栏
09-04 869
Go语言提供了两种精度的浮点数 float32 和 float64，它们的算术规范由 IEEE754 浮点数国际标准定义，该浮点数规范被所有现代的 CPU 支持。 这些浮点数类型的取值范围可以从很微小到很巨大。浮点数取值范围的极限值可以在 math 包中找到： 常量 math.MaxFloat32 表示 float32 能取到的最大数值，大约是 3.4e38； 常量 math.MaxFloat64 表示 float64 能取到的最大数值，大约是 1.8e308； float32 和 float64 能
golang变量类型，转换方式，注意事项
m0_48186564的博客
09-08 1152
Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，例如： 整型和浮点型变量的默认值为0。1.字符串就是固定长度的字符连接起来的字符序列，Go的字符串是由当个字节连接起来的，go语言的字符串hi字节使用UTF-8。1.int有符号，的取值范围，和uint无符号的取值范围，默认是看计算机是几位，64位的话是占8个字节。5.Golang程序中，遵循保小不保大的原则，尽量使用占用空间小的数据类型。4.浮点型有固定的范围，字段长度，不受os（操作系统）的影响。
golang中int int8 int16 int32 int64 uint8 uint16 uint32 uint64 占用字节和取值范围
码二哥的技术池
12-05 1万+
本次测试的环境是Mac系统下，CPU 64位。 注意： go语言中的int的大小是和操作系统位数相关的； 如果是32位操作系统，int类型的大小就是4字节; 如果是64位操作系统，int类型的大小就是8个字节 1、测试不同int类型占用字节数大小 1.1、测试有符号int类型 import ( "testing" "unsafe" "math" "fmt" ) func TestIntSize(t *testing.T) { fmt.Println("不同int类型占用的字节数大小：")
Golang math 包下常用的一些方法
余念
04-12 1万+
package main import ( "fmt" "math" ) func main() { i := 1 fmt.Println(math.Abs(float64(i))) //取到绝对值 fmt.Println(math.Ceil(3.8)) //向上取整 fmt.Println(math.Floor(3.6)) //向下取整 fmt.Println(m...
Math.min()和Math.max()的使用
baidu_41904590的博客
10-25 1万+
Math.min()返回零个或更多个数值的最小值 1.返回给定数值中最小的数。如果任一参数不能转换为数值，则返回NaN。如果没有参数，结果为Infinity(无穷大)。 参数有效值：整数，浮点数，数字字符串。 参数无效值：非数字字符串，空变量，空数组(非数字)。 //正常使用 console.log(Math.min(-1, 4, 6, 12))；//输出值：-1 console.log(Math.min(1.23, 45, 6, 0.1));//输出值：0.1 console.log(Math.min("
golang中的基本数据类型和引用数据类型
最新发布
04-08
在Golang中，基本数据类型包括整型、浮点型、布尔型、字符串和字符型。引用数据类型包括数组、切片、映射、结构体和接口。 1. 整型：Golang提供了多种整型，包括int、int8、int16、int32、int64、uint、uint8、uint...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值