[GO语言基础] 三.变量声明、数据类型、标识符及编程练习12题

谁践踏了优雅 2022-10-24 13:18 174阅读 0赞

作为网络安全初学者，会遇到采用Go语言开发的恶意样本。因此从今天开始从零讲解Golang编程语言，一方面是督促自己不断前行且学习新知识；另一方面是分享与读者，希望大家一起进步。**前文介绍了Go的编译运行、语法规范、注释转义及API标准库知识；这篇文章将介绍Golang的变量、数据类型和标识符知识，并通过12道编程练习进行提升。** 这系列文章入门部分将参考“尚硅谷”韩顺平老师的视频和书籍《GO高级编程》，详见参考文献，并结合作者多年的编程经验进行学习和丰富，且看且珍惜吧！后续会结合网络安全进行GO语言实战深入，加油~

这些年我学过各种编程语言，从最早的C语言到C++，再到C\#、PHP、JAVA，再到IOS开发、Python，到最新的GO语言，学得是真的杂。有时候觉得编程语言恰恰是最简单的，而通过一门编程语言能够解决实际问题或深入底层才是其价值所在，并且当我们学好一门编程语言后，其他编程语言都非常类似，殊途同归，学起来也很迅速。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center]

**源码下载地址：**

*  [https://github.com/eastmountyxz/Go-learning][https_github.com_eastmountyxz_Go-learning]

前文参考：

*  [\[GO语言基础\] 一.为什么我要学习Golang以及GO语言入门普及][GO_ _._Golang_GO]
 *  [\[GO语言基础\] 二.编译运行、语法规范、注释转义及API标准库知识普及][GO_ _._API]
 *  \[GO语言基础\] 三.变量声明、数据类型、标识符及编程练习12题

### 文章目录 ###

*  一.变量
 *   *  1.什么是变量
     *  2.变量的声明
     *  3.变量的注意事项
 *  二.数据类型
 *   *  1.整型
     *  2.浮点型
     *  3.字符类型
     *  4.布尔型
     *  5.字符串类型
     *  6.基本数据类型的默认值
     *  7.基本数据类型转换
     *  8.基本数据类型和string转换
 *  三.指针
 *   *  1.基本介绍
     *  2.指针类型
     *  3.获取指针类型所指向的值
     *  4.指针修改值
     *  5.值类型和引用类型
 *  四.标识符和关键字
 *   *  1.标识符
     *  2.关键字
 *  五.GO编程练习
 *   *  1.题目
     *  2.解答
 *  六.总结

--------------------

# 一.变量 #

## 1.什么是变量 ##

**为什么需要变量呢？**  
一个程序就是一个世界，不论使用哪种高级程序语言编写代码，变量都是其程序的基本组成单位。如下图所示的sum和sub都是变量。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 1]

**变量的定义：**  
变量相当于内存中一个数据存储空间的表示，可以将变量看作是一个房间的门牌号，通过门牌号能找到房间；通过变量名可以访问到变量的值。变量使用的常见三个步骤：

*  声明变量或定义变量
 *  变量赋值
 *  变量使用

![在这里插入图片描述][20210130173054222.png_pic_center]

**变量入门示例：**  
变量表示内存中的一个存储区域，该区域有自己的变量名和数据类型。下面是一个简单案例：

package main
    import "fmt"
    
    func main() { 
    	//定义变量
    	var n int
    	//赋值变量
    	n = 10
    	//使用变量
    	fmt.Println("n =", n)
    }

--------------------

## 2.变量的声明 ##

**Go语言变量使用的三种方式：**

*  (1) 指定变量类型，声明后若不复制，使用默认值，如int的默认值是0；  
    var i int  
    fmt.Println(“i =”, i)
 *  (2) 根据值自行判定变量类型（类型推导）；  
    var num = 3.14  
    fmt.Println(“num =”, num)
 *  (3) 省略var，=是赋值， :=是声明变量并赋值。注意 :=左侧变量不应该是已经声明过的，否则会编译错误  
    name := “eastmount”  
    fmt.Println(“name =”, name)  
    等价于  
    var name string  
    name = “eastmount”

package main
    import "fmt"
    
    func main() { 
    	//方法一：指定变量类型 int默认值为0
    	var i int
    	fmt.Println("i =", i)
    
    	//方法二：根据值自行判定变量类型
    	var num = 3.14
    	fmt.Println("num =", num)
    
    	//方法三：省略var :=声明变量并赋值
    	name := "eastmount"
    	fmt.Println("name =", name)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130162213300.png_pic_center]

**多变量声明：**  
在编程中，通常会遇到一次性声明多个变量的情况。Golang同样提供了对应的功能，如下所示：

*  var n1, n2, n3 int
 *  var n1, name, n3 = 100, “csdn”, 3.14
 *  n1, name, n3 := 100, “csdn”, 3.14

代码如下，注意不要重复定义变量，否则会报错。

package main
    import "fmt"
    
    func main() { 
    	//方法一：指定变量类型 int默认值为0
    	var n1, n2, n3 int
    	fmt.Println("n1 =", n1, "n2 =", n2, "n3 =", n3)
    
    	//方法二：根据值自行判定变量类型
    	var m1, name, m3 = 100, "csdn", 3.14
    	fmt.Println("m1 =", m1, "name =", name, "m3 =", m3)
    
    	//方法三：省略var :=声明变量并赋值
    	k1, k2, k3 := 100, "yxz", 3.14
    	fmt.Println("k1 =", k1, "k2 =", k2, "k3 =", k3)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130163656500.png_pic_center]

那么，如何一次性声明多个全局变量呢？

*  在Go中函数外部定义的变量就是全局变量
 *  全局变量如果只定义不使用，不会报错
 *  一次性声明

package main
    import "fmt"
    
    //定义全局变量
    var n = 100
    var m = 200
    var k = "eastmount"
    
    //等价于一次性声明
    var (
    	o = 300
    	p = 400
    	q = "yxz"
    )
    
    func main() { 
    	//输出全局变量
    	fmt.Println("n =", n, "m =", m, "k =", k)
    }

--------------------

## 3.变量的注意事项 ##

**注意事项：**

*  变量在某个区域的数据值可以在同一类型范围内不断变化，但不能改变数据类型（强类型转换）

![在这里插入图片描述][20210130170629620.png_pic_center]

*  变量在同一**作用域**（在一个函数或代码块）内不能重名

![在这里插入图片描述][20210130170858378.png_pic_center]

*  变量=变量名+值+数据类型，这一点大家需要注意，变量的三要素
 *  Golang的变量如果没有赋初值， 编译器会使用默认值，比如int为0，string为空串等

**变量知识总结：**

*  **声明变量**  
    基本语法：var 变量名 数据类型  
    比如“var n int”表示声明一个变量，变量名为n；“var num float32”表示声明一个单精度小数类型的变量
 *  **初始化变量**  
    在声明变量时赋初值，比如“var n int = 12”，如果声明时就直接赋值，可省略数据类型，比如“var m = 30”
 *  **变量赋值**  
    先声明变量“var num int”，此时默认值为0，再给变量赋值“num=78”

> **加号用法：**
> 
>  *  当左右两边都是数值型是，做加法运算
>  *  当左右两边都是字符串，做字符串拼接

package main
    import "fmt"
    
    func main() { 
    	//加法运算
    	var i, j = 2, 3
    	var res = i + j
    	fmt.Println("res =", res)
    
    	//字符串拼接
    	var str1 = "hello"
    	var str2 = "world"
    	var str3 = str1 + str2
    	fmt.Println("str3 =", str3)
    }

![在这里插入图片描述][2021013017154152.png_pic_center]

--------------------

# 二.数据类型 #

每一种数据都定义了明确的数据类型，并在内存中分配不同大小的内存空间。常用的数据类型分为基本数据类型和派生/复杂数据类型。

*  基本数据类型  
    数值型（整型、浮点型）、字符型（单个字符）、布尔型、字符串（Go中归属为基本数据类型）、复数类型（complex64、complex128）、rune
 *  派生/复杂数据类型  
    指针、数组、结构体、管道、函数、切片、接口、map

![在这里插入图片描述][20210129175420314.png_pic_center]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 2]

## 1.整型 ##

整数类型就是用于存放整数值，比如0、-2、23等。

**(1) 整形的各个类型**  
注意，一个字节为8位（bit），计算机采用二进制（0或1），即2^8表数范围。

*  有符号的int8表示为-128 ~ 127。下图bit7为符号位，最大值为bit0至bit6均为1，故为 2 7 − 1 2^7-1 27−1，即127；由于存在+0和-0，因此将 -0位赋值给负数，因此最小值为-128。
 *  无符号uint8表示为0 ~ 255。无符号最大值为bit0至bit7均为1，故为 2 8 − 1 2^8-1 28−1，即255。

![在这里插入图片描述][20210131113600454.png_pic_center]

<table> 
 <thead> 
 <tr> 
 <th align="center">类型</th> 
 <th align="center">有无符号</th> 
 <th align="center">占用存储空间</th> 
 <th align="center">表数范围</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="center">int8</td> 
 <td align="center">有</td> 
 <td align="center">1字节</td> 
 <td align="center"> − 128 ∼ 127 -128 \sim 127 −128∼127</td> 
 </tr> 
 <tr> 
 <td align="center">int16</td> 
 <td align="center">有</td> 
 <td align="center">2字节</td> 
 <td align="center"> − 2 15 ∼ 2 15 − 1 - 2^{15} \sim 2^{15}-1 −215∼215−1</td> 
 </tr> 
 <tr> 
 <td align="center">int32</td> 
 <td align="center">有</td> 
 <td align="center">4字节</td> 
 <td align="center"> − 2 31 ∼ 2 31 − 1 - 2^{31} \sim 2^{31}-1 −231∼231−1</td> 
 </tr> 
 <tr> 
 <td align="center">int64</td> 
 <td align="center">有</td> 
 <td align="center">8字节</td> 
 <td align="center"> − 2 63 ∼ 2 63 − 1 - 2^{63} \sim 2^{63}-1 −263∼263−1</td> 
 </tr> 
 </tbody> 
</table>

案例如下：

package main
    import "fmt"
    
    func main() { 
    	var i int = 1
    	fmt.Println("i =", i)
    
    	var j int8 = 127
    	fmt.Println("j =", j)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130191938321.png_pic_center]

**(2) 无符号整形**

案例如下，如果uint8赋值为256则会提示边界溢出“.\\type03\_01.go:14:6: constant 256 overflows uint8”。

![在这里插入图片描述][20210130192251588.png_pic_center]

**(3) 其他int类型**

<table> 
 <thead> 
 <tr> 
 <th align="center">类型</th> 
 <th align="center">有无符号</th> 
 <th align="center">占用存储空间</th> 
 <th align="center">表数范围</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="center">int</td> 
 <td align="center">有</td> 
 <td align="center">32位系统4个字节 64位系统8个字节</td> 
 <td align="center"> − 2 31 ∼ 2 31 − 1 − 2 63 ∼ 2 63 − 1 - 2^{31} \sim 2^{31}-1 \\ - 2^{63} \sim 2^{63}-1 −231∼231−1−263∼263−1</td> 
 </tr> 
 <tr> 
 <td align="center">uint</td> 
 <td align="center">无</td> 
 <td align="center">32位系统4个字节 64位系统8个字节</td> 
 <td align="center"> 0 ∼ 2 32 − 1 0 ∼ 2 64 − 1 0 \sim 2^{32}-1 \\ 0 \sim 2^{64}-1 0∼232−10∼264−1</td> 
 </tr> 
 <tr> 
 <td align="center">rune</td> 
 <td align="center">有</td> 
 <td align="center">与int32等价，表示一个unicode码，常用处理中文</td> 
 <td align="center"> − 2 31 ∼ 2 31 − 1 - 2^{31} \sim 2^{31}-1 −231∼231−1</td> 
 </tr> 
 <tr> 
 <td align="center">byte</td> 
 <td align="center">无</td> 
 <td align="center">与uint8等价，存储字符选用</td> 
 <td align="center"> 0 ∼ 255 0 \sim 255 0∼255</td> 
 </tr> 
 </tbody> 
</table>

案例如下：

package main
    import "fmt"
    
    func main() { 
    	var i int = -20
    	fmt.Println("i =", i)
    
    	var j uint = 127
    	fmt.Println("j =", j)
    
    	var k rune = 1024
    	fmt.Println("k =", k)
    
    	var m byte = 255
    	fmt.Println("m =", m)
    }

输出结果如下：

![在这里插入图片描述][20210130192656803.png_pic_center]

**(4) 整形的注意事项**

*  Golang各证书类型分为有符号和无符号，int、uint的大小和系统有关
 *  Golang的整型默认声明为int型
 *  查看某个变量的字节大小（unsafe.Sizeof）和数据类型（fmt.Printf->%T）
 *  Golang程序中整型变量使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型，比如年龄
 *  bit是计算机中最小存储单位，byte是计算机中基本存储单元（1 byte=8 bit）

package main
    import "fmt"
    import "unsafe"
    
    func main() { 
    	//查看变量的数据类型
    	//fmt.Printf() 用于格式化输出
    	var num int = 1024
    	fmt.Println("num =", num)
    	fmt.Printf("num 的数据类型是 %T \n", num)
    
    	//查看变量占用的空间大小
    	var n int64 = 10
    	var name = "eastmount"
    	fmt.Printf("n 的数据类型是 %T; 占用字节数是 %d \n", n, unsafe.Sizeof(n))
    	fmt.Printf("name 的数据类型是 %T; 占用字节数是 %d \n", name, unsafe.Sizeof(name))
    
    	//Golang程序中整型变量使用尽量遵守保小原则
    	//在保证程序正确运行下，尽量使用空间小的数据类型
    	var age byte = 28
    	fmt.Printf("n 的数据类型是 %T; 占用字节数是 %d \n", age, unsafe.Sizeof(age))
    }

输出结果如下图所示：

![在这里插入图片描述][20210130193953328.png_pic_center]

--------------------

## 2.浮点型 ##

浮点型用于存放小数，比如3.14、-1.9等，两种类型如下（没有double类型）。

*  单精度float32：4字节
 *  双精度float64：8字节

浮点数都是有符号的，浮点数在机器中存放形式为：

*  浮点数=符号位+指数位+尾数位

![在这里插入图片描述][20210131115118290.png_pic_center]

浮点数的尾数部分可能丢失，造成精度损失。

*  float64的精度要比float32准确，如果我们要保存一个高精度数据，则应该选用float64；软件开发中也推荐使用float64

package main
    import "fmt"
    
    func main() { 
    	//浮点数定义
    	var price float32 = 89.12
    	fmt.Println("price =", price)
    
    	var num1 float32 = -0.00081
    	var num2 float64 = -78942.00912
    	fmt.Println("num1 =", num1, "num2 =", num2)
    	
    	//精度损失
    	var num3 float32 = -123.0000203
    	var num4 float64 = -123.0000203
    	fmt.Println("\n精度损失")
    	fmt.Println("num3 =", num3, "num4 =", num4)
    }

输出结果如下图所示，可以看到float32精度损失。

![在这里插入图片描述][20210130203303814.png_pic_center]

**浮点数的注意事项**

*  Golang浮点类型包括float32和float64两种，不存在double类型
 *  Golang浮点类型有固定的范围和字段长度，不受具体操作系统的影响
 *  Golang的浮点型默认声明为float64类型
 *  浮点型常量有两种表示  
    – 十进制数形式，如：3.14、.1234，必须有小数点  
    – 科学技术法形式，如：5.1234e2=5.12\*10的2次方，5.12E-2=5.12/10的2次方
 *  通常情况推荐使用float64，它比float32更精确

package main
    import "fmt"
    import "unsafe"
    
    func main() { 
    	//浮点数默认声明为 float64类型
    	var num = 89.12
    	fmt.Printf("num的数据类型是 %T; 占用字节数是 %d \n", num, unsafe.Sizeof(num))
    
    	//十进制数形式
    	num1 := 3.14
    	num2 := .123
    	fmt.Println("num1 =", num1, "num2 =", num2)
    
    	//科学计数法形式
    	num3 := 1.234e2      //1.234 * 10的2次方
    	num4 := 1.234E2      //1.234 * 10的2次方
    	num5 := 1.234E-2     //1.234 / 10的2次方
    	fmt.Println("num3 =", num3, "num4 =", num4, "num5 =", num5)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130210532409.png_pic_center]

--------------------

## 3.字符类型 ##

Golang中没有专门的字符类型，如果要存储单个字符（字母），一般使用 byte 来保存（ASCII码表）。注意，是单个字母，而汉字是3个字节。

字符串是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的，也就是说传统的字符串是由字符组成的，**而Go的字符串不同，它是由字节组成的**。

举个简单示例：

*  如果保存的字符在ASCII表中，比如 \[0-9, a-z, A-Z, …\] 直接可以保存到byte
 *  如果保存的字符对应码值大于255，这是可以考虑使用int类型保存
 *  如果需要按照字符的方式输出，这是需要格式化输出，即fmt.Printf("%c", num)

package main
    import "fmt"
    
    func main() { 
    	//定义字符类型
    	var c1 byte = 'a'
    	var c2 byte = '6'
    
    	//当我们直接输出byte值 即输出对应字符的ASCII码值
    	fmt.Println("c1 =", c1)
    	fmt.Println("c2 =", c2)
    
    	//如果需要输出对应字符 需要使用格式化输出
    	fmt.Printf("c1=%c c2=%c\n", c1, c2)
    
    	//var c3 byte = '杨'
    	//overflow溢出
    	var c3 int = '杨'
    	fmt.Printf("c3=%c c3对应码值=%d\n", c3, c3)
    }

输出结果如下图所示，比如“杨”对应Unicode编码10进制为“26472”。由于ASCII码只能存储127个字符，英文字母和字符可以，但是中文字符或其他国家字符很多，故衍生出UTF-8其他编码方式。

![在这里插入图片描述][20210130212237871.png_pic_center]

**字符型的注意事项**

*  字符常量是用单引号（’）括起来的单个字符，例如var c1 byte=‘a’，var c2 int=‘中’
 *  Go中允许使用转义字符 \\’ 来讲其后的字符转变为特殊字符型常量，比如var c3 char = ‘\\n’，表示换行符
 *  Go语言的字符使用UTF-8编码，英文字母1个字节，汉字3个字节。如果想查询字对应的utf8编码，使用网址：  
    – [http://www.mytju.com/classcode/tools/encode\_utf8.asp][http_www.mytju.com_classcode_tools_encode_utf8.asp]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 3]

*  在Go中，字符的本质是一个整数，直接输出时，是该符对应的UTF-8编码的码字
 *  可以直接给某个变量赋一个数字，然后按格式化输出%c，会输出该数字对应的unicode字符
 *  字符类型可以进行运算，相当于一个整数，因为它都对应有Unicode编码

package main
    import "fmt"
    
    func main() { 
    	//直接赋值数字 格式化输出字符
    	var c1 int = 22269   // 22269->'国' 120->'x'
    	fmt.Printf("c1=%c\n", c1)
    
    	//字符类型可以运算 相当于一个整数 运算时按码值运行
    	var c2  = 10 + 'a'
    	fmt.Printf("c3=%c c3对应码值=%d\n", c2, c2)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130214501417.png_pic_center]

**字符类型本质探讨**

*  字符型存储到计算机中，需要将字符对应的码值（整数）找出来  
    – 存储：字符 -> 对应码值 -> 二进制 -> 存储  
    – 读取：二进制 -> 码值 -> 字符 -> 读取
 *  字符和码值的对应关系是通过字符编码表决定的，事先规定好的
 *  Go语言的编码都统一成utf-8，从而解决各种乱码问题

--------------------

## 4.布尔型 ##

布尔（bool）类型数据只允许取值true和false，用于表示真和假。它仅占1个字节，常用于逻辑运算，适用于程序流程控制（后续详细介绍）。

*  if条件控制语句
 *  for循环控制语句

下面举个简单的案例：

package main
    import "fmt"
    import "unsafe"
    
    func main() { 
    	//定义数据类型
    	var num = false
    	fmt.Println("num =", num)
    
    	//注意bool类型占用1个字节 只能取true或false
    	fmt.Println("占用空间 =", unsafe.Sizeof(num))
    }

输出结果如下：

![在这里插入图片描述][2021013021534620.png_pic_center]

**注意：Go语言中bool类型不可以使用0或非0的整数替代false或true，这和C语言不同。**

--------------------

## 5.字符串类型 ##

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

package main
    import "fmt"
    
    func main() { 
    	//定义字符串类型
    	var name string = "我的名字叫Eastmount!"
    	fmt.Println(name)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130220053500.png_pic_center]

**字符串的注意事项**

*  Go语言字符串的字符使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码，中文乱码问题不在困扰我们。编码问题一直是C语言、Java、Python2常见问题
 *  字符串一旦被复制，字符串就不能修改，即Go中字符串是不可变的（原子性）

![在这里插入图片描述][20210130220805515.png_pic_center]

**字符串两种表示形式**

*  双引号：会识别转移字符
 *  反引号：以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果

package main
    import "fmt"
    
    func main() { 
    	//双引号字符串
    	str1 := "Eastmount\nCSDN"
    	fmt.Println(str1)
    
    	//反引号字符串 ``
    	str2 := ` package main import "fmt" func main() { //定义字符串类型 var name string = "我的名字叫Eastmount!" fmt.Println(name) } `
    	fmt.Println(str2)
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 4]

**字符串拼接**

*  var str = “hello” + “world”
 *  str += “yangxiuzhang”

当一行字符串太长时，需要使用到多行字符串，可以进行如下处理：

![在这里插入图片描述][20210130221359231.png_pic_center]

--------------------

## 6.基本数据类型的默认值 ##

在Golang中，数据类型都有一个默认值，当程序员没有赋初值时，它就会保留默认值（或零值）。常见默认值如下图所示：

![在这里插入图片描述][20210130214658410.png_pic_center]

举例如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 5]

--------------------

## 7.基本数据类型转换 ##

Golang和Java、C不同，Go在不同类型的变量之间赋值时需要**显示转换**。换句话说，Golang中数据类型不能自动转换。

**强制转换基本语法**

*  表达式 T(v) 将值 v 转换为类型 T
 *  T：数据类型，比如int32、int64、float64等
 *  v：需要转换的变量

package main
    import "fmt"
    
    func main() { 
    	//数据类型转换
    	var a int32 = 100
    
    	//整型->浮点型
    	var b float32 = float32(a)
    	var c int8 = int8(a)
    
    	//低精度->高精度
    	var d int64 = int64(a)
    	fmt.Printf("a=%v b=%v c=%v d=%v\n", a, b, c, d)
    	fmt.Printf("a=%T b=%T c=%T d=%T\n", a, b, c, d)
    
    	//浮点型->整型
    	var e float32 = 3.14
    	var f int32 = int32(e)
    	fmt.Printf("e=%v f=%v\n", e, f)
    	fmt.Printf("e=%T f=%T\n", e, f)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130223643801.png_pic_center]

**注意事项**

*  Go中数据类型的转换可以从表示范围小到表示范围大，也可以从范围大到范围小
 *  被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化
 *  在转换中，比如将 int64 转换成 int8（-128到127），编译时不会报错，只是转换的结果按溢出处理，和期待的结果不一样。因此在转换时，需要考虑范围

![在这里插入图片描述][20210130225332834.png_pic_center]

*  数据类型不一致的运算错误，建议转换成相同的数据类型。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 6]

由于n3是int8类型，赋值语句含128所以编译不通过；而n4也是int8类型，但编译能通过，结果溢出处理。

![在这里插入图片描述][20210130225848167.png_pic_center]

--------------------

## 8.基本数据类型和string转换 ##

在程序开发中，经常将基本数据类型转换成string或将string转换成基本数据类型。

**(1) 基本数据类型转换成string**

*  方法1：fmt.Sprintf("%参数", 表达式)  
    Sprintf根据format参数生成格式化的字符串并返回该字符串，参数需要和表达式的数据类型匹配。

![在这里插入图片描述][20210130230432936.png_pic_center]

代码如下：

package main
    import "fmt"
    
    func main() { 
    	//变量定义
    	var num1 int = 99
    	var num2 float64 = 3.14
    	var b bool = true
    	var char byte = 'h'
    	var str 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", char)
    	fmt.Printf("str type %T str=%q\n", str, str)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130231855702.png_pic_center]

*  方法2：使用strconv包的函数  
    – func FormatBool(b bool) string  
    – func FormatFloat(f float64, fmt byte, prec, bitSize int) string  
    – func FormatInt(i int64, base int) string  
    – func FormatUint(i uint64, base int) string  
    – func Itoa(int(num))

package main
    import "fmt"
    import "strconv"
    
    func main() { 
    	//变量定义
    	var num1 int = 99
    	var num2 float64 = 3.14
    	var b bool = true
    	var num3 int64 = 4567
    	var str string
    	
    	//strconv.FormatInt 10进制
    	str = strconv.FormatInt(int64(num1), 10)
    	fmt.Printf("str type %T str=%q\n", str, str)
    
    	//strconv.FormatFloat(num2, 'f', 10, 64)
    	//说明：'f'格式 10表示小数位保留10位 64表示小数float64
    	str = strconv.FormatFloat(num2, 'f', 10, 64)
    	fmt.Printf("str type %T str=%q\n", str, str)
    
    	str = strconv.FormatBool(b)
    	fmt.Printf("str type %T str=%q\n", str, str)
    
    	str = strconv.Itoa(int(num3))
    	fmt.Printf("str type %T str=%q\n", str, str)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130233120193.png_pic_center]

**(2) string类型转基本数据类型**  
使用strconv包的函数：

*  func ParseBool(str string) (value bool, err error)
 *  func ParseFloat(s string, bitSize int) (f float64, err error)
 *  func ParseInt(s string, base int, bitSize int) (i int64, err error)
 *  func ParseUint(s string, b int, bitSize int) (n uint64, err error)

需要说明，因为返回的是int64或float64，如希望得到int32、float32，则需要调用 int32(num)处理。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 7]

注意：在将String类型转换成基本数据类型时，**要确保String类型能够转成有效的数据**。比如把“123”转成一个整数，但不能把“hello”转成一个整数；如果这样Go直接将其转成0，其他类型也是同样的道理，float转成0、bool转成false。

![在这里插入图片描述][20210131145205150.png_pic_center]

--------------------

# 三.指针 #

## 1.基本介绍 ##

由于后续很多内容（如引用）都会涉及到指针，C语言中它也是一个难点，因此这里我们先介绍指针的基础知识，更好地帮助我们学习Golang。

对于基本数据类型来说，变量存的就是值，也叫值类型。获取变量的地址使用“&”，比如：

*  var num int
 *  获取num的地址是&num

package main
    import "fmt"
    
    func main() { 
    	//基本数据类型在内存布局
    	var i int = 10
    	//i的地址 &i
    	fmt.Println("i的地址=", &i)
    	fmt.Println("i的值=", i)
    }

输出结果：

i的地址= 0xc0000100a0
    i的值= 10

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 8]

--------------------

## 2.指针类型 ##

指针变量存的是一个地址，这个地址指向的空间存的才是值，比如：

*  var ptr \*int = &num

举例说明指针在内存的布局。

![在这里插入图片描述][202101302350267.png_pic_center]

package main
    import "fmt"
    
    func main() { 
    	//基本数据类型在内存布局
    	var i int = 10
    	//i的地址 &i
    	fmt.Println("i的地址=", &i)
    	fmt.Println("i的值=", i)
    
    	/* var ptr *int = &i 1.ptr是一个指针变量 2.ptr的类型是*int 3.ptr本身的值是&i */
    	var ptr *int = &i
    	fmt.Printf("ptr=%v\n", ptr)
    }

输出结果如下图所示：

![在这里插入图片描述][20210130235554213.png_pic_center]

--------------------

## 3.获取指针类型所指向的值 ##

使用 \* 实现，比如 var ptr *int，使用*ptr获取ptr指向的值。

输出结果如下所示：

*  i的地址= 0xc0000100a0
 *  i的值= 10
 *  ptr=0xc0000100a0
 *  ptr的地址=0xc000006030
 *  ptr指向的值=10

举例说明：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 9]

--------------------

## 4.指针修改值 ##

编写一个程序，获取一个int变量num的地址并显示终端；再将num的地址赋值给指针ptr，通过ptr去修改num的值。

package main
    import "fmt"
    
    func main() { 
    	//基本数据类型
    	var num int = 10
    	fmt.Printf("num的地址=%v 原始值=%v\n", &num, num)
    
    	//指针
    	var ptr *int
    	ptr = &num
    	fmt.Printf("ptr的地址=%v 指向的值为=%v 自身=%v\n", &ptr, *ptr, ptr)
    
    	//修改值
    	*ptr = 666
    	fmt.Printf("num修改后的值=%v\n", num)
    }

输出结果如下图所示：

![在这里插入图片描述][20210131001537164.png_pic_center]

下面这三个练习也推荐大家尝试。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 10]

--------------------

## 5.值类型和引用类型 ##

(1) 值类型

*  **值类型**：有对应的指针类型，形式为“ \*数据类型 ”，比如int对应的指针就是“\*int”，float32对应的指针类型就是“\*float32”，以此类推
 *  **值类型的基本数据类型包括：int、float、bool、string、数组和结构体struct**
 *  值类型：变量直接存储值，内存通常在栈中分配

![在这里插入图片描述][20210131002055822.png_pic_center]

(2) 引用类型

*  变量存储的一个地址，这个地址对应的空间才是真正存储数据（值），内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾空间，由GC来回收。  
    **- 引用类型的基本数据类型包括：指针、slice切片、map、管道、interface等**

![在这里插入图片描述][20210131002339455.png_pic_center]

内存的栈区和堆区示意图如下：

![在这里插入图片描述][20210131002359460.png_pic_center]

--------------------

# 四.标识符和关键字 #

## 1.标识符 ##

Golang对各种变量、方法和函数等命名时使用的字符序列称为标识符。凡是自己可以起名字的地方也都叫标识符。其命名规则如下：

*  由26个英文字母大小写、0-9、下划线（\_）组成
 *  数字不可以开头，比如正确的“var num int”、错误的“var 3num int”
 *  Golang中严格区分大小写，Name和name是两个不同的变量
 *  标识符不能包含空格
 *  下划线（\_）本身在Go中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略，所以仅能作为占位符使用，不能作为标识符使用
 *  不能以系统保留关键字作为标识符（一共有25个），比如break、if等

![在这里插入图片描述][20210131002916877.png_pic_center]

标识符命名注意事项：

*  包名：保持package的名字和目录尽量保持一致，建议采取有意义的包名，不要和标准库冲突（大家可以去Go开源代码学习下包名）。

![在这里插入图片描述][20210131003255864.png_pic_center]

*  变量名、函数名、常量名建议采用驼峰法命名  
    比如：var stuName string = “csdn”，形如xxxYyyyZzzz…
 *  如果变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用（ **首字母大写是公开的，首字母小写是私有的** ），在Golang中没有public、private等关键字，这也是Go与其他语言的区别

举例说明，首先在utils.go中定义一个变量；然后在main.go中使用该变量。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 11]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 12]

untils.go

package model
    
    //定义一个变量
    var HeroName string = "武松"

main.go

package main
    import (
    	"fmt"
    	//导入utils.go文件的变量或函数 引入该model包
    	"go_code/chapter03/datatype/model"
    )
    
    func main() { 
    	//该区域的数据可以在同一类型范围内变化
    	var n int = 10
    	n = 30
    	n = 50
    	fmt.Println("n=", n)
    
    	//使用utils.go的HeroName变量 包名.标志符
    	fmt.Println(model.HeroName)
    }

输出结果如下图所示：

![在这里插入图片描述][20210131111050743.png_pic_center]

如果变量名定义时是小写“heroNam”则会报错

![在这里插入图片描述][20210131151359314.png_pic_center]

--------------------

## 2.关键字 ##

在Go中，为简化代码编译过程中对代码的解析，系统仅保留25个关键字，如下表所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 13]

除了保留关键字外，Go还提供了36个预定的标志符，包括基础数据类型和系统内嵌函数。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 14]

--------------------

# 五.GO编程练习 #

## 1.题目 ##

**(1) 分别定义常见的数据类型（整型、浮点型、字符型、布尔型、字符串型）变量，输出对应结果并查看变量的空间大小、数据类型。**

变量名称        数据类型        占用空间        对应的值
    num1     int     8       -12
    num2     uint8   1       127
    num3     int64   8       12345
    num4     float32         4       3.14
    num5     float64         8       314.15
    num6     int     8       26472
    num7     bool    1       false
    num8     string          16      Eastmount

**(2) 判断数字9的奇偶性输出它是奇数或偶数。**

num = 9
    这是一个奇数

**(3) 有人用温度计测量出华氏法表示的温度（如69°F），先要求把它转换为以摄氏法表示的温度（如20°C），输入值为69。**

![在这里插入图片描述][20210130173015442.png_pic_center]

华氏度 f= 69
    摄氏度 c= 20.555555555555557
    摄氏度取整 c= 20

**(4) 通过两种方法（调用函数和循环）实现计算字符串“Eastmount”长度。**

The length of "Eastmount" is 9.
    E a s t m o u n t
    The length of "Eastmount" is 9.

**(5) 循环依次输出“East 秀璋”字符串的所有字符。**

Unicode遍历字符串
    Unicode: E  69
    Unicode: a  97
    Unicode: s  115
    Unicode: t  116
    Unicode:    32
    Unicode: 秀  31168
    Unicode: 璋  29835
    
    utf-8遍历字符串
    Unicode: E  69
    Unicode: a  97
    Unicode: s  115
    Unicode: t  116
    Unicode:    32
    Unicode: ç  231
    Unicode: §  167
    Unicode: €  128
    Unicode: ç  231
    Unicode: ’  146
    Unicode: ‹  139

**(6) 实现字符串循环拼接，将变量str拼接成“a”到“z”并输出。**

abcdefghijklmnopqrstuvwxyz

**(7) 从键盘上输入整数、浮点数和字符，然后赋值给变量并输出结果。**

Eastmount
    28
    60.2
    我的名字是: Eastmount
    我的年龄是: 28
    我的体重是: 60.2

**(8) 任意输入一个字母，实现大小写自动转换输出。**

请输入任意字母:
    A
    对应的ASCII码值: 65
    A => a
    
    请输入任意字母:
    h
    对应的ASCII码值: 104
    h => H

**(9) 实现多种数据类型转换（int和float转换、float和string转换）。**

a=100 int32, b=100 float32
    c=3.14 float32, d=3 int32
    e=3.14 float64, f=3.140000 string
    e=123.456 string, f=123.456 float64

**(10) 指针基本概念，定义变量i，然后指针ptr指向该值，输出对应值及地址。**

i的地址= 0xc0000100a0
    i的值= 10
    ptr=0xc0000100a0
    ptr的地址=0xc000006030
    ptr指向的值=10

**(11) 编写一个程序，获取一个int变量num的地址并显示终端；再将num的地址赋值给指针ptr，通过ptr去修改num的值。**

666
    num的地址= 0xc0000100a0
    num的值= 54
    ptr的地址=0xc000006030
    ptr指向的值=54
    
    修改值后: num=512 0xc0000100a0
    修改值后: ptr=512 0xc000006030

**(12) 输入a和b两个整数，调用指针按从大到小的顺序输出a和b。**

20 88
    a=88, b=20
    max=88, min=20    //p1和p2

--------------------

## 2.解答 ##

> 注意：程序实现的方法由千万种，作者更多是提供一个场景让你独立思考，独立解决问题。希望你喜欢这些题目，不要觉得枯燥，很多题目后续都会结合实际项目及经验进行介绍。

**(1) 分别定义常见的数据类型（整型、浮点型、字符型、布尔型、字符串型）变量，输出对应结果并查看变量的空间大小、数据类型。**

*  查看某个变量的字节大小（unsafe.Sizeof）和数据类型（fmt.Printf->%T）

package main
    import "fmt"
    import "unsafe"
    
    func main() { 
    	var num1 int = -12
    	fmt.Println("变量名称\t数据类型\t占用空间\t对应的值")
    	fmt.Printf("num1 \t %T \t %d \t %v \n", num1, unsafe.Sizeof(num1), num1)
    
    	var num2 byte = 127
    	fmt.Printf("num2 \t %T \t %d \t %v \n", num2, unsafe.Sizeof(num2), num2)
    
    	var num3 int64 = 12345
    	fmt.Printf("num3 \t %T \t %d \t %v \n", num3, unsafe.Sizeof(num3), num3)
    
    	var num4 float32 = 3.14
    	fmt.Printf("num4 \t %T \t %d \t %v \n", num4, unsafe.Sizeof(num4), num4)
    
    	var num5 float64 = 3.1415e2
    	fmt.Printf("num5 \t %T \t %d \t %v \n", num5, unsafe.Sizeof(num5), num5)
    
    	var num6 int = '杨'
    	fmt.Printf("num6 \t %T \t %d \t %v \n", num6, unsafe.Sizeof(num6), num6)
    
    	var num7 bool = false
    	fmt.Printf("num7 \t %T \t %d \t %v \n", num7, unsafe.Sizeof(num7), num7)
    
    	var num8 string = "Eastmount"
    	fmt.Printf("num8 \t %T \t %d \t %v \n", num8, unsafe.Sizeof(num8), num8)
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 15]

--------------------

**(2) 判断数字9的奇偶性输出它是奇数或偶数。**

package main
    import "fmt"
    
    func main() { 
    	var num int = 9
    	fmt.Println("num =", num)
    
    	//判断奇偶性
    	if num % 2 == 0 { 
    		fmt.Println("这是一个偶数")
    	} else { 
    		fmt.Println("这是一个奇数")
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][20210131153245588.png_pic_center]

--------------------

**(3) 有人用温度计测量出华氏法表示的温度（如69°F），先要求把它转换为以摄氏法表示的温度（如20°C），输入值为69。**

package main
    import "fmt"
    
    func main() { 
    	var f float64
    	var c float64
    
    	//温度转换
    	f = 69.0
    	c = (5.0 / 9) * (f - 32)
    	fmt.Println("华氏度 f=", f)
    	fmt.Println("摄氏度 c=", c)
    	fmt.Println("摄氏度整数 c=", int64(c))
    }

输出结果如下图所示：

![在这里插入图片描述][20210131153947381.png_pic_center]

--------------------

**(4) 通过两种方法（调用函数和循环）实现计算字符串“Eastmount”长度。**

package main
    import "fmt"
     
    func main() { 
        var str string
    	str = "Eastmount"
    
    	//计算字符串长度
    	fmt.Printf("The length of \"%s\" is %d. \n", str, len(str))
    	
    	//循环计算字符串长度
    	var num int = 0
    	for _, s := range str { 
    		fmt.Printf("%c ", s)
    		num += 1
    	}
    	fmt.Printf("\nThe length of \"%s\" is %d. \n", str, num)
    }

输出结果如下图所示：

![在这里插入图片描述][20210131160827905.png_pic_center]

注意，当字符串中包含多字节字符时，要用到标准库utf8中的RuneCountInString函数来获取字符串的长度。代码如下：

package main
    import (
        "fmt"
        "unicode/utf8"
    )
     
    func main() { 
    	//多字节字符
    	test := "Hello, 世界"
    	fmt.Println("bytes =", len(test))                      //bytes = 13
        fmt.Println("runes =", utf8.RuneCountInString(test))   //runes = 9
    }

--------------------

**(5) 循环依次输出“East 秀璋”字符串的所有字符。**

package main
 import "fmt"
 
 func main() { 
 	str := "East 秀璋"
 
 	//方法1：Unicode遍历字符串
 	fmt.Printf("Unicode遍历字符串\n")
 	for _, s := range str { 
 		fmt.Printf("Unicode: %c %d\n", s, s)
 	}
 	
 
 	//方法2：utf-8遍历字符串
 	fmt.Printf("utf-8遍历字符串\n")
 	for i := 0; i < len(str); i++ { 
 		ch := str[i]
 		fmt.Printf("Unicode: %c %d\n", ch, ch)
 	}
 }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 16]

--------------------

**(6) 实现字符串循环拼接，将变量str拼接成“a”到“z”并输出。**

package main
 import "fmt"
 
 func main() { 
 	var str string
 	var tt string
 	var ch byte = 'a'
 
 	for i := 0; i < 26; i++ { 
 		tt = fmt.Sprintf("%c", ch)
 		str += tt
 		ch += 1
 	}
 	fmt.Println(str)
 }

上述代码注意类型转换，输出结果如下图所示：

![在这里插入图片描述][20210131164707596.png_pic_center]

--------------------

**(7) 从键盘上输入整数、浮点数和字符，然后赋值给变量并输出结果。**

*  第一种: fmt.Scan(地址列表)  
    参数传入地址列表。输入变量之间可以采用空格或者换行
 *  第二种: fmt.Scanln(地址列表)  
    与Scan不同在于自带换行，因此输入变量间不能采用换行
 *  第三种:fmt.Scanf(“格式化字符串”, 地址列表)格式化输入  
    限制固定的输入格式

package main
    import "fmt"
    
    func main() { 
    	var (
    		name string
    		age int
    		weight float32
    	)
    
    	//从终端获取用户的输入内容
    	fmt.Scan(&name, &age, &weight)
    	fmt.Println("我的名字是:", name)
    	fmt.Println("我的年龄是:", age)
    	fmt.Println("我的体重是:", weight)
    }

输出结果如下图所示：

![在这里插入图片描述][20210131165312747.png_pic_center]

--------------------

**(8) 任意输入一个字母，实现大小写自动转换输出。**

*  A的ASCII码值为65，a的ASCII码值为97

package main
 import "fmt"
 
 func main() { 
 	var ch byte
 	var re byte
 
 	//从终端获取用户的输入内容
 	fmt.Println("请输入任意字母:")
 	fmt.Scanf("%c", &ch)
 	fmt.Println("对应的ASCII码值:", ch)
 
 	//大小写转换
 	if ch >= 'A' && ch <= 'Z' { 
 		re = ch + 32
 	} else if ch >= 'a' && ch <= 'z' { 
 		re = ch - 32
 	}
 	fmt.Printf("%c => %c", ch, re)
 }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 17]

--------------------

**(9) 实现多种数据类型转换（int和float转换、float和string转换）。**

package main
    import "fmt"
    import "strconv"
    
    func main() { 
    	//整型->浮点型
    	var a int32 = 100
    	var b float32 = float32(a)
    	fmt.Printf("a=%v %T, b=%v %T\n", a, a, b, b)
    
    	//浮点型->整型
    	var c float32 = 3.14
    	var d int32 = int32(c)
    	fmt.Printf("c=%v %T, d=%v %T\n", c, c, d, d)
    
    	//其他类型->string
    	var e float64 = 3.14
    	var f string
    	f = fmt.Sprintf("%f", e)
    	fmt.Printf("e=%v %T, f=%v %T\n", e, e, f, f)
    
    	//string->其他类型
    	var g string = "123.456"
    	var h float64
    	h, _ = strconv.ParseFloat(g, 64)
    	fmt.Printf("e=%v %T, f=%v %T\n", g, g, h, h)
    }

输出结果如下图所示：

![在这里插入图片描述][2021013117184490.png_pic_center]

--------------------

**(10) 指针基本概念，定义变量i，然后指针ptr指向该值，输出对应值及地址。**

输出结果如下图所示：

![在这里插入图片描述][20210131172150431.png_pic_center]

--------------------

**(11) 编写一个程序，获取一个int变量num的地址并显示终端；再将num的地址赋值给指针ptr，通过ptr去修改num的值。**

package main
    import "fmt"
    
    func main() { 
    	//获取一个int变量num的地址并显示终端
    	var num int
    	fmt.Scanf("%c", &num)
    	fmt.Println("num的地址=", &num)
    	fmt.Println("num的值=", num)
    
    	//定义ptr指针变量
    	var ptr *int = &num
    	fmt.Printf("ptr的地址=%v\n", &ptr)
    	fmt.Printf("ptr指向的值=%v\n", *ptr)
    
    	//通过ptr去修改num的值
    	*ptr = 512
    	fmt.Printf("修改值后: num=%d %v\n", num, &num)
    	fmt.Printf("修改值后: ptr=%d %v\n", *ptr, &ptr)
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 18]

--------------------

**(12) 输入a和b两个整数，调用指针按从大到小的顺序输出a和b。**

*  解题：用指针方法来处理，不交换整型变量的值，而是交换两个指针变量的值

package main
 import "fmt"
 
 func main() { 
 	//变量定义
 	var a int
 	var b int
 	
 	//输入两个整数
 	fmt.Println("请输入两个整数:")
 	fmt.Scanf("%d %d", &a, &b)
 
 	//p1指向a p2指向b
 	var p1 *int = &a
 	var p2 *int = &b
 	var p *int
 
 	//如果a<b则交换p1与p2的值 a存储大值
 	if a < b { 
 		p = p1
 		p1 = p2
 		p2 = p
 	}
 
 	//从大到小输出a、b结果
 	fmt.Printf("a=%v, b=%v\n", a, b)
 
 	//输出p1和p2所指向变量的值
 	fmt.Printf("max=%v, min=%v\n", *p1, *p2)
 }

输出结果如下图所示，但遗憾的是a和b值并没有交换，而p1确实指向较大值，p2指向较小值。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 19]

这与C语言也存在一些差异，C语言代码如下，请大家下来思考具体原因。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 20]

--------------------

# 六.总结 #

写到这里，这篇基础性Golang文章介绍完毕，希望您喜欢！

*  **一.变量**  
    1.什么是变量  
    2.变量的声明  
    3.变量的注意事项
 *  **二.数据类型**  
    1.整型  
    2.浮点型  
    3.字符类型  
    4.布尔型  
    5.字符串类型  
    6.基本数据类型的默认值  
    7.基本数据类型转换  
    8.基本数据类型和string转换
 *  **三.指针**  
    1.基本介绍  
    2.指针类型  
    3.获取指针类型所指向的值  
    4.指针修改值  
    5.值类型和引用类型
 *  **四.标识符和关键字**  
    1.标识符  
    2.关键字
 *  **五.GO编程练习**  
    1.题目  
    2.解答

Go基本概念和数据类型了解后，后面的文章将详细介绍Go语言的运算、条件语句和循环语句知识，并结合案例进行普及。希望这篇基础性文章对您有帮助，写得不好的地方还请海涵。同时非常感谢参考文献中的大佬们的文章分享，尤其是韩顺平老师，深知自己很菜，得努力前行。也希望自己能深入下去，未来四年好好研究Go编程语言，做更多实际工程，写更好的文章，共勉！

源代码下载地址：

*  [https://github.com/eastmountyxz/Go-learning][https_github.com_eastmountyxz_Go-learning]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 21]

2020年8月18新开的“娜璋AI安全之家”，主要围绕Python大数据分析、网络空间安全、人工智能、Web渗透及攻防技术进行讲解，同时分享论文的算法实现。娜璋之家会更加系统，并重构作者的所有文章，从零讲解Python和安全，写了近十年文章，真心想把自己所学所感所做分享出来，还请各位多多指教，真诚邀请您的关注！谢谢。

![在这里插入图片描述][20210129020034946.png_pic_center]

(By:娜璋AI之家 Eastmount 2021-01-31 星期天 夜于贵阳 [https://blog.csdn.net/Eastmount][https_blog.csdn.net_Eastmount])

--------------------

**参考文献：**

*  Go官网：[https://golang.org/][https_golang.org]
 *  韩老师视频：[https://www.bilibili.com/video/BV1pt41127FZ][https_www.bilibili.com_video_BV1pt41127FZ]
 *  [https://www.runoob.com/go/go-tutorial.html][https_www.runoob.com_go_go-tutorial.html]
 *  Go中文网在线标准库文档：[https://studygolang.com/pkgdoc][https_studygolang.com_pkgdoc]

--------------------

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/c9c80d2c7a8c4db2accf903500b2e39c.png
[https_github.com_eastmountyxz_Go-learning]: https://github.com/eastmountyxz/Go-learning
[GO_ _._Golang_GO]: https://blog.csdn.net/Eastmount/article/details/111150449
[GO_ _._API]: https://blog.csdn.net/Eastmount/article/details/113151363
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/7737a2474ea94b56adfadfd96fa71f6a.png
[20210130173054222.png_pic_center]: /images/20221024/9dbe7d2d5f5e4434bffb42c4918549d5.png
[20210130162213300.png_pic_center]: /images/20221024/8be784b695e648b2bf3f78fe7b954e67.png
[20210130163656500.png_pic_center]: /images/20221024/cb03d197b0bc44f5a8c01a214d35bb6a.png
[20210130170629620.png_pic_center]: /images/20221024/a648e57521b04a839e25fab8717016c5.png
[20210130170858378.png_pic_center]: /images/20221024/3b7ddf18b34048178eb46b4232f452e6.png
[2021013017154152.png_pic_center]: /images/20221024/4f1a865080254b8e8bd5cefc4d2056b8.png
[20210129175420314.png_pic_center]: /images/20221024/63a9fa2a5905403d92f41be6d654a566.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221024/5e61047ed8fc4ed6a35039f2a8bd9998.png
[20210131113600454.png_pic_center]: /images/20221024/f4b22913f2c24ea09dbedc6d0de90c42.png
[20210130191938321.png_pic_center]: /images/20221024/b594ab4140aa420ca5ab956f6df6d9e8.png
[20210130192251588.png_pic_center]: /images/20221024/5f6edc6126ce4ea68f7c4a2b50689a81.png
[20210130192656803.png_pic_center]: /images/20221024/aa1ef11fd2c04de480d8392717c40c90.png
[20210130193953328.png_pic_center]: /images/20221024/de02b7bfc0dc4bb0b7cdeed632df2f9d.png
[20210131115118290.png_pic_center]: /images/20221024/0d8acf9a069041468de2991ba76e4cf4.png
[20210130203303814.png_pic_center]: /images/20221024/6be76705684f427793e74c6413cad786.png
[20210130210532409.png_pic_center]: /images/20221024/c500794c637e4133a52c662fe2e1a2d0.png
[20210130212237871.png_pic_center]: /images/20221024/b6263790ad61475abfe15d6ffed78747.png
[http_www.mytju.com_classcode_tools_encode_utf8.asp]: http://www.mytju.com/classcode/tools/encode_utf8.asp
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221024/517d273a7a9942d68473a68e35e7e90a.png
[20210130214501417.png_pic_center]: /images/20221024/961dc81342d340649574235626043867.png
[2021013021534620.png_pic_center]: /images/20221024/7dde13cc49f04c21bb0670e47274fb60.png
[20210130220053500.png_pic_center]: /images/20221024/1019c6c75e11451d989ddb2a2bcda23e.png
[20210130220805515.png_pic_center]: /images/20221024/c1c049ccc4784a6badf6370ef57aa6ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221024/0575c4ea58684dc1953d8ea0c51be610.png
[20210130221359231.png_pic_center]: /images/20221024/d6f1fd321a2049fa99960defc91f5ae6.png
[20210130214658410.png_pic_center]: /images/20221024/33ff7d47513e4fe88cf815b14e79358c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221024/5e7bd9c283874d7396b048ed2ce9273e.png
[20210130223643801.png_pic_center]: /images/20221024/4e061d965e2c4c158941626dfd4a5f65.png
[20210130225332834.png_pic_center]: /images/20221024/401b1221f4854b5a88cb3ee08266239a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221024/47bac29d2a8043c2a4c750b38b69d010.png
[20210130225848167.png_pic_center]: /images/20221024/7e14f12256cb41d199052d1c04dde35f.png
[20210130230432936.png_pic_center]: /images/20221024/60d4c4421777437fad9ba63683d14fc5.png
[20210130231855702.png_pic_center]: /images/20221024/085ddbf37c2c4b03972791887f4dbf95.png
[20210130233120193.png_pic_center]: /images/20221024/ba5600ef406847e185c200c1ce866d8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221024/fee3bd36d41a4b2eb32559b2250911fb.png
[20210131145205150.png_pic_center]: /images/20221024/4adc9d6102c045d4a771fe8585737ff4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221024/d1008b3b2cf349c8b9864daae87c148b.png
[202101302350267.png_pic_center]: /images/20221024/a62fd55f13d342b598df508276e20f3d.png
[20210130235554213.png_pic_center]: /images/20221024/9d9a71ba4b61407988f30a472992e257.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221024/c4795d38223e407fa0075daad4191e80.png
[20210131001537164.png_pic_center]: /images/20221024/2789d9353151484c87e3307ac9adb573.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221024/f3a0034334424b399fdc48061f854ed0.png
[20210131002055822.png_pic_center]: /images/20221024/f996c5f4af0546a598102c171a9cfc3a.png
[20210131002339455.png_pic_center]: /images/20221024/eedd93e03deb4a68ac401fbda6e1bd5b.png
[20210131002359460.png_pic_center]: /images/20221024/edad78268a2e4090a0a4cb45e214aefe.png
[20210131002916877.png_pic_center]: /images/20221024/ceed404f3d6b4242bb9557fd4018d6f2.png
[20210131003255864.png_pic_center]: /images/20221024/cc54229eed83479287fd9eeb031acfc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221024/1936f79c6a3c4a72ae54c2b70cec411d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221024/485166b3bfb04f839d4a2b95954d46cf.png
[20210131111050743.png_pic_center]: /images/20221024/77501a35a7ca46e5aa5d7dca2bac2b38.png
[20210131151359314.png_pic_center]: /images/20221024/ab37fb5d41eb4a53998c1ff1a40323b5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221024/9ab609e3bbef4db6973fd28ba437ab46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221024/77d48c37b43442748c2407700cc2f49a.png
[20210130173015442.png_pic_center]: /images/20221024/4c9dc96e650047efa0cf57da86c6d736.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221024/24c17a5b6ea84071944925a8fd86e33d.png
[20210131153245588.png_pic_center]: /images/20221024/0fed8750227f46b695c065f5337e60d2.png
[20210131153947381.png_pic_center]: /images/20221024/f54ddbb8ef8147fda06cb7ec0711591e.png
[20210131160827905.png_pic_center]: /images/20221024/c953dba2f752448d89a983ffdc87d7fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221024/e58dc7d0ecfc48439f125cea4b33988a.png
[20210131164707596.png_pic_center]: /images/20221024/62e5aa54f2d24695aae2feef495b3c42.png
[20210131165312747.png_pic_center]: /images/20221024/56415a59480f42d9b45f215be3a62fc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221024/95fdaa8090ad4643a5a431c60e59e8b8.png
[2021013117184490.png_pic_center]: /images/20221024/8e0db7e7bf9d4341b9a751b3743ce95a.png
[20210131172150431.png_pic_center]: /images/20221024/f22df831dac74357b72ef49c6639d325.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20221024/f1a75516d1be4c13bed91423da77c5a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20221024/a9beeaba5424423c963765f767aee801.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20221024/f60c751b36a34875af3ab24b8e556bdc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 21]: /images/20221024/c3999c1817c34769ad18e66516265a1b.png
[20210129020034946.png_pic_center]: /images/20221024/bd42949e50c14124b02f7f2873ebd838.png
[https_blog.csdn.net_Eastmount]: https://blog.csdn.net/Eastmount
[https_golang.org]: https://golang.org/
[https_www.bilibili.com_video_BV1pt41127FZ]: https://www.bilibili.com/video/BV1pt41127FZ
[https_www.runoob.com_go_go-tutorial.html]: https://www.runoob.com/go/go-tutorial.html
[https_studygolang.com_pkgdoc]: https://studygolang.com/pkgdoc