《【西天取经】Go语言学习笔记：基本变量与类型》

东城绝神

已于 2022-08-12 13:47:14 修改

阅读量460

点赞数

分类专栏：《Go语言学习》文章标签： go

于 2022-08-03 16:18:09 首次发布

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/m0_37814112/article/details/126142787

版权

《Go语言学习》专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文介绍了Go语言中的变量声明、初始化、赋值及变量值交换，包括变量命名规范和默认值。此外，还详细讲解了整型、浮点型、字符串、布尔型的数据类型及其转换方法，以及数据类型判断和转换。最后，讨论了指针的概念和声明方式。文章通过实例展示了Go语言基础语法的实用技巧。

摘要由CSDN通过智能技术生成

一、Go语言变量

1.1、变量是什么

说明：变量是计算机语言中能存储计算结果或能表示值抽象概念。变量可以通过变量名访问。

1.2、变量名要求

1、变量名必须只包含：字母、数字、下划线
2、不能以数字开头，如1name
3、不能使用go语言内置的关键字,如break、default、func、interface、select、case、defer、go、map、struct、chan、else、goto、package、switch、const、fallthrough、if、range、type、continue、for、import、return、var

建议

1、变量名最好见名知意：如name/age/num
2、驼峰式命名：myBossName / startDate

1.3、声明变量

1.3.1、标准格式

var 变量名 变量类型

例如：

var num int

1.3.2、批量格式

说明：使用关键字和小括号，可以同时声明多个变量

var (
	a int
	b string
	c bool
)

1.4、初始化变量

Go语言在声明变量时，会自动对每个变量对应的内存区域进行初始化，即每个变量会有其类型对应的默认值。

1、整型和浮点型变量默认值为0
2、字符串变量的默认值为空字符串
3、布尔型变量默认为false
4、切片、映射、函数、指针变量默认为nil

示例如下：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var name string
	var num int
	var result bool
	fmt.Println(name, reflect.TypeOf(name))
	fmt.Println(num, reflect.TypeOf(num))
	fmt.Println(result, reflect.TypeOf(result))
}

执行结果如下图所示：

在这里插入图片描述

1.4.1、方法一：【声明+赋值】标准格式

//示例一： 定义单个变量
package main

import "fmt"

func main() {

	//示例一： 定义单个变量
	var name1 string = "zhangwuji1"
	fmt.Println(name1)
	
	//示例二： 定义多个变量
	var name4, name5 string = "zhangwuji4", "zhangwuji5"
	fmt.Println(name4, name5)
	
	//示例三： 定义多个变量
	var (
		name10 string = "zhangwuji10"
		name11 string = "zhangwuji11"
		name12 string = "zhangwuji12"
	)
	fmt.Println(name10, name11, name12)
}

1.4.2、方法二：【声明+赋值】编译器推导类型格式

//示例一： 定义单个变量
package main

import "fmt"

func main() {

	//示例一： 定义单个变量
	var name2 = "zhangwuji2"
	fmt.Println(name2)

	//示例二： 定义多个变量
	var name6, name7 = "zhangwuji6", "zhangwuji7"
	fmt.Println(name6, name7)

	//示例三： 定义多个变量
	var (
		name13 = "zhangwuji13"
		name14 = "zhangwuji14"
		name15 = "zhangwuji15"
	)
	fmt.Println(name13, name14, name15)
}

1.4.3、方法三：【声明+赋值】短变量声明并初始化（建议）

package main

import "fmt"

func main() {

	//示例一： 定义单个变量
	name3 := "zhangwuji3"
	fmt.Println(name3)

	//示例二： 定义多个变量
	name8, name9 := "zhangwuji8", "zhangwuji9"
	fmt.Println(name8, name9)
}

1.4.4、方法四：【先声明后赋值】

package main

import "fmt"

func main() {
	var name, message, data string
	name = "张三冯"
	message = "中奖了"
	data = "中了5000w"
	fmt.Println(name, message, data)
}

1.5、变量值交换

package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := 17
	b := 18
	var c, d int
	c = a + b
	d = a * b
	fmt.Println(a, reflect.TypeOf(a))
	fmt.Println(b, reflect.TypeOf(b))
	fmt.Println(c, reflect.TypeOf(c))
	fmt.Println(d, reflect.TypeOf(d))
}

1.5、匿名变量

在编码过程中，可能会遇到没有名称的变量、类型或方法。虽然这不是必须的，但有时候这样做可以极大地增强代码的灵活性，这些变量被统称为匿名变量。匿名变量的特点是一个下划线“”，“”本身就是一个特殊的标识符，被称为空白标识符。使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。

package main

import "fmt"

func GetData() (int, int) {
	return 100, 200
}
func main() {
	a, _ := GetData() //只需要获取第一个返回值，所以将第二个返回值的变量设为下划线
	_, b := GetData()
	fmt.Println(a, b)
}

二、Go语言数据类型

2.1、整型

整型主要分为：有符号整型和无符号整型。

1、有符号整型：int8 int16 int32 int64
2、无符号整型：uint8 uint16 uint32 uint64

整型是所有编程语言里最基础的数据类型，Go语言默认支持如下这些整型类型。
在这里插入图片描述
示例一：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := 10
	b := 18
	fmt.Println(b/a, reflect.TypeOf(b/a))
}

>>> 执行结果
1 int

说明：在Go语言中，对于两个整型变量的除法计算，小数部分会直接被截取，只取整数部分，不会存在四舍五入的情况。

2.2、浮点型

编程语言中的浮点数就是我们常说的小数。Go语言支持两种浮点数：float32和float64。

示例一：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := 10.0
	b := 4.0
	fmt.Println(a/b, reflect.TypeOf(a/b))
}

>>> 执行结果
2.5 float64

2.3、字符串

Go语言中，字符串的值为双引号中的内容，而且可以直接输入中文。

示例一：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	name := "张三丰"
	fmt.Println(name, reflect.TypeOf(name))
}

>>> 执行结果
张三丰 string

2.4、字符和转义字符

字符串转义符
在这里插入图片描述
示例一：

package main

import "fmt" // fmt包中提供格式化，输出，输入的函数.

// 这是一个main函数，是程序入口
func main() {
	// 转义字符 \t
	fmt.Println("tom\tjack")
	// 转义字符 \n
	fmt.Println("hello\nworld")
	// 转义字符\\
	fmt.Println("C:\\Users\\Administrator\\Desktop\\资料")
	// 转义字符\"
	fmt.Println("tom说:\"i love you\"")
	// 转义字符 \r 。回车,从当前行的最前面开始输出，覆盖掉以前内容
	fmt.Println("倚天屠龙记\r张无忌")
}

>>> 执行结果
tom     jack                        
hello                               
world                               
C:\Users\Administrator\Desktop\资料 
tom说:"i love you"                  
张无忌龙记

2.5、布尔型

布尔型是最简单的数据类型，只有两个值：false（假）和true（真）。

示例一：

package main

import "fmt"

func main() {
	var b1 bool = true
	var b2 bool = false
	var b3 = true
	var b4 = false
	b5 := true
	b6 := false

	fmt.Printf("b1: %v\n", b1)
	fmt.Printf("b2: %v\n", b2)
	fmt.Printf("b3: %v\n", b3)
	fmt.Printf("b4: %v\n", b4)
	fmt.Printf("b5: %v\n", b5)
	fmt.Printf("b6: %v\n", b6)
}

>>> 执行结果
b1: true  
b2: false 
b3: true  
b4: false 
b5: true  
b6: false

2.6、数据类型判断

如果我们需要判断变量的类型，可以使用Go语言标准库中的reflect包，通过将变量传入此包的Type0f方法，可以得到变量的数据类型。

示例一：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	name := "张无忌"
	age := 18
	result := true

	fmt.Println(name, reflect.TypeOf(name))
	fmt.Println(age, reflect.TypeOf(age))
	fmt.Println(result, reflect.TypeOf(result))
}

>>> 执行结果
张无忌 string 
18 int        
true bool

2.7、数据类型转换

2.7.1、整型之间转换

示例一：int8类型转换为int16

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var v1 int8 = 10
	var v2 int16 = 20
	v3 := int16(v1) + v2
	fmt.Println(v3, reflect.TypeOf(v3))

	var v4 int8 = 12
	var v5 int16 = 24
	v6 := v4 + int8(v5)
	fmt.Println(v6, reflect.TypeOf(v6))
}

>>> 执行结果
30 int16
36 int8

说明：低位转向高位，没问题，高位转低位，可能会有问题，跟数据范围有关系。

2.7.2、整型与字符串的转换

示例一：int类型转换为字符串类型

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	v1 := 19
	result := strconv.Itoa(v1)
	fmt.Println(result, reflect.TypeOf(result))
}

>>> 执行结果
19 string

示例二：int8类型转换为字符串类型
说明：int8不能直接转换成字符串类型，必须先转换为int类型，然后再转换成字符串类型

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	var v1 int8 = 19
	result := strconv.Itoa(int(v1))
	fmt.Println(result, reflect.TypeOf(result))
}

>>> 执行结果
19 string

示例三：字符串类型转换为int类型

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	v1 := "666"
	result, error := strconv.Atoi(v1)
	if error == nil {
		fmt.Println("转换成功", result, reflect.TypeOf(result))
	} else {
		fmt.Println("转换失败")
	}
}

>>> 执行结果
转换成功 666 int

2.7.3、十进制和二进制等其它进制转换

如下图所示：
在这里插入图片描述
总结：
1、十进制转换成二进制、八进制、十六进制，使用FormatInt函数。
2、二进制、八进制、十六进制转换成十进制，使用ParseInt函数。
3、二进制转换成八进制、十六进制，需先使用ParseInt函数转换成十进制，然后再使用FormatInt函数转换成八进制或十六进制。

1、十进制，整型的方式存在
2、其他进制，是以字符串的形式存在

示例二：整型(十进制)转换成二进制

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	v1 := 19
	fmt.Println(v1, reflect.TypeOf(v1))
	
	//在64位计算机中,int64也就是等同于int，int64(v1)表示要转换的对象，即int64位的整型19，2表示要转换的进制位数
	v2 := strconv.FormatInt(int64(v1), 2) 
	fmt.Println(v2, reflect.TypeOf(v2))
}

>>> 执行结果
19 int       
10011 string

示例二：整型(十进制)转换成八进制

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	v1 := 99
	fmt.Println(v1, reflect.TypeOf(v1))
	//在64位计算机中,int64也就是等同于int，int64(v1)表示要转换的对象，即int64位的整型19，8表示要转换的进制位数
	v2 := strconv.FormatInt(int64(v1), 8)
	fmt.Println(v2, reflect.TypeOf(v2))
}

>>> 执行结果
99 int
143 string

示例三：整型(十进制)转换成十六进制

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	v1 := 99
	fmt.Println(v1, reflect.TypeOf(v1))
	//在64位计算机中,int64也就是等同于int，int64(v1)表示要转换的对象，即int64位的整型19，16表示要转换的进制位数
	v2 := strconv.FormatInt(int64(v1), 16)
	fmt.Println(v2, reflect.TypeOf(v2))
}

>>> 执行结果
99 int
63 string

示例四：二进制转换成整型(十进制)

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	// v1,要转换的文本
	// 2，把文档当做二进制去转换成 十进制（整型）
	// 0，转换的过程中对结果已int进行约束，int其实就是64
	// 结果：如果转换成功，则将err设置为nil，result则永远以int64的类型返回。
	v1 := "1001000101"
	v2, error := strconv.ParseInt(v1, 2, 0)
	fmt.Println(v2, error, reflect.TypeOf(v2))
}

>>> 执行结果
581 <nil> int64

示例四：二进制转换成十六进制

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	//将 2进制 "10011" 转换成 16 进制的字符串
	v3, error := strconv.ParseInt("10011", 2, 0)
	v4 := strconv.FormatInt(v3, 16)
	fmt.Println(v4, reflect.TypeOf(v4))
}

>>> 执行结果
13 string