Go基础03：变量、常量和数据类型

变量的声明

变量相当于内存中一个数据存储空间的表示，通过变量名可以访问到变量（值）。

变量声明方式

第一种：指定变量类型，声明后若不赋值，使用默认值（比如 int 默认值为 0，string 默认值为空串，float 默认为 0）

package main

import "fmt"

func main() {
	var i int
	fmt.Println(i) // 0
}

第二种：根据值自行判定变量类型（类型推导）

package main

import "fmt"

func main() {
	var num = 2.22
	fmt.Println(num) // 2.22
}

第三种：省略 var，注意 := 左侧的变量不应该是已经声明过的，否则会导致编译错误

package main

import "fmt"

func main() {
	str := "a"
	fmt.Println(str) // a
}

多变量声明

package main

import "fmt"

func main() {
	i, num, str := 1, 2.22, "a"
	fmt.Println(i, num, str) // 1 2.22 a
}

全局变量声明

package main

import "fmt"

// 定义全局变量
var n1 = 100
var n2 = 200
var s1 = "a"

// 一次性定义全局变量
var (
	n3 = 300
	n4 = 400
	s2 = "b"
)

func main() {
	fmt.Println(n1, n2, s1, n3, n4, s2) // 100 200 a 300 400 b
}

常量的声明

常量声明方式

package main

import "fmt"

func main() {
	const PI float32 = 3.14
	fmt.Println(PI) // 3.14
}

多常量声明

package main

import "fmt"

func main() {
	const a, b, c = 1, false, "a"
	const (
		d = 2
		e = true
		f = "b"
	)
	fmt.Println(a, b, c, d, e, f) // 1 false a 2 true b
}

全局常量声明

package main

import "fmt"

// 定义全局常量
const a = 1
const b bool = false
const c string = "a"

// 一次性定义全局常量
const (
	d int = 2
	e     = true
	f     = "b"
)

func main() {
	fmt.Println(a, b, c, d, e, f) // 1 false a 2 true b
}

基本数据类型

整型

类型	有无符号	占用存储空间	表数范围
int8	有	1字节	-128 到 127
int16	有	2字节	-32768 到 32767
int32	有	4字节	-2147483648 到 2147483647
int64	有	8字节	-9223372036854775808 到 9223372036854775807
uint8	无	1字节	0 到 255
uint16	无	2字节	0 到 65535
uint32	无	4字节	0 到 4294967295
uint64	无	8字节	0 到 18446744073709551615

类型	有无符号	占用存储空间	表数范围
int	有	4字节(32位) 8字节(64位)	-2147483648 到 2147483647 -9223372036854775808 到 9223372036854775807
uint	无	4字节(32位) 8字节(64位)	0 到 4294967295 0 到 18446744073709551615
rune	有	4字节(与int32一样)	0 到 4294967295
byte	无	1字节(与uint8一样)	0 到 255

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var a = 100
    // 查看变量的数据类型和占用字节大小
	fmt.Printf("a 的类型：%T，占用的字节数：%d", a, unsafe.Sizeof(a)) // a 的类型：int，占用的字节数：8
}

使用总结：

1. Go 各整数类型分：有符号和无符号，int 和 uint 的大小和系统有关。
2. Go 的整型默认声明为 int 型。

浮点型

类型	占用存储空间	表数范围
单精度 float32	4字节	-3.403E38 到 3.403E38
双精度 float64	8字节	-1.798E308 到 1.798E308

package main

import (
	"fmt"
)

func main() {
	var num1 float32 = 22.22
	fmt.Println(num1) // 22.22

	// 浮点数都是有符号的
	var num2 float32 = -0.00099
	var num3 float64 = -1234567.89
	fmt.Println(num2, num3) // -0.00099 -1.23456789e+06

	// 尾数部分可能丢失，造成精度损失（float64 的精度比 float32 的要准确）
	var num4 float32 = -123.456789
	var num5 float64 = -123.456789
	fmt.Println(num4, num5) // -123.45679 -123.456789
}

使用总结：

1. Go 浮点型的存储分为三部分：符号位+指数位+尾数位。
2. Go 浮点型有固定的范围和字段长度，不受操作系统的影响。
3. Go 浮点数默认声明为 float64 类型。
4. 在存储过程中，精度会有丢失，float64 的精度比 float32 的要准确。

字符型

Go 中没有专门的字符类型，如果要存储单个字符，一般使用 byte 来声明。

package main

import (
	"fmt"
)

func main() {
	var s1 byte = 'a'
	var s2 byte = '0'
	fmt.Println(s1, s2) // 97 48

	var s3 int = '中'
	fmt.Println(s3) // 20013

	var s4 int = 20013
	fmt.Printf("%c\n", s4) // 中

	var s5 byte = '\n'
	fmt.Println(s5) // 10
}

使用总结：

1. 字符常量是用单引号括起来的单个字符。
2. Go 中允许使用转义字符 \ 来将其后的字符转变为特殊字符型常量。
3. 在 Go 中，字符的本质是一个证书，直接输出时，是该字符对应的 UTF-8 编码的码值。
4. 可以直接给某个变量赋一个数字，然后按格式化输出时 %c，会输出该数字对应的 unicode 字符。

布尔型

布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。

bool 类型占 1 个字节。

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var b = true
	fmt.Println(b) // true
	fmt.Println(unsafe.Sizeof(b)) // 1
}

字符串

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var str1 string = "hello"
	fmt.Println(str1) // hello
	fmt.Println(unsafe.Sizeof(str1)) // 16

	str2 := "world"
	fmt.Println(str2) // world
}

基本数据类型默认值

数据类型	默认值
整型	0
浮点型	0
字符串	“”
布尔类型	false

package main

import (
	"fmt"
)

func main() {
	var a int
	var b float32
	var c float64
	var d bool
	var e string

	fmt.Println(a) // 0
	fmt.Println(b) // 0
	fmt.Println(c) // 0
	fmt.Println(d) // false
	fmt.Println(e) //
}

基本数据类型相互转换

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)
	var n4 string = string(i)

	fmt.Println(i)  // 100
	fmt.Println(n1) // 100
	fmt.Println(n2) // 100
	fmt.Println(n3) // 100
	fmt.Println(n4) // 100
}

使用总结：

1. 数据类型的转换可以时从 小->大，也可以 大->小。
2. 被转换的时变量存储的数据（即值），变量本身的数据类型并没有变化。
3. 在转换中，浮点型高精度转成低精度，编译时不会报错，只是转换的结果是按溢出处理。

派生数据类型

• 指针类型（Pointer）
• 数组类型
• 结构化类型(struct)
• Channel 类型
• 函数类型
• 切片类型
• 接口类型（interface）
• Map 类型