Go语言学习 第四章 基本数据类型

Go语言数据类型分为五种：

• 布尔类型
• 整型类型
• 浮点类型
• 字符类型
• 字符串类型

类型	名称	长度	零值	说明
bool	布尔类型	1	false	其值不为真即为假，不可以用数字代表true或false
byte	字节型	1	0	uint8别名
int, uint	整型	-	0	根据操作系统设定数据的值。
int8	整型	1	0	-128 ~ 127
uint8	整型	1	0	0 ~ 255
int16	整型	2	0	-32768 ~ 32767
uint16	整型	2	0	0 ~ 65535
int32	整型	4	0	-2147483648 ~ 2147483647
uint32	整型	4	0	0 ~ 4294967295(42亿)
int64	整型	8	0	-9223372036854775808 ~ 9223372036854775807
uint64	整型	8	0	0 ~ 18446744073709551615(1844京)
float32	浮点型	4	0.0	小数位精确到7位
float64	浮点型	8	0.0	小数位精确到15位
string	字符串	-	""	utf-8字符串

1 布尔型

在计算机中，会涉及到逻辑性问题的真假对错，例如：在计算机中描述张三 ( 20岁 ) 比李四 ( 18岁 ) 小，这句话的结果？

布尔类型的变量取值要么是真（true）,要么是假 ( false )，用bool关键字来进行定义。

示例如下：

//定义bool类型变量
var 变量名 bool = true

package main
import "fmt"

func main()  {
  a := 10
  b := 20
  //比较两个数的大小 返回值为bool类型的结果
  fmt.Println(a > b)        //false
  fmt.Println(a < b)        //true
  //将表达式的结果赋值给bool类型变量c中
  var c bool = a < b
  fmt.Println(c)
  //格式化打印 使用占位符%t 输出一个bool类型数据
  fmt.Printf("%t", c)
}

2 整型

Go语言的整数类型一共有10个。

大多数情况下，我们只需要 int 一种整型即可，它可以用于循环计数器、数组和切片的索引，以及任何通用目的的整型运算符，通常 int 类型的处理速度也是最快的。

其中计算架构相关的整数类型有两个，即：

• 有符号的整数类型 int。
• 无符号的整数类型 uint。

//有符号的整型
var a int = -10
//无符号的整型(不可以存储带符号数据)
var b uint = 10

//格式化打印 使用占位符%d 输出一个int类型数据
fmt.Printf("%t", a)

这两个计算架构相关的整数类型之外，还有8个可以显式表达自身宽度的整数类型。

如下表所示。

数据类型	有符号	类型长度（位）	取值范围
int8	是	8	-128 ~ 127
int16	是	16	-32768 ~ 32767
int32	是	32	-2147483648 ~ 2147483647
int64	是	64	-9223372036854775808 ~ 9223372036854775807
uint8	否	8	0 ~ 255
uint16	否	16	0 ~ 65535
uint32	否	32	0 ~ 4294967295
uint64	否	64	0 ~ 18446744073709551615

可以看到，这8个整数类型的宽度已经表现在它们的名称中了。

3 浮点型

Go语言提供了两种精度的浮点数 float32 和 float64。

这些浮点数类型的取值范围可以从很微小到很巨大。浮点数取值范围的极限值可以在 math 包中找到：

• 常量 math.MaxFloat32 表示 float32 能取到的最大数值，大约是 3.4e38；
• 常量 math.MaxFloat64 表示 float64 能取到的最大数值，大约是 1.8e308；

• float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324。

  浮点型数据都是相对精准的，存在一定的误差值：

• float32 类型的浮点数可以提供约 6 个十进制数的精度。

• float64 类型的浮点数可以提供约 15 个十进制数的精度。

  通常应该优先使用 float64 类型，因为 float32 类型的累计计算误差很容易扩散，并且 float32 能精确表示的正整数并不是很大。

  浮点数在声明的时候可以只写整数部分或者小数部分，像下面这样：

  const e = .71828                     // 0.71828
  const f = 1.                         // 1.0
  

  很小或很大的数最好用科学计数法书写，通过 e 或 E 来指定指数部分：

  const Avogadro = 6.02214129e23      // 阿伏伽德罗常数
  const Planck   = 6.62606957e-34     // 普朗克常数
  

  用 Printf 函数打印浮点数时可以使用“%f”来控制保留几位小数

  package main
  import "fmt"
  
  func main() {
  pi := 3.1415926
  //格式化打印 使用占位符%d 输出一个float类型数据
  //%f 默认保留六位小数 会四舍五入
  fmt.Printf("%f\n", Pi)
  //设置保留二位小数
  fmt.Printf("%.2f\n", Pi)
  }
  

4 字符型

Go语言的字符有以下两种：

• 一种是 uint8 类型，或者叫 byte 型，代表了 ASCII码 的一个字符。
• 一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。

byte 类型是 uint8 的别名，对于只占用 1 个字节的传统 ASCII 编码的字符来说，完全没有问题，

例如：

//字符类型是用单引号括起来的单个字符
var ch byte = 'A'
//格式化打印 使用占位符%c 输出一个byte类型数据
fmt.Printf("%c\n", ch)

rune 类型等价于 int32 类型，可以存储带中文的符合字符。

例如：

//rune 类型可以存储带中文的字符
var ch rune = '帅'
//格式化打印 使用占位符%c 输出一个rune类型数据
fmt.Printf("%c\n", ch)

5 字符串型

用双引号括起来的字符是字符串类型 。

在Go中的字符串，都是采用UTF-8字符集编码。

var str string = "法师真帅"
//格式化打印 使用占位符%s 输出一个string类型数据
fmt.Printf("%s\n", ch)

字符串拼接

str1 := "性感法师"
str2 := "在线讲课"
fmt.Println(str1 + str2)         //性感法师在线讲课

字符串长度

str1 := "hello"
str2 := "法师"
//len(字符串) 计算字符串中字符个数
fmt.Println(len(str1))             //5
fmt.Println(len(str2))            //6 一个汉字占三个字符