【Golang入门】四、变量的基本数据类型

一、 整数类型 int

整数类型用于存放整数值。

1. 有符号的整数类型

类型	有无符号	占用存储空间	表示数据范围
int8	有	1字节	$-2^7$~$2^7-1$
int16	有	2字节	$-2^{15}$~$2^{15}-1$
int32	有	4字节	$-2^{31}$~$2^{31}-1$
int64	有	8字节	$-2^{63}$~$2^{63}-1$

2. 无符号的整数类型

类型	有无符号	占用存储空间	表示数据范围
uint8	无	1字节	$0$~$2^8-1$
uint16	无	2字节	$0$~$2^{16}-1$
uint32	无	4字节	$0$~$2^{32}-1$
uint64	无	8字节	$0$~$2^{64}-1$

3. int的其他类型数据

类型	有无符号	占用存储空间	表示数据范围
int	有	32bit系统4个字节，64bit系统8个字节	$-2^{31}$~$2^{31}-1$, $-2^{63}$~$2^{63}-1$
uint	无	32bit系统4个字节，64bit系统8个字节	$0$~$2^{32}-1$, $0$~$2^{64}-1$
rune	有	4字节	$-2^{31}$~$2^{31}-1$
byte	无	1字节	$0$~$2^8-1$

4. 整数类型的使用细节

1、Golang的整数类型分为有符号和无符号两种类型，并且int 和unit的大小与系统有关；
2、Golang的整型默认声明为 int 型；
3、在程序中查看某个变量的字节大小和数据类型的方式为：

package main

// import "fmt"
// import "unsafe"
// 引用多个包时，采用如下方式
import (
  "fmt"
  "unsafe"
)
func main() {
  // 查看某个变量占用的字节大小和数据类型
  var n int64 = 100
  // unsafe.Sizeof(n) 是 unsafe 包中的一个函数，可以返回变量 n 占用的字节大小
  fmt.Printf("n 的数据类型是 %T, 占用的字节大小是 %d", n, unsafe.Sizeof(n))
}

输出结果为：

4、使用整型变量时：保小不保大，即保证程序正确运行下，尽量使用占用空间小的数据类型。

5、bit：计算机中的最小存储单位，byte：计算机中的基本存储单元。

二、浮点数类型

用于存放浮点数(小数)。

1. 类型分类

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

说明：
1、浮点数 = 符号位 + 指数位 + 尾数位，说明浮点数都是有符号的；
2、尾数部分可能丢失，造成精度损失。

package main

import "fmt"
func main()  {
  var num1 float32 = 10.00000901
  var num2 float64 = 10.00000901
  fmt.Println("num1 = ", num1, "num2 = ", num2)
}

输出结果为：

说明：float64的精度比float32高。

3、 浮点数的存储分为三部分：符号位，指数位和尾数位，存储过程中可能会造成精度损失。

2. 使用细节

1、Golang浮点类型有固定的范围和字段长度，不受操作系统的影响；
2、Golang的浮点型默认声明为float64类型；
3、通常情况下使用float64，比float32更精确。

三、字符类型

Golang中没有专门的字符类型，一般使用byte保存单个字符。示例如下：

package main

import "fmt"

func main() {
  var c1 byte = 'a'
  var c2 byte = '0'
  // 直接输出 byte 值，输出的是对应字符的ASCII码值
  fmt.Println("c1 = ", c1, "c2 = ", c2)
  
  // 格式化输出对应字符
  fmt.Printf("c1 = %c, c2 = %c", c1, c2)
}

结果为：

1. 使用细节

1、 字符常量是用单引号(’’)引起来的单个字符；
2、Go中的字符使用UTF-8编码 (包含了ASCII码)，英文字母1个字节，汉字3个字节；
3、Go中字符的本质是一个整数，直接输出的结果是字符对应的UTF-8编码的码值；
4、直接给变量赋值一个数字，格式化输出%c该变量，结果是数字对应的字符；
5、字符类型可以用于计算，并且按码值进行运算：

package main

import "fmt"
func main() {
  var n = 10 + 'a'
  fmt.Println("n = ", n)
  fmt.Printf("n = %c", n)
}

输出结果为：

四、布尔类型 bool

bool类型数据只能取值 true 和 false，占1个字节，适用于逻辑运算，用于程序流程控制。比如 if 条件控制语句和 for 循环控制语句。

Golang中不能用 0 或非 0 整数替代 false 和 true，这一点和C语言不同。

五、字符串类型 string

字符串是一串固定长度的字符连接起来的字符序列。

package main

import "fmt"
func main() {
  var address string = "Chongqing."
  fmt.Println(address)
}

1. 使用细节

1、Golang统一使用UTF-8编码，中文乱码问题就不会再困扰程序员了。
2、Golang中字符串不可变：字符串一旦赋值，就不能再修改了。
3、字符串的两种表示形式：双引号，会识别转义字符；反引号，以字符串的原生形式输出，可以实现防止攻击、输出源代码等效果。

package main

import "fmt"
func main() {
  // 双引号
  var address string = "Southwest University, Chongqing."
  fmt.Println(address)

  // 使用反引号
  str := `
  package main

  import "fmt"
  func main() {
    var address string = "Southwest University, Chongqing."
    fmt.Println(address)
  }
  `
  fmt.Println(str)
}

输出结果：

4、 字符串拼接方式：+

package main

import "fmt"
func main() {
  // 字符串拼接
  var str1 = "hello " + "world"
  fmt.Println(str1)
  
  // 对于很长的拼接，可以分行写
  var str2 = "hello " + "world" +
  ", this " + "is " + "Golang " + 
  "programming " + "lesson!"
  fmt.Println(str2)
}

输出结果为：

注意，将字符串的长拼接分行写的时候，行末尾要保留+号，因此编译时不会自动在行末尾添加 ; 号。

六、基本数据类型默认值

Golang中，所有的数据类型都有一个默认值，没有赋值时会保留默认值。默认值又叫零值。

数据类型	默认值
整型	0
浮点型	0
字符串	" "
bool	false

七、基本数据类型的转换

(非常重要)Golang和Java/c不同，Go在不同类型变量之间赋值时需要显示转换** (强制转换)，即Golang中的数据类型不能自动转换**。

1.基本语法

数据类型(变量)，T(v)：将值v转换为类型T。

package main

import "fmt"
func main() {
  var num1 int = 10
  fmt.Println("num1 = \t", num1)
  // 输出 num1 的数据类型
  fmt.Printf("num1 的数据类型是 %T\n", num1)

  var num2 float32 = float32(num1)
  fmt.Println("num2 = \t", num2)
  // 输出 num2 的数据类型
  fmt.Printf("num2 的数据类型是 %T", num2)
}

输出结果为：

高精度到低精度，或低精度到高精度：

var num1 int32 = 100
// 高精度到低精度
var num2 int8 = int8(num1)
// 低精度到高精度
var num3 int64 = int64(num1)

2. 使用细节

1、被转换的是变量存储的数据，变量本身的数据类型并没有发生变化；
2、转换时，比如 int64 转成 int8，编译时不会报错，转换的结果按溢出处理。因此，在转换时需要考虑范围问题。

package main

import (
  "fmt"
)
func main() {
  var num1 int64 = 1234567
  fmt.Println("num1 = \t", num1)
  fmt.Printf("num1 的数据类型是 %T\n", num1)

  var num2 int8 = int8(num1)
  fmt.Println("num2 = \t", num2)
  fmt.Printf("num2 的数据类型是 %T", num2)
}

输出结果为：

八、基本数据类型和string的转换

1. 基本数据类型转成string

方式1：fmt.Sprintf("%参数", 表达式)，比较灵活，首推

package main

import (
  "fmt"
)
func main() {
  // 基本数据类型转string
  var num1 int = 99
  var num2 float64 = 23.456
  var b bool = true
  var mychar byte = 'h'
  var str string // 空的string

  // 使用第一种方式转换：fmt.Sprintf("%参数", 表达式)
  str = fmt.Sprintf("%d", num1)
  fmt.Printf("str type %T, str = %q\n", str, str)

  str = fmt.Sprintf("%f", num2)
  fmt.Printf("str type %T, str = %q\n", str, str)

  str = fmt.Sprintf("%t", b)
  fmt.Printf("str type %T, str = %q\n", str, str)

  str = fmt.Sprintf("%c", mychar)
  fmt.Printf("str type %T, str = %q", str, str)
}

输出结果为：

方式2：使用strconv包的函数

package main

import (
  "fmt"
  "strconv"
)
func main() {
  // 基本数据类型转string
  // 使用第二种方式转换：strconv包里的函数
  var num3 int = 99
  var num4 float64 = 23.456
  var b2 bool = true
  var str2 string

  str2 = strconv.FormatInt(int64(num3), 10)
  fmt.Printf("str2 type %T, str2 = %q\n", str2, str2)
  // 一个更快捷的 int 转 string 的方式是
  // str2 = strconv.Itoa(num3)
  // Itoa 是 FormatInt(i, 10) 的简写

  str2 = strconv.FormatFloat(num4, 'f', 6, 64)
  fmt.Printf("str2 type %T, str2 = %q\n", str2, str2)

  str2 = strconv.FormatBool(b2)
  fmt.Printf("str2 type %T, str2 = %q", str2, str2)
}

输出结果为：

2. string转基本数据类型

方式：使用strconv包的函数** (函数中的第二个括号表示函数的返回值)**

package main

import (
  "fmt"
  "strconv"
)
func main() {
  // string 转基本数据类型
  var str string = "true"
  var b bool

  // ParseBool 返回两个值 (value bool, err error)
  // 只关心 bool 值，用下划线 _ 表示忽略第二个值
  b, _ = strconv.ParseBool(str)
  fmt.Printf("b type %T, b = %v\n", b, b)

  var str2 string = "123456"
  var num int64

  num, _ = strconv.ParseInt(str2, 10, 64)
  fmt.Printf("b type %T, b = %v\n", num, num)
}

输出结果为：

注意，因为返回的是 int64 或者 float64，要得到 int32 或 float32，需要做如下处理：
var num2 int32
num2 = int32(num)

3. 使用细节

string转成基本数据类型时，要确保string类型能够转成有效的数据，否则转成基本数据类型的默认值；

package main

import (
  "fmt"
  "strconv"
)
func main() {
  var str string = "hello"
  var num int64
  num, _ = strconv.ParseInt(str, 10, 64)
  fmt.Printf("num type %T, num = %v\n", num, num)
}

输出结果为：

需要注意的是，num 即便已经初始化为21，string 转换后，依然会被 int 的默认值覆盖掉：

  var str string = "hello"
  var num int64 = 21
  num, _ = strconv.ParseInt(str, 10, 64)
  fmt.Printf("num type %T, num = %v\n", num, num)

输出结果为：