go的基本数据类型「你怎么可以搞特殊化,有别于其它语言」

浏览提示:
   1字节 = 8位
   本机为 64 位计算机

数字类型

无符号整型
类型 描述 占用存储空间 范围
uint 无符号的整型 取决于计算机的位数 取决于计算机的位数
uint8 无符号 8 位整型 1字节 0 ~ 255
uint16 无符号 16 位整型 2字节 0 ~ 65535
uint32 无符号 32 位整型 4字节 0 ~ 4294967295
uint64 无符号 64 位整型 8字节 0 ~ 18446744073709551615

查看默认初始值

package main

import (
	"fmt"
	"unsafe"
)

func main(){

	// 声明无符号类型,查看默认初始值
	var(
		uintEight uint8
		uintSixteen uint16
		uintThirtyTwo uint32
		uintSixtyFour uint64
		uintDefault uint
	)
	fmt.Println("uintEight:",uintEight)
	fmt.Println("uintSixteen:",uintSixteen)
	fmt.Println("uintThirtyTwo:",uintThirtyTwo)
	fmt.Println("uintSixtyFour:",uintSixtyFour)
	fmt.Println("uintDefault:",uintDefault)

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

	fmt.Println("本机器默认的 uint 属于哪个:")
	fmt.Println("uintEight 占用的存储空间:", unsafe.Sizeof(uintEight))
	fmt.Println("uintSixteen 占用的存储空间:", unsafe.Sizeof(uintSixteen))
	fmt.Println("uintThirtyTwo 占用的存储空间:", unsafe.Sizeof(uintThirtyTwo))
	fmt.Println("uintSixtyFour 占用的存储空间:", unsafe.Sizeof(uintSixtyFour))
	fmt.Println("uintDefault 占用的存储空间:", unsafe.Sizeof(uintDefault))

}
/*
输出内容:
		uintEight: 0
		uintSixteen: 0
		uintThirtyTwo: 0
		uintSixtyFour: 0
		uintDefault: 0
		-------------------------
		本机器默认的 uint 属于哪个:
		uintEight 占用的存储空间: 1
		uintSixteen 占用的存储空间: 2
		uintThirtyTwo 占用的存储空间: 4
		uintSixtyFour 占用的存储空间: 8
		uintDefault 占用的存储空间: 8
*/

有符号整型
类型 描述 占用存储空间 范围
int 有符号的整型 取决于计算机的位数 取决于计算机的位数
int8 有符号 8 位整型 1字节 -128 ~ 127
int16 有符号 16 位整型 2字节 -32768 ~ 32767
int32 有符号 32 位整型 4字节 -2147483648 ~ 2147483647
int64 有符号 64 位整型 8字节 -9223372036854775808 ~ 9223372036854775807

查看默认值

package main

import (
	"fmt"
	"unsafe"
)

func main(){

	// 有符号类型,查看默认初始值
	var(
		intEight int8
		intSixteen int16
		intThirtyTwo int32
		intSixtyFour int64
		intDefault int
	)
	fmt.Println("intEight:",intEight)
	fmt.Println("intSixteen:",intSixteen)
	fmt.Println("intThirtyTwo:",intThirtyTwo)
	fmt.Println("intSixtyFour:",intSixtyFour)
	fmt.Println("intDefault:",intDefault)

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

	fmt.Println("本机器默认的 int 属于哪个:")
	fmt.Println("intEight 占用的存储空间:", unsafe.Sizeof(intEight))
	fmt.Println("intSixteen 占用的存储空间:", unsafe.Sizeof(intSixteen))
	fmt.Println("intThirtyTwo 占用的存储空间:", unsafe.Sizeof(intThirtyTwo))
	fmt.Println("intSixtyFour 占用的存储空间:", unsafe.Sizeof(intSixtyFour))
	fmt.Println("intDefault 占用的存储空间:", unsafe.Sizeof(intDefault))

}

/*
输出内容:
		intEight: 0
		intSixteen: 0
		intThirtyTwo: 0
		intSixtyFour: 0
		intDefault: 0
		-------------------------
		本机器默认的 int 属于哪个:
		intEight 占用的存储空间: 1
		intSixteen 占用的存储空间: 2
		intThirtyTwo 占用的存储空间: 4
		intSixtyFour 占用的存储空间: 8
		intDefault 占用的存储空间: 8

*/

某些整型的别名

类型 别名
byte unit8
rune int32

查看默认值

package main

import (
	"fmt"
	"unsafe"
)

func main(){

	var (
		byteTest byte
		runeTest rune
	)
	//默认值
	fmt.Println("byteTest 的默认值:", byteTest)
	fmt.Println("runeTest 的默认值:", runeTest)

	//所占存储空间
	fmt.Println("-------------------",)
	fmt.Println("byteTest 所占存储空间", unsafe.Sizeof(byteTest))
	fmt.Println("runeTest 所占存储空间", unsafe.Sizeof(runeTest))
}
/*
输出内容:
		byteTest 的默认值: 0
		runeTest 的默认值: 0
		-------------------
		byteTest 所占存储空间 1
		runeTest 所占存储空间 4
*/

补充说明:
   byte 常用来处理 ASCII 字符
   rune 常用来处理 unicode 或 utf-8 字符 ,它用来区分字符型和整型值

用类型推断,来确定字符的输出类型是什么

package main

import (
	"fmt"
	"reflect"
)

func main(){

	testType := 'A'
	//reflect.TypeOf():可以查看变量的类型
	fmt.Println("testType 的类型为 ", reflect.TypeOf(testType)) 

}
/*

输出为:testType 的类型为  int32

*/

浮点数
类型 描述
float32 32位浮点型数 ,单精度
float64 64位浮点型数,双精度
complex64 32 位实数和虚数
complex128 64 位实数和虚数

查看默认值

package main

import "fmt"

func main(){

	var(
		testFloat32 float32
		testFloat64 float64
	)
	fmt.Println("testFloat32 的默认值为:", testFloat32)
	fmt.Println("testFloat64 的默认值为:", testFloat64)

}
/*
输出内容
		testFloat32 的默认值为: 0
		testFloat64 的默认值为: 0
*/

利用类型推断,查看数字属于哪个精度

在这里,我测试了小数点后有1位、2位、3位…,测试出来的结果都是 float64,不知道是否与我个人的 64 计算机有关,如果你是 32 位计算机,可测试看,是否会编程 float32

package main

import (
	"fmt"
	"reflect"
)

func main(){

	testWhichIs1 := 1.1
	testWhichIs2 := 1.11
	testWhichIs3 := 1.111
	testWhichIs4 := 1.1111
	testWhichIs5 := 1.11111

	fmt.Println("testWhichIs1 的类型为:",reflect.TypeOf(testWhichIs1))
	fmt.Println("testWhichIs2 的类型为:",reflect.TypeOf(testWhichIs2))
	fmt.Println("testWhichIs3 的类型为:",reflect.TypeOf(testWhichIs3))
	fmt.Println("testWhichIs4 的类型为:",reflect.TypeOf(testWhichIs4))
	fmt.Println("testWhichIs5 的类型为:",reflect.TypeOf(testWhichIs5))

}
/*
输出内容
		testWhichIs1 的类型为: float64
		testWhichIs2 的类型为: float64
		testWhichIs3 的类型为: float64
		testWhichIs4 的类型为: float64
		testWhichIs5 的类型为: float64
*/

字符串型

类型 描述
String 存储以 " " 的内容,一经声明,不可更改

查看默认值

package main

import "fmt"

func main(){

	var testString string
	
	fmt.Println("String 的默认值是否是空字符串:", testString == "")


}
/*
输出内容:
	String 的默认值是否是空字符串: true
*/


欢迎大家关注下个人的「公众号」:独醉贪欢

猜你喜欢

转载自blog.csdn.net/weixin_41640994/article/details/105153730