GO语言-数据类型

变量定义

代码如下：

package main

import "fmt"

var i1 = 1000
var i2 int

var(
	i5 = "hello"
	i6 = "world"
)

func main(){
	var i int
	
	fmt.Println("i = ", i)
	
	i = 10
	fmt.Println("i = ", i)

	var num = 10.01 	
	fmt.Println("num = ", num)

	num = 100.01 	
	fmt.Println("num = ", num)

	Name := "MikeSun"
	fmt.Println("Name = ", Name)

	var n1 , n2 , n3 int
	fmt.Println("n1 = ", n1, "n2 = ", n2, "n3 = ", n3)

	var n4 , name1 , n5 = 100, "MikeSun", 200
	fmt.Println("n4 = ", n4, "name1 = ", name1, "n5 = ", n5)

	n6, name2, n7 := 1000, "joke", 2000
	fmt.Println("n6 = ", n6, "name2 = ", name2, "n7 = ", n7)

	fmt.Println("i1 = ", i1, "i2 = ", i2)
	fmt.Println("i5、i6 = ", i5, i6)
}

1、从main函数上面的全局变量开始分析：
全局变量定义，定义时不声明类型，只定义数值，自动分配类型：
var i1 = 1000
全局变量定义：
var i2 int
全局变量定义，同时定义多个对象：
var(
i5 = “hello”
i6 = “world”
)

2、再来看main函数中的变量定义方式
定义变量不赋值：
var i int
3、对已定义的变量赋值：
i = 10
4、定义变量，不声明类型，默认匹配类型：
var num = 10.01
5、定义并且赋值：
Name := “MikeSun”
上面代码等价于
var Name string
Name = “MikeSun”
6、一次定义多个变量
var n1 , n2 , n3 int
7、一次性定义多个变量并且赋值
var n4 , name1 , n5 = 100, “MikeSun”, 200
8、一次性定义多个变量并且赋值
n6, name2, n7 := 1000, “joke”, 2000

1. 整数类型

2. 浮点类型

package main 
import (
	"fmt"
	"reflect"
)

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)

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

	//Golang的浮点类型默认声明为float64 类型
	var num5 = 1.1
	fmt.Println("typeof num5 is ", reflect.TypeOf(num5))

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

	//科学计数法
	num8 := 5.1234e2
	num9 := 5.1234E2
	num10 := 5.1234E-2
	fmt.Println("num8 = ", num8, "num9 = ", num9, "num10 = ", num10)
}

3. 字符类型

Go语言统一使用Unicode编码。
字符类型的本质就是一个整数型，一个整数对应Unicode中的一个字符，从而可以使用特地的输出格式输出，如%c。
Unicode编码是包含ASCII码的，所以前面的256个字符仍然可以当作ASCII码来输出或转换。

package main

import (
	"fmt"
)

func main(){
	var c1 byte = 'a'
	var c2 byte = '0'
	
	fmt.Println("c1 = ", c1)
	fmt.Println("c2 = ", c2)

	// 要输出ASCII值必须要格式化输出
	fmt.Printf("c1 = %c c2 = %c", c1, c2)

	var c3 int = '孙'
	fmt.Printf("c3 = %c c3 = %d", c3, c3)

	var c4 int = 22269
	fmt.Printf("\nc4 = %c", c4)

	var c5 int = 65
	fmt.Printf("\nc5 = %c", c5)
}

运行结果：
c1 =  97
c2 =  48
c1 = a c2 = 0c3 = 孙 c3 = 23385
c4 = 国
c5 = A

4. 布尔类型

代码示例如下：

package main
import (
	"fmt"
	"unsafe"
)

func main(){
	var bflag = false
	fmt.Println("bflag = ", bflag)
	//注意事项
	//1.bool类型占用存储空间是1个字节
	fmt.Println("bflag 的占用空间 =  ", unsafe.Sizeof(bflag))
	//2.bool类型只能取true或者false
}

运行结果：
bflag =  false
bflag 的占用空间 =   1

注意：
1、bool类型不能参加±运算，可以参加逻辑运算。

b := true
// fmt.Println(b + 1) // 错误：bool 不能参与数学运算

2、Go 是强类型语言，其他类型不能隐式转为 bool

// 错误示例
i := 1
if i { // 编译错误：non-bool i (type int) used as if condition
    fmt.Println("True")
}

3、必须显式比较

b := true
// fmt.Println(b + 1) // 错误：bool 不能参与数学运算

5. 字符串类型

5.1 字符串的本质

1、底层结构：Go 的字符串是一个 只读的字节切片（[]byte），存储的是 UTF-8 编码的 Unicode 字符。
2、不可变性：字符串一旦创建，内容不可修改（若需修改需转为 []byte 或 []rune）。

代码示例如下：

package main

import (
	"fmt"
	"reflect"
)

//演示golang中string 的类型使用
func main(){
	var str1 = "北京欢迎您"
	fmt.Println("1、", str1)
	fmt.Println("sizeof(strl) is", len(str1))
	fmt.Println("typeof(strl) is", reflect.TypeOf(str1))

	// 字符串拼接方式
	str1 += "为您开天辟地"
	fmt.Println("2、", str1)

	// 字符串拼接需要换行的时候，需要将操作符，例如+，保留在上面一行否则报错
	str1 += "hello" + "world" +
		    "666"
	fmt.Println("3、", str1)

	// 反引号引用无需转义，原样输出
	str1 = `
	var str1 = "北京欢迎您"
	fmt.Println("1、", str1)
	fmt.Println("sizeof(strl) is", len(str1))
	fmt.Println("typeof(strl) is", reflect.TypeOf(str1))
	`
	fmt.Println("4、", str1)

	// str1[0] = 'A'
}


运行结果：
1、 北京欢迎您
sizeof(strl) is 15
typeof(strl) is string
2、 北京欢迎您为您开天辟地
3、 北京欢迎您为您开天辟地helloworld666
4、
        var str1 = "北京欢迎您"
        fmt.Println("1、", str1)
        fmt.Println("sizeof(strl) is", len(str1))
        fmt.Println("typeof(strl) is", reflect.TypeOf(str1))

5.2 常用字符串处理函数(strings包)

5.3 修改字符串的方式

若需频繁操作字节/字符，可先转为 []byte 或 []rune：

s := "Hello"
bytes := []byte(s)
bytes[0] = 'h' // 修改后转回字符串
s = string(bytes) // "hello"

6. 数据默认值

Go语言数据默认值均为0（字符串空，nil，false均为0的别名）。

package main

import (
	"fmt"
)


func main(){
	var a int // 0
	var b float32 // 0
	var c float64 // 0
	var d bool // flase
	var name string // ""

	//%v 表示按照变量的值输出
	fmt.Printf("a = %v, b = %v, c = %v, d = %v, name = %v", a, b, c, d, name)
}



运行结果：
a = 0, b = 0, c = 0, d = false, name = 

7. 类型转换

Go语言在不同类型的变量之间赋值时需要显示转换。也就是说Go语言数据类型不会自动转换。
1、强制类型转换既可以从小范围数据类型转换到大范围数据类型(上行转换)、也可以从大范围数据类型转换到小范围数据类型(下行转换)
2、被转换的是变量存储的数据(数值),变量本身的数据类型并没有发生改变
3、在转换中，可能出现意想不到的结果，特别是下行转换的时候。
示例代码如下：
从代码很容易看出转换语法：type(var)，这里需要注意，和C语言不同，C语言是(type)var。
当转换溢出时，数据会错误。
如int64的变量转换为int8，则需要取余256.（网上某个培训班网课说无法计算，实际是可计算的，数据溢出之后从0开始，是一个循环）

package main

import (
	"fmt"
)

func main(){

	var i int32 = 100

	var n1 float32 = float32(i)
	var n2 int8 = int8(i)
	var n3 int64 = int64(i)

	fmt.Printf("i = %v n1 = %v n2 = %v n3 = %v", i, n1, n2, n3)

	// 被转换的是变量的数据，而不是变量的类型
	fmt.Printf("i type is %T", i)

	var num1 int64 = 999999
	var num2 int8 = int8(num1)
	fmt.Println("num2 = ", num2)
	num1 = 257
	num2 = int8(num1)
	fmt.Println("num2 = ", num2)
}