小言_互联网的博客

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

2021-02-10 08:38 327人阅读  评论(0)

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

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

源码下载地址：

前文参考：

文章目录

一.变量

1.什么是变量

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

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

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

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

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)
}

输出结果如下图所示：

多变量声明：
在编程中，通常会遇到一次性声明多个变量的情况。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)
}

输出结果如下图所示：

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

  • 在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.变量的注意事项

注意事项：

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

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

  • 变量=变量名+值+数据类型，这一点大家需要注意，变量的三要素

  • 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)
}

二.数据类型

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

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

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。

类型 有无符号 占用存储空间 表数范围
int8 有 1字节 − 128 ∼ 127 -128 \sim 127 −128∼127
int16 有 2字节 − 2 15 ∼ 2 15 − 1 - 2^{15} \sim 2^{15}-1 −215∼215−1
int32 有 4字节 − 2 31 ∼ 2 31 − 1 - 2^{31} \sim 2^{31}-1 −231∼231−1
int64 有 8字节 − 2 63 ∼ 2 63 − 1 - 2^{63} \sim 2^{63}-1 −263∼263−1

案例如下：

package main
import "fmt"

func main() {
   
	var i int = 1
	fmt.Println("i =", i)

	var j int8 = 127
	fmt.Println("j =", j)
}

输出结果如下图所示：

(2) 无符号整形

类型 有无符号 占用存储空间 表数范围
uint8 无 1字节 0 ∼ 255 0 \sim 255 0∼255
uint16 无 2字节 0 ∼ 2 16 − 1 0 \sim 2^{16}-1 0∼216−1
uint32 无 4字节 0 ∼ 2 32 − 1 0 \sim 2^{32}-1 0∼232−1
uint64 无 8字节 0 ∼ 2 64 − 1 0 \sim 2^{64}-1 0∼264−1

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

(3) 其他int类型

类型 有无符号 占用存储空间 表数范围
int 有 32位系统4个字节
64位系统8个字节		 − 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
uint 无 32位系统4个字节
64位系统8个字节		 0 ∼ 2 32 − 1 0 ∼ 2 64 − 1 0 \sim 2^{32}-1 \\ 0 \sim 2^{64}-1 0∼232−10∼264−1
rune 有 与int32等价，表示一个unicode码，常用处理中文 − 2 31 ∼ 2 31 − 1 - 2^{31} \sim 2^{31}-1 −231∼231−1
byte 无 与uint8等价，存储字符选用 0 ∼ 255 0 \sim 255 0∼255

案例如下：

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)
}

输出结果如下：

(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))
}

输出结果如下图所示：

2.浮点型

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

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

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

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

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

  • 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精度损失。

浮点数的注意事项

  • 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)
}

输出结果如下图所示：

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其他编码方式。

字符型的注意事项

  • 字符常量是用单引号（’）括起来的单个字符，例如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

  • 在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)
}

输出结果如下图所示：

字符类型本质探讨

  • 字符型存储到计算机中，需要将字符对应的码值（整数）找出来
    – 存储：字符 -> 对应码值 -> 二进制 -> 存储
    – 读取：二进制 -> 码值 -> 字符 -> 读取
  • 字符和码值的对应关系是通过字符编码表决定的，事先规定好的
  • 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))
}

输出结果如下：

注意：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)
}

输出结果如下图所示：

字符串的注意事项

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

字符串两种表示形式

  • 双引号：会识别转移字符
  • 反引号：以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
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)
}

输出结果如下图所示：

字符串拼接

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

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

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

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

举例如下：

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)
}

输出结果如下图所示：

注意事项

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

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

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

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

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

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

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

代码如下：

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)
}

输出结果如下图所示：

  • 方法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)
}

输出结果如下图所示：

(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)处理。

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

三.指针

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

2.指针类型

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

  • var ptr *int = &num

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

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)
}

输出结果如下图所示：

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

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

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)

	//获取指针类型指向的值
	fmt.Printf("ptr的地址=%v\n", &ptr)
	fmt.Printf("ptr指向的值=%v\n", *ptr)
}

输出结果如下所示：

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

举例说明：

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)
}

输出结果如下图所示：

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

5.值类型和引用类型

(1) 值类型

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

(2) 引用类型

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

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

四.标识符和关键字

1.标识符

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

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

标识符命名注意事项：

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

  • 变量名、函数名、常量名建议采用驼峰法命名
    比如：var stuName string = “csdn”，形如xxxYyyyZzzz…

  • 如果变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用（ 首字母大写是公开的，首字母小写是私有的 ），在Golang中没有public、private等关键字，这也是Go与其他语言的区别

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

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)
}

输出结果如下图所示：

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

2.关键字

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

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

五.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。

华氏度 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)
}

输出结果如下图所示：

(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("这是一个奇数")
	}
}

输出结果如下图所示：

(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))
}

输出结果如下图所示：

(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)
}

输出结果如下图所示：

注意，当字符串中包含多字节字符时，要用到标准库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)
	}
}

输出结果如下图所示：

(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)
}

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

(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)
}

输出结果如下图所示：

(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)
}

输出结果如下图所示：

(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)
}

输出结果如下图所示：

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

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)

	//获取指针类型指向的值
	fmt.Printf("ptr的地址=%v\n", &ptr)
	fmt.Printf("ptr指向的值=%v\n", *ptr)
}

输出结果如下图所示：

(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)
}

输出结果如下图所示：

(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指向较小值。

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

六.总结

写到这里，这篇基础性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编程语言，做更多实际工程，写更好的文章，共勉！

源代码下载地址：

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

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

参考文献：


转载：https://blog.csdn.net/Eastmount/article/details/113399802
查看评论
* 以上用户言论只代表其个人观点，不代表本网站的观点或立场