【30天熟悉Go语言】5 Go 基本数据类型

电玩女神 2023-10-12 08:57 17阅读 0赞

#### 文章目录 ####

*  一、前言
 *  二、数据类型总览
 *   *  1、基本数据类型
     *   *  1）数值型-整数类型
         *   *  1> 有符号整数类型：
             *  2> 无符号整数类型：
             *  3> 其他整数类型：
             *  4> PS:Go的整数类型，默认声明为int类型：
             *  5> 变量占用的字节数
         *  2、数值型-浮点类型
         *   *  1> 浮点类型种类
             *  2> PS:Go的浮点类型，默认声明为float64类型：
         *  3、字符类型
         *  4、布尔类型
         *  5、字符串类型
     *  2、复杂数据类型
 *  三、类型转换
 *   *  1、基本数据类型之间的转换
     *   *  1）强制转换
         *   *  1> 强转报错：数据溢出
             *  2> 数据溢出自动判断
         *  2）其他基本类型转string
         *   *  1> fmt.Sprintf
             *  2> strconv
         *  3）string转其他基本类型
 *  四、总结
 *   *  对比着看Java的基本数据类型

## 一、前言 ##

![在这里插入图片描述][26456da6bcf74d8ab70094e321fbd199.png]

Go系列文章：

> 1.  [GO开篇：手握Java走进Golang的世界][GO_Java_Golang]
> 2.  [2 Go开发环境搭建、Hello World程序运行][2 Go_Hello World]
> 3.  [3 Go编程规约和API包][3 Go_API]
> 4.  [4 Go的变量、常量、运算符][4 Go]

**Go专栏传送链接：[https://blog.csdn.net/saintmm/category\_12326997.html][https_blog.csdn.net_saintmm_category_12326997.html]**

## 二、数据类型总览 ##

![在这里插入图片描述][f65c783ada464ecfb7f4b29d33c907e2.png]

### 1、基本数据类型 ###

基本数据类型大体来看有四种：数值型、字符型、布尔型、字符串。数值型又分为整数类型和浮点类型。

#### 1）数值型-整数类型 ####

用于存放整数值的，比如10,1002,-6712等等。

按数据范围进一步细分，整数类型又分：int8、int16、int32、int64。所谓的8/16/32/64只是用于表示数据临界范围

##### 1> 有符号整数类型： #####

![在这里插入图片描述][da955c73dd7e4c1b804d1932300ab951.png]

##### 2> 无符号整数类型： #####

![在这里插入图片描述][ab651cb8106844699c3ddd8289b0a959.png]

##### 3> 其他整数类型： #####

![在这里插入图片描述][25b99125c0d04a829f5ab9d5eaa42e0d.png]

##### 4> PS:Go的整数类型，默认声明为int类型： #####

![在这里插入图片描述][a39cdd949ed5468a94cb46d920bdcbd6.png]

*  Printf函数的作用是格式化，把age的类型填充到%T位置上。

##### 5> 变量占用的字节数 #####

使用unsafe包下的Sizeof()方法；

package main
    
    import "fmt"
    import "unsafe"
    // 基础数据类型
    func main() {
        
    
    	age := 18
    	fmt.Printf("age的类型是： %T", age)
    	fmt.Println();
    	fmt.Println("------------------")
    	fmt.Println(unsafe.Sizeof(age))
    }

![在这里插入图片描述][3377615ea07543529137085b0c5c4048.png]

#### 2、数值型-浮点类型 ####

浮点类型用于存放小数，比如：3.14、0.33、-1.19等等。

##### 1> 浮点类型种类 #####

浮点类型有两种：32位float 和 64位float。  
![在这里插入图片描述][097f6b126f5b49f3aa3e0e34144e67f4.png]

其底层存储空间和操作系统无关。

由于浮点类型底层存储：符号位+指数位+尾数位，所以尾数位只是存了 一个大概，很可能会出现**精度的损失**。

package main
    
    import (
    	"fmt"
    	"unsafe"
    )
    
    // 基础数据类型
    func main() {
        
    	float()
    }
    
    func float() {
        
    	// 定义浮点类型数据
    	var num1 float32 = 3.14
    	fmt.Println(num1)
    
    	//浮点数可以用十进制表示形式，也可以用科学计数法表示形式  E 大写小写都可以的
    	var num2 float32 = 314E-2
    	fmt.Println(num2)
    
    	//浮点数可能会有精度的损失，所以通常情况下，建议使用：float64
    	var num3 float32 = 234.000000916
    	fmt.Println(num3)
    	var num4 float64 = 234.000000916
    	fmt.Println(num4)
    }

**控制台输出如下：**  
![在这里插入图片描述][7e9461793740422d9e972b3289d93c23.png]

##### 2> PS:Go的浮点类型，默认声明为float64类型： #####

// golang中默认的浮点类型为：float64
    num5 := 3.17
    fmt.Printf("num5对应的默认的类型为：%T",num5)

![在这里插入图片描述][b8473bbb18c8435f812255f46795606c.png]

**当我们在IDEA声明一个float64数据类型的变量时，IDEA编译器会提示：**

![在这里插入图片描述][796db8b75b3e444a987cc8e3d98264fb.png]

#### 3、字符类型 ####

Go中没有专门的字符类型；

如果要存储单个字符（字母、数字、标点等符号），底层对应的是ASCII码值，一般使用byte来保存；  
Go中字符使用`UTF-8`编码，底层对应的是Unicode码值（`Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案`），中文的码值可能会导致byte类型溢出，建议使用int 或 rune存在中文字符。

因此在 Go 语言中，字符可以被分成两种类型处理：

*  对占 1 个字节的英文类字符，可以使用byte（或者unit8）；
 *  对占 1 ~ 4 个字节的其他字符，可以使用rune（或者int32），如中文、特殊符号等。

**ASCII码表：**

![在这里插入图片描述][4c6bb51e9e1e4ec7a1b0a4d0a35e1f1a.png]

**字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出：**

![在这里插入图片描述][3630185477b04604b9a40aefd768003e.png]

**想显示对应的字符，必须采用格式化输出：**

var c4 byte = 'A'
    fmt.Printf("c4对应的具体的字符为：%c",c4)

**测试代码：**

func char() {
        
    	// 定义字符类型的数据
    	var c1 byte = 'a'
    	// 字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出
    	// 输出97
    	fmt.Println(c1)
    
    	var c2 byte = '('
    	// 字母，数字，标点等字符，底层是按照ASCII进行存储。
    	// 输出 40
    	fmt.Println(c2 + 20)
    
    	var c3 int = '中'
    	// 汉字字符，底层对应的是Unicode码值，中字对应的码值为20013，byte类型溢出，可以用int存储
    	fmt.Println(c3)
    
    	var c4 byte = 'A'
    	// 想显示对应的字符，必须采用格式化输出
    	fmt.Printf("c4对应的具体的字符为：%c",c4)
    
    }

#### 4、布尔类型 ####

布尔类型也叫bool类型，bool类型数据只允许取值true和false；

*  占1个字节
 *  用于逻辑运算，大量使用于程序流程控制。

package main
    
    import (
    	"fmt"
    )
    
    // 基础数据类型
    func main() {
        
    	boolean()
    }
    func boolean() {
        
    	var b1 bool = true
    	fmt.Println(b1)
    	b2 := false
    	fmt.Println(b2)
    	b3 := 5 < 9
    	fmt.Println(b3)
    }

**控制台输出：**  
![在这里插入图片描述][b242f03a2f454b5589a2e5984edfa7bc.png]

#### 5、字符串类型 ####

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

*  字符串是不可变的，指字符串一旦定义好，其中字符的值不能改变，但是字符串的引用可以改变。
 *  如果字符串中没有特殊字符，字符串的表示形式用双引号“”
 *  如果字符串中有特殊字符，字符串的表示形式用反引号 \`\`
 *  字符串拼接可以直接使用加号`+`

**测试代码：**

package main
    
    import (
    	"fmt"
    	"unsafe"
    )
    
    // 基础数据类型
    func main() {
        
    	typeString()
    }
    
    func typeString() {
        
    	// 1.定义一个字符串
    	var s1 string = "Hello world!"
    	fmt.Println(s1)
    	// 2. 字符串是不可变的, 指字符串一旦定义好，其中字符的值不能改变，但是字符串的引用可以改变。
    	s2 := "abc"
    	//s2[0] = 'q']
    	// 这里会改变字符串s2的引用
    	//s2 = "def"
    	fmt.Println(s2)
    
    	// 3.字符串的表示形式：
    	//（1）如果字符串中没有特殊字符，字符串的表示形式用双引号
    	s3 := "123ads"
    	fmt.Println(s3)
    	//（2）如果字符串中有特殊字符，字符串的表示形式用反引号 ``
    	s4 := `
    					package main
    					import "fmt"
    					func main() {
    						//
    					}`
    	fmt.Println(s4)
    
    	// 4.字符串拼接
    	s5 := "123" + "321asd"
    	fmt.Println(s5)
    
    }

**控制台输出：**  
![在这里插入图片描述][5a5bc3685cf44a2e9bf600fa8c110bd5.png]

### 2、复杂数据类型 ###

复杂数据类型见后面的文章

## 三、类型转换 ##

### 1、基本数据类型之间的转换 ###

#### 1）强制转换 ####

Go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换（强制转换）。

**语法：表达式 `T(v)` 将`值 v` 转换为`类型 T`；**

*  T : 是数据类型
 *  v : 是需要转换的变量
 *  强转后，变量v的类型不会发生改变

例如：将int转为float32

// 1. 进行类型转换：
    var n1 int = 100
    fmt.Println(n1)
    var n2 float32 = float32(n1)
    fmt.Println(n2)
    
    // n1的类型还是int，只是将n1的值100转为了float32赋值给n2而已。
    fmt.Printf("%T",n1)

##### 1> 强转报错：数据溢出 #####

**<1> 编译通过，执行时会数据溢出**

// 2. 强转报错：超过数据范围
    var n3 int64 = 888888
    var n4 int8 = int8(n3)
    // 将int64转为int8，编译不会出错，但是会数据溢出
    fmt.Println(n4)

##### 2> 数据溢出自动判断 #####

常量 + 一个变量，如果常量不超过相应类型的数据边界，可以编译通过；超过则编译不通过；

// 3. 数据溢出判断
    var n5 int64 = 12
    // 编译通过，但是结果可能会溢出
    var n6 int8 = int8(n5) + 127
    // 编译不会通过
    var n7 int8 = int8(n5) + 128
    fmt.Println(n7)
    fmt.Println(n6)

![在这里插入图片描述][0b878b9a2b8541ed89f755e6371597a1.png]

即使 `n5` 变量你声明为负数，依旧编译不通过；

![在这里插入图片描述][d5c5bb3bd2b7419ab7612e0bb157439f.png]

#### 2）其他基本类型转string ####

其他基本类型转string有两种方式：

1.  `fmt.Sprintf("%参数", 表达式)`，推荐使用；
2.  使用strconv包的函数；

##### 1> fmt.Sprintf #####

![在这里插入图片描述][cdbca22f3d2c4ca49f40723f86ddc2fe.png]

从[https://pkg.go.dev/fmt@go1.20.5\#Sprintf][https_pkg.go.dev_fmt_go1.20.5_Sprintf]文档中可以看到各种参数占位符；

![在这里插入图片描述][b21b728362254056832d8054c945b372.png]  
![在这里插入图片描述][b8db4b2818db4bca86006701e45bd09f.png]  
![在这里插入图片描述][d91d778aa6474c19988150a89c221b08.png]  
![在这里插入图片描述][3901fd954a424cce8abd48ba57b61bf0.png]

**（1）int 转 string：**

var n1 int = 6
    var s1 string = fmt.Sprintf("%d",n1)
    fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)

**（2）float32转 string：**

var n2 float32 = 6.78
    var s2 string = fmt.Sprintf("%f",n2)
    fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)

**（3）bool 转 string：**

var n3 bool = false
    var s3 string = fmt.Sprintf("%t",n3)
    fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)

**（4）byte 转 string：**

var n4 byte = 'd'
    var s4 string = fmt.Sprintf("%c",n4)
    fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)

**控制台输出：**  
![在这里插入图片描述][7a6bf656190c43669f36415556476cfc.png]

##### 2> strconv #####

API文档：[https://pkg.go.dev/strconv@go1.20.5\#FormatBool][https_pkg.go.dev_strconv_go1.20.5_FormatBool]

![在这里插入图片描述][a1c2b185bc82402cb99a3cc45cea7269.png]

var n1 int = 6
    // 参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制
    var s1 string = strconv.FormatInt(int64(n1),10)
    fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
    var n2 float64 = 6.78
    
    // 第二个参数：'f'表示格式化为（-ddd.dddd，不带指数形式）  第三个参数：9 保留小数点后面9位  第四个参数：表示这个小数是float64类型
    var s2 string = strconv.FormatFloat(n2,'f',9,64)
    fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
    
    var n3 bool = true
    var s3 string = strconv.FormatBool(n3)
    fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)

**控制台输出：**  
![在这里插入图片描述][0f90068631a344ae8ab201b971ff22f7.png]

#### 3）string转其他基本类型 ####

string转其他基本类型的方式为使用strconv包的函数，比如：strconv.ParseInt，strconv.ParseFloat

API文档：[https://pkg.go.dev/strconv@go1.20.5\#ParseBool][https_pkg.go.dev_strconv_go1.20.5_ParseBool]

![在这里插入图片描述][a3d360cadf0641d484d5f8b77b4da22f.png]

// string --> bool
    var s1 string = "true"
    var b bool
    // ParseBool函数的返回值有两个：(value bool, err error) ，value是我们得到的布尔类型的数据，err表示出现的错误
    // 如果只关注布尔类型的数据，err可以用_标识符接收、直接忽略掉。
    b , _ = strconv.ParseBool(s1)
    fmt.Printf("b的类型是：%T,b=%v \n",b,b)
    
    // string --> int64
    var s2 string = "19"
    var num1 int64
    num1,_ = strconv.ParseInt(s2,10,64)
    fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)
    
    // string --> float32/float64
    var s3 string = "3.14"
    var f1 float64
    f1,_ = strconv.ParseFloat(s3,64)
    fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)

**控制台输出：**  
![在这里插入图片描述][ca6f24bd9233417ea52640693e18ed66.png]

**PS：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果为：对应类型的默认值**

var s4 string = "golang"
    var b1 bool
    b1 , _ = strconv.ParseBool(s4)
    fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)
    
    var s5 string = "golang"
    var num2 int64
    num2,_ = strconv.ParseInt(s5,10,64)
    fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)

**控制台输出：**  
![在这里插入图片描述][1db445383e82488f81eb78db2867a793.png]

## 四、总结 ##

基本数据类型的默认值（`在Go中数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值(默认值又叫零值)`）为：  
![在这里插入图片描述][0ece07b2d8e34858aa5cf262e3edfc50.png]

### 对比着看Java的基本数据类型 ###

java的基本数据类型有8种：byte、short、int、long、float、double、boolean、char；

Go的基本类型有五种：

*  布尔型：关键字【bool】： true false
 *  整数类型：又细分为有符号整数类型和无符号整数类型；
    
     *  有符号整数类型（第一位代表正负）：int、int8、int16、int32、int64
     *  无符号整数类型：uint、uint8、uint16、uint32、uint64
 *  浮点类型：float32、float64
 *  字符串：string
 *  字符类型：byte（等同uint8，类似于一个别名），用于存放占 1 字节的 ASCII 字符，如英文字符，返回字符原始字节。
    
     *  rune（等同int32，只是一个别名），用于存放多字节字符，如占 3 字节的中文字符，返回字符 Unicode 码点值

**Java和Go基本数据类型的映射为：**

<table> 
 <thead> 
  <tr> 
   <th>Java</th> 
   <th>Go</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte（有符号型，字节数据类型）</td> 
   <td>byte（无符号型，等同uint8，类似一个别名）</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>int16</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>int32</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>int64</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>float32</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>float64</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>bool</td> 
  </tr> 
  <tr> 
   <td>char（无符号型，字符数据类型）</td> 
   <td>uint16</td> 
  </tr> 
 </tbody> 
</table>

**PS：**

*  Go中整型的默认类型为int，int是32还是64位取决于操作系统的位数；
 *  Go没有float类型，只有float32和float64
 *  Go中string也是基本数据类型。

[26456da6bcf74d8ab70094e321fbd199.png]: https://img-blog.csdnimg.cn/26456da6bcf74d8ab70094e321fbd199.png
[GO_Java_Golang]: https://blog.csdn.net/Saintmm/article/details/130793052
[2 Go_Hello World]: https://blog.csdn.net/Saintmm/article/details/130799639
[3 Go_API]: https://blog.csdn.net/Saintmm/article/details/130819239
[4 Go]: https://blog.csdn.net/Saintmm/article/details/130839198
[https_blog.csdn.net_saintmm_category_12326997.html]: https://blog.csdn.net/saintmm/category_12326997.html
[f65c783ada464ecfb7f4b29d33c907e2.png]: https://img-blog.csdnimg.cn/f65c783ada464ecfb7f4b29d33c907e2.png
[da955c73dd7e4c1b804d1932300ab951.png]: https://img-blog.csdnimg.cn/da955c73dd7e4c1b804d1932300ab951.png
[ab651cb8106844699c3ddd8289b0a959.png]: https://img-blog.csdnimg.cn/ab651cb8106844699c3ddd8289b0a959.png
[25b99125c0d04a829f5ab9d5eaa42e0d.png]: https://img-blog.csdnimg.cn/25b99125c0d04a829f5ab9d5eaa42e0d.png
[a39cdd949ed5468a94cb46d920bdcbd6.png]: https://img-blog.csdnimg.cn/a39cdd949ed5468a94cb46d920bdcbd6.png
[3377615ea07543529137085b0c5c4048.png]: https://img-blog.csdnimg.cn/3377615ea07543529137085b0c5c4048.png
[097f6b126f5b49f3aa3e0e34144e67f4.png]: https://img-blog.csdnimg.cn/097f6b126f5b49f3aa3e0e34144e67f4.png
[7e9461793740422d9e972b3289d93c23.png]: https://img-blog.csdnimg.cn/7e9461793740422d9e972b3289d93c23.png
[b8473bbb18c8435f812255f46795606c.png]: https://img-blog.csdnimg.cn/b8473bbb18c8435f812255f46795606c.png
[796db8b75b3e444a987cc8e3d98264fb.png]: https://img-blog.csdnimg.cn/796db8b75b3e444a987cc8e3d98264fb.png
[4c6bb51e9e1e4ec7a1b0a4d0a35e1f1a.png]: https://img-blog.csdnimg.cn/4c6bb51e9e1e4ec7a1b0a4d0a35e1f1a.png
[3630185477b04604b9a40aefd768003e.png]: https://img-blog.csdnimg.cn/3630185477b04604b9a40aefd768003e.png
[b242f03a2f454b5589a2e5984edfa7bc.png]: https://img-blog.csdnimg.cn/b242f03a2f454b5589a2e5984edfa7bc.png
[5a5bc3685cf44a2e9bf600fa8c110bd5.png]: https://img-blog.csdnimg.cn/5a5bc3685cf44a2e9bf600fa8c110bd5.png
[0b878b9a2b8541ed89f755e6371597a1.png]: https://img-blog.csdnimg.cn/0b878b9a2b8541ed89f755e6371597a1.png
[d5c5bb3bd2b7419ab7612e0bb157439f.png]: https://img-blog.csdnimg.cn/d5c5bb3bd2b7419ab7612e0bb157439f.png
[cdbca22f3d2c4ca49f40723f86ddc2fe.png]: https://img-blog.csdnimg.cn/cdbca22f3d2c4ca49f40723f86ddc2fe.png
[https_pkg.go.dev_fmt_go1.20.5_Sprintf]: https://pkg.go.dev/fmt@go1.20.5#Sprintf
[b21b728362254056832d8054c945b372.png]: https://img-blog.csdnimg.cn/b21b728362254056832d8054c945b372.png
[b8db4b2818db4bca86006701e45bd09f.png]: https://img-blog.csdnimg.cn/b8db4b2818db4bca86006701e45bd09f.png
[d91d778aa6474c19988150a89c221b08.png]: https://img-blog.csdnimg.cn/d91d778aa6474c19988150a89c221b08.png
[3901fd954a424cce8abd48ba57b61bf0.png]: https://img-blog.csdnimg.cn/3901fd954a424cce8abd48ba57b61bf0.png
[7a6bf656190c43669f36415556476cfc.png]: https://img-blog.csdnimg.cn/7a6bf656190c43669f36415556476cfc.png
[https_pkg.go.dev_strconv_go1.20.5_FormatBool]: https://pkg.go.dev/strconv@go1.20.5#FormatBool
[a1c2b185bc82402cb99a3cc45cea7269.png]: https://img-blog.csdnimg.cn/a1c2b185bc82402cb99a3cc45cea7269.png
[0f90068631a344ae8ab201b971ff22f7.png]: https://img-blog.csdnimg.cn/0f90068631a344ae8ab201b971ff22f7.png
[https_pkg.go.dev_strconv_go1.20.5_ParseBool]: https://pkg.go.dev/strconv@go1.20.5#ParseBool
[a3d360cadf0641d484d5f8b77b4da22f.png]: https://img-blog.csdnimg.cn/a3d360cadf0641d484d5f8b77b4da22f.png
[ca6f24bd9233417ea52640693e18ed66.png]: https://img-blog.csdnimg.cn/ca6f24bd9233417ea52640693e18ed66.png
[1db445383e82488f81eb78db2867a793.png]: https://img-blog.csdnimg.cn/1db445383e82488f81eb78db2867a793.png
[0ece07b2d8e34858aa5cf262e3edfc50.png]: https://img-blog.csdnimg.cn/0ece07b2d8e34858aa5cf262e3edfc50.png