【go基础】基本数据类型

1.数值型

1.1整数类型：(u)int ,(u)int 8,(u)int 16,(u)int 32,(u)int 64,byte(uint 8),rune(int 32)

1. Golang 各整数类型分：有符号和无符号，int uint 的大小和系统有关
2. Golang 的整型默认声明为 int 型
3. 在程序查看某个变量的字节大小和数据类型

//如何在程序查看某个变量的占用字节大小和数据类型 
	var n2 int64 = 10
	//unsafe.Sizeof(n1) 是unsafe包的一个函数，可以返回n1变量占用的字节数
	fmt.Printf("n2 的 类型 %T  n2占用的字节数是 %d ", n2, unsafe.Sizeof(n2))

整型使用实例

package main
// import "fmt"
// import "unsafe"
import (
	"fmt"
	"unsafe"
)

//演示golang中整数类型使用
func main() {
	
	var i int = 1
	fmt.Println("i=", i)

	//测试一下int8的范围 -128~127,
	//其它的 int16, int32, int64,类推。。。
	var j int8 = 127
	fmt.Println("j=", j)

	//测试一下 uint8的范围(0-255),其它的 uint16, uint32, uint64类推即可
	var k uint16 = 255
	fmt.Println("k=", k)

	//int , uint , rune , byte的使用
	var a int = 8900
	fmt.Println("a=", a)
	var b uint = 1
	var c byte = 255
	fmt.Println("b=", b, "c=", c)

	//整型的使用细节
	var n1 = 100 // ? n1 是什么类型
	//这里我们给介绍一下如何查看某个变量的数据类型
	//fmt.Printf() 可以用于做格式化输出。
	fmt.Printf("n1 的 类型 %T \n", n1)


	//如何在程序查看某个变量的占用字节大小和数据类型 （使用较多）
	var n2 int64 = 10
	//unsafe.Sizeof(n1) 是unsafe包的一个函数，可以返回n1变量占用的字节数
	fmt.Printf("n2 的 类型 %T  n2占用的字节数是 %d ", n2, unsafe.Sizeof(n2))
}

结果示例

i= 1
j= 127                               
k= 255                               
a= 8900                              
b= 1 c= 255                          
n1 的 类型 int                       
n2 的 类型 int64  n2占用的字节数是 8 

1.2浮点类型 float32，float64

1. 浮点数在机器中存放形式：浮点数=符号位+指数位+尾数位
2. 浮点数都是有符号的
3. 尾数部分可能丢失，造成精度损失。 -123.0000901

	var num3 float32 = -123.0000901
	var num4 float64 = -123.0000901
	fmt.Println("num3=", num3, "num4=", num4)

结果

	num3= -123.00009 num4= -123.0000901   

4. Golang 的浮点型默认声明为float64 类型

package main
import (
	"fmt"
	"unsafe"
)

//演示golang中小数类型使用
func main() {

	var price float32 = 89.12
	fmt.Println("price=", price)
	var num1 float32 = -0.00089
	var num2 float64 = -7809656.09
	fmt.Println("num1=", num1, "num2=", num2)

	//尾数部分可能丢失，造成精度损失。 -123.0000901
	var num3 float32 = -123.0000901
	var num4 float64 = -123.0000901
	fmt.Println("num3=", num3, "num4=", num4)
	// num3= -123.00009 num4= -123.0000901    

	//Golang 的浮点型默认声明为float64 类型
	var num5 = 1.1
	fmt.Printf("num5的数据类型是 %T \n", num5)


	//十进制数形式：如：5.12       .512   (必须有小数点）
	num6 := 5.12
	num7 := .123 //=> 0.123
	fmt.Println("num6=", num6, "num7=", num7)

	//科学计数法形式
	num8 := 5.1234e2 // ? 5.1234 * 10的2次方
	num9 := 5.1234E4 // ? 5.1234 * 10的2次方 shift+alt+向下的箭头
	num10 := 5.1234E-2 // ? 5.1234 / 10的2次方 0.051234
	
	fmt.Println("num8=", num8, "num9=", num9, "num10=", num10)
}

结果输出

price= 89.12
num1= -0.00089 num2= -7.80965609e+06     
num3= -123.00009 num4= -123.0000901      
num5的数据类型是 float64                 
num6= 5.12 num7= 0.123                   
num8= 512.34 num9= 512.34 num10= 0.051234

1.4 复数类型 complex

2.字符型 byte

Golang 中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 byte 来保存。
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而 Go 的字符串不同，它是由字节组成的。

1. 如果我们保存的字符在 ASCII 表的,比如[0-1, a-z,A-Z…]直接可以保存到 byte
2. 如果我们保存的字符对应码值大于 255,这时我们可以考虑使用 int 类型保存
3. 如果我们需要按照字符的方式输出，这时我们需要格式化输出，即 fmt.Printf(“%c”, c1)
4. 字符常量是用单引号(‘’)括起来的单个字符。例如：var c1 byte = ‘a’ var c2 int = ‘中’ var c3 byte = ‘9’

package main
import (
	"fmt"
)

//演示golang中字符类型使用
func main() {

	var c1 byte = 'a'
	var c2 byte = '0' //字符的0

	//当我们直接输出byte值，就是输出了的对应的字符的码值
	// 'a' ==> 
	fmt.Println("c1=", c1)    //c1= 97
	fmt.Println("c2=", c2)    //c2= 48
	//如果我们希望输出对应字符，需要使用格式化输出
	fmt.Printf("c1=%c c2=%c\n", c1, c2)   
	//c1=a c2=0 

	//var c3 byte = '北' //overflow溢出
	var c3 int = '北' //overflow溢出
	fmt.Printf("c3=%c c3对应码值=%d\n", c3, c3)  
	//c3=北 c3对应码值=21271

	//可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode 字符
	var c4 int = 22269 // 22269 -> '国' 120->'x'
	fmt.Printf("c4=%c\n", c4)
	//c4=国 

	//字符类型是可以进行运算的，相当于一个整数,运输时是按照码值运行
	var n1 = 10 + 'a' //  10 + 97 = 107
	fmt.Println("n1=", n1)
	//n1= 107 
}

字符类型本质探讨

1. 字符型 存储到 计算机中，需要将字符对应的码值（整数）找出来存储：
   字符—>对应码值 >二进制–>存储
   读取：二进制----> 码值 ----> 字符 --> 读取
2. 字符和码值的对应关系是通过字符编码表决定的(是规定好)
3. Go 语言的编码都统一成了 utf-8。非常的方便，很统一，再也没有编码乱码的困扰了

3.字符串类型

1. 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本
2. 字符串的两种表示形式
   (1) 双引号, 会识别转义字符

str2 := "abc\nabc"
	fmt.Println(str2)

abc                                                               
abc    

(2) 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果

	
	//使用的反引号 `
	str3 := ` 
	package main
	import (
		"fmt"
		"unsafe"
	)
	
	//演示golang中bool类型使用
	func main() {
		var b = false
		fmt.Println("b=", b)
		//注意事项
		//1. bool类型占用存储空间是1个字节
		fmt.Println("b 的占用空间 =", unsafe.Sizeof(b) )
		//2. bool类型只能取true或者false
		
	}
	`
	fmt.Println(str3)

原样输出

3. 字符串拼接方式

	var str = "hello " + "world"
	str += " haha!"
	fmt.Println(str)
	//hello world haha!    

5. 当一行字符串太长时，需要使用到多行字符串，需要将+保留在上一行.

	str4 := "hello " + "world" + "hello " + "world" + "hello " + 
	"world" + "hello " + "world" + "hello " + "world" + 
	"hello " + "world"
	fmt.Println(str4)
	//hello worldhello worldhello worldhello worldhello worldhello world

6. 字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的

	var str = "hello"
	str[0] = 'a' //err  这里就不能去修改str的内容，即go中的字符串是不可变的。

4.布尔型

1. 布尔类型也叫 bool 类型，bool 类型数据只允许取值 true 和 false
2. bool 类型占 1 个字节。
3. bool 类型适于逻辑运算，一般用于程序流程控制

5.rune的用法

在Go语言中，rune是int32类型的别名，代表一个Unicode码点。当处理包含多种语言和脚本字符的文本数据时，rune是常用的类型。以下是在Go中使用rune的方法：

1. 声明一个rune变量：

var r rune = 'a'

在此示例中，我们声明一个rune类型的变量r并将小写字母’a’的Unicode码点分配给它。

2. 将字符串转换为rune片段：

str := "Hello, 世界"
runes := []rune(str)

在此示例中，我们声明一个包含英文单词“Hello”和汉字“世界”的字符串str。然后，我们使用内置的[]rune()函数将字符串转换为rune片段runes。

3. 使用rune迭代字符串：

for _, r := range "Hello, 世界" {
    fmt.Printf("%c ", r)
}

在此示例中，我们使用range循环使用rune迭代字符串“Hello，世界”。使用%c格式说明符打印Unicode码点作为字符。

请注意，在Go中，字符串是一个字节序列，而不是rune序列。为了正确处理包含非ASCII字符的字符串，请在处理单个Unicode码点时使用[]rune类型或rune数据类型。

4. rune字节大小

	var c1 rune = '北'
	fmt.Println("c1=", c1, unsafe.Sizeof(c1))

c1= 21271 4 

基本数据类型的默认值

在 go 中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在 go 中，默认值又叫零值。

var a int // 0
	var b float32 // 0
	var c float64 // 0
	var isMarried bool // false 
	var name string // ""
	//这里的%v 表示按照变量的值输出
	fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v name=%v",a,b,c,isMarried, name)