Go语言基础详解-优快云博客

本文链接：https://blog.youkuaiyun.com/baidu_34933057/article/details/126527259

Go基本语法与使用（一）

1 变量

1.1 声明变量

1. 标准格式

变量声明以var关键字开头，后置变量类型，行尾无需分号，标准格式：

var 变量名变量类型

2. 批量格式

var (
	a int
    b string
    c float32
    d func() bool
    e struct{
        x int
    }
)

1.2 初始化变量

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

整型浮点型变量的默认值为0
字符串变量的默认值为空字符串。
布尔型变量默认为 bool
切片、函、指针变量的默认为 nil

也可以在变量声明时赋予变量一个初始值。

标准格式如下：

var a int = 100
推导类型格式如下：

var a = 100
短变量声明并初始化如：

a := 100

注意：由于使用了“：＝”，而不是赋值的“＝” 因此推导声明写法的左值变量必须是没有定义过的变量。若定义过，将会发生编译错误。

注意：在多个短变量声明和赋值中，至少有一个新声明的变量出现在左值中，即使其他变量名可能是重复声明的，编译器也不会报错。

1.3 多个变量同时赋值

多重赋值时，变量的左值和右值按从左到右的顺序赋值。在 Go 语言的错误处理和函数返回值中会大量地使用。

var a int = 100 
var b int = 200 
b, a = a, b 
fmt.Println(a, b)

1.4 匿名变量

在使用多重赋值时，如果不需要在左值中接收变量可以使用匿名变量。

医名变量的表现是个**“_”下画线**，使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。

例如：

func GetData()	(int, int) {
	return 100, 200
}
a, _ := GetData()
_, b := GetData()
fmt.Println(a, b)

2 数据类型

整型

整型分为下两个大类

按长度分为： int8 int16 int32 int64
还有对应的无符号整型： uint8 uint16 uint32 uint64

其中， uint8就是我们熟知的 byte 型， int16 对应语言中的 short 型， int64 对应中的 long 型。

浮点型

Go 语言支持两种浮点型数 float32、float64 这两种浮点型数格式遵循 IEEE 754 标准。

float32 浮点数的最大范围约为 3.4e38 ，可以使用常量定义 math.MaxFloat32

• float64 的浮点数的最大范围约为 1.8e308 ，可以使用一个常量定义 math.MaxFloat64

打印浮点数时，可以使用 fmt 包配合动词“%f”。

布尔型

布尔型数据在 Go 语言中以 boo 类型进行声明，布尔型数据只有 true (真）和 false(假)两个值。

Go 言中不允许将整型强制转换为布尔型。布尔型无法参与数值运算，也无法与其他类型进行转换。

字符串

字符串在 Go 语言中以原生数据类型出现，使用字符串就像使用其他原生数据类型（ int 等)一样。

字符串的值为双引号中的内容，可以在 Go 语言的源码中直接添加非 ASCII 码字符。例如：

str := “中文”

字符串转义字符

转义符含义
\r 回车符（返回行首）
\n 换行符（跳至下一行同列位置）
\t 制表符
\’ 单引号
\" 双引号
\\ 反斜杠
字符串基于UTF-8编码

转义符	含义
\r	回车符（返回行首）
\n	换行符（跳至下一行同列位置）
\t	制表符
\’	单引号
\"	双引号
\\	反斜杠

Go 语言里的字符串的内部实现使用 UTF-8 编码。通过 rune 类型，可以方便地对每个UTF-8 字符进行访问。当然， Go 言也支持按传统的 ASCII 码方式进行逐字符访问。

3.定义多行字符串

如果需要在源码中嵌入一个多行字符串时，就必须使用“`”字符，称为反引号，就是键盘上键左边的键，两个反引号间的字符串将被原样赋值到str变量中。

const str = `第一行
第二行
第三行
\r\n
`

字符

字符串中的每一个元素叫做“字符”。在遍历或者个获取字符串元素时可以获得字符。

Go 语言的字符有以下两种

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

使用 fmt.Printf 中的"%T"动词可以输出变量的实际类型，使用这个方法可以查看 byte和rune 的本来类型，代码如下：

var a byte = 'a' 
fmt.Printf("%d %T\n", a, a) 
var b rune = '你'
fmt.Printf("%d %T\n", b, b)

UTF-8和Unicode 有何区别?

Unicode 字符集。 ASCII 是一种字符集。

字符集为每个字符分配一个唯 ID ，我们使用到的所有字符在 Unicode 字符集中都有唯一的 ID 对应，例如上面例子中的a的Unicode 与 ASCII 中的编码都是 97 。“你”在Unicode 中的编码为 20320，但是在不同国家的字符集中，“你”的ID会不同。而无论任何情况下， Unicode 中的字符的 ID 是不会变化的。

UTF 是编码规则，将 Unicode 中字符的 ID 以某种方式进行编码。 UTF-8 的是一种变长编码规则，从1到4字节不等。编码规则如下

0xxxx 表示文字符号 0~127，兼容 ASCII 字符集。
从 128 到0x10ffff 表示其他字符。

根据这个规则，拉丁文语系的字符编码一般情况下，每个字符依然占用一个字节，而中文每个字符占用3个字节。

广义的 Unicode 个标准，定义字符集及编码规则，即 Unicode 字符集和 UTF-8、UTF-16 编码等。

切片

切片是一个拥有相同类型元素的可变长度的序列。切片的声明方式如下：

var name [] T

其中， T代表切片元素类型，可以是整型、浮点型、布尔型、切片、map 、函数等。

切片的元素使用“ ［］ ”进行访问，在方括号中提供切片的索引即可访问元素，索引的

范围从0开始，且不超过切片的最大容量。

3 转换不同类型

Go 语言使用类型前置加括号的方式进行类型转换一般格式如下

T(表达式)

其中， T代表要转换的类型。表达式包括变量、复杂算子和函数返回值等。

package main

import (
	"fmt"
	"math"
)

func main() {
	//输出各数值范围
	fmt.Println("int8 range:", math.MinInt8, math.MaxInt8)
	fmt.Println("int16 range:", math.MinInt16, math.MaxInt16)
	fmt.Println("int32 range:", math.MinInt32, math.MaxInt32)
	fmt.Println("int64 range:", math.MinInt64, math.MaxInt64)

	//初始化一个32位整型值
	var a int32 = 1047483647
	//输出变量的十六进制形式和十进制值
	fmt.Printf("int32:0x%x %d\n", a, a)

	//将a变量的数值转为int16类型，发生数值截断
	b := int16(a)
	//输出变量的十六进制形式和十进制值
	fmt.Printf("int16:0x%x %d\n", b, b)

	//将常量保存为float32类型
	var c float32 = math.Pi
	//转换为int类型，浮点发生精度丢失
	fmt.Println(int(c))
}

4 指针

指针概念在 Go 语言中被拆分为两个核心概念

类型指针，允许对这个指针类型的数据进行修改。传递数据使用指针，而无须拷贝数据。类型指针不能进行偏移和运算。
切片，由指向起始元素的原始指针、元素数量和容量组成。

受益于这样的约束和拆分， Go 语言的指针类型变量拥有指针的高效访问，但又不会发生指针偏移，从而避免非法修改关键数据问题。同时，垃圾回收也比较容易对不会发生偏移的指针进行检索和回收。

切片比原始指针具备更强大的特性更为安全。切片发生越界时，运行时会报出宕机，并打出堆栈。

4.1 认识指针地址和指针类型

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。 Go 语言中使用“＆” 操作符放在变量前面对变量进行“取地址”操作。

格式如下：

ptr : = &v // v 的类型为T

其中 v代表被取地址的变量，被取地址的v使用ptr变量进行接收， ptr的类型就为*T，称做 T的指针类型

“＊”代表指针。

4.2 从指针获取指向指针的值

在对普通变量使用“＆”操作符取地址获得这个变量的指针后，可对指针使用“＊”操作，也就是指针取值，代码如下。

var house = "Maibu Point 10880, 90000"
ptr := &house //对字符串取地址，ptr类型为*string
fmt.Printf("ptr type: %T\n", ptr)	//打印ptr类型
fmt.Printf("address: %p\n", ptr) //打印ptr的指针地址
//对指针进行取值操作
value := *ptr
fmt.Printf("value type: %T\n", value)
fmt.Printf("value: %s\n", value) //指针取值后就是指向变量的值

4.3 使用指针修改值

通过指针不仅可以取值，也可以修改值。

前面己经使用多重赋值的方法进行数值交换，使用指针同样可以进行数值交换，代码如下：

package main
import "fmt"
// 交换函数
func swap(a, b *int) {
    // 取a指针的值, 赋给临时变量t
    t := *a
    // 取b指针的值, 赋给a指针指向的变量
    *a = *b
    // 将a指针的值赋给b指针指向的变量
    *b = t
}
func main() {
// 准备两个变量, 赋值1和2
    x, y := 1, 2
    // 交换变量值
    swap(&x, &y)
    // 输出变量值
    fmt.Println(x, y)
}

4.4 创建指针的另一种方法——new()函数

Go语言还提供了另外一种方法来创建指针变量，格式如下：

new(类型)

一般这样写：

str := new(string)*str = "Go语言教程"fmt.Println(*str)

new() 函数可以创建一个对应类型的指针，创建过程会分配内存，被创建的指针指向默认值。