基础语法和数据类型
基础语法
注释
注释是在编程代码中用于添加解释性文本的一种方式。它们是为了给程序员提供额外的信息，解释代码的功能、目的、实现细节或其他相关信息，在 Go 语言支持两种类型的注释：单行注释、多行注释。
以下是单行注释案例：
go
// 这是单行注释以下是多行注释案例：
go
/*
这里是多行注释
Go语言又称为Golang
Go语言由Google公司开发的一种编程语言
*/推荐使用单行注释来替代多行注释
以下是在开源项目的注释案例。
go
// getAvgPowerBudget retrieves configured power budget
// (in watts) for NVM devices. When libipmctl is not available
// zero is returned.
func getAvgPowerBudget() (uint, error) {
// Get number of devices on the platform
// see: https://github.com/intel/ipmctl/blob/v01.00.00.3497/src/os/nvm_api/nvm_management.h#L1478
count := C.uint(0)
err := C.nvm_get_number_of_devices(&count)
if err != C.NVM_SUCCESS {
klog.Warningf("Unable to get number of NVM devices. Status code: %d", err)
return uint(0), fmt.Errorf("Unable to get number of NVM devices. Status code: %d", err)
}
if count == 0 {
klog.V(4).Infof("There are no NVM devices.")
return uint(0), nil
}
// Load basic device information for all the devices
// to obtain UID of the first one.
devices := make([]C.struct_device_discovery, count)
err = C.nvm_get_devices(&devices[0], C.uchar(count))
if err != C.NVM_SUCCESS {
klog.Warningf("Unable to get all NVM devices. Status code: %d", err)
return uint(0), fmt.Errorf("Unable to get all NVM devices. Status code: %d", err)
}
// Power budget is same for all the devices
// so we can rely on any of them.
device := C.struct_device_details{}
err = C.nvm_get_device_details(&devices[0].uid[0], &device)
if err != C.NVM_SUCCESS {
uid := C.GoString(&devices[0].uid[0])
klog.Warningf("Unable to get details of NVM device %q. Status code: %d", uid, err)
return uint(0), fmt.Errorf("Unable to get details of NVM device %q. Status code: %d", uid, err)
}
return uint(device.avg_power_budget / 1000), nil
}标识符
在 Go 语言中，标识符是用来命名变量、函数、类型、常量和其他程序实体的名称。标识符用于在代码中引用这些实体，并且在编程过程中需要遵循一些规则。
详细介绍在包的管理和常用规范。
以下是有效的标识符：
go
name ikun age abc b_7788
myblog77 _temp j a88n99 retValue以下的是无效标识符：
go
// 以数字开头的标识符
123abc
9var
// 包含特殊字符的标识符
my-var
my@var
// 使用了保留关键字作为标识符
if
func
for
// 重复的标识符
func myFunc() {
var myVar int
var myVar string // 重复的标识符
}关键字
下面列举了 Go 代码中会使用到的 25 个关键字或保留字：
| 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|
| 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 |
在使用 Go 语言的关键字时，有一些注意事项需要牢记：
- 关键字不能用作标识符：Go 语言的关键字具有特殊含义，不能用作变量名、函数名或其他标识符。例如，不能将关键字 if 用作变量名。
- 关键字的大小写：Go 语言的关键字是严格区分大小写的。例如，if 是关键字，而 If 或 IF 不是。
- 保留关键字：虽然某些单词可能在当前版本的 Go 中不是关键字，但它们可能在将来的版本中成为关键字。因此，应避免使用这些保留关键字作为标识符。
除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符：
| 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|
| 常量: true | false | iota | nil | |
| 类型: int | int8 | int16 | int32 | int64 |
| uint | uint8 | uint16 | uint32 | uint64 |
| uintptr | float32 | float64 | complex128 | complex64 |
| bool | byte | rune | string | error |
| 函数: make | len | cap | new | append |
| copy | close | delete | complex | real |
| imag | panic | recover |
在使用 Go 语言的预定义标识符时，有一些注意事项需要记住：
- 保留标识符：预定义标识符具有特殊的含义和行为，它们在标准库中有定义。因此，不应该重新定义这些标识符作为变量名或函数名，以免引起混淆并降低代码的可读性。
- 标识符的大小写：Go 语言是大小写敏感的，因此你必须按照预定义标识符的大小写来使用它们。例如，true 和 True 是不同的标识符。
- 类型安全：预定义标识符具有特定的类型，例如 bool 是布尔类型，int 是整数类型。在使用这些标识符时，要注意与其对应的类型一致，以确保类型安全性。
- 功能和语义：预定义标识符具有特定的功能和语义。例如，len 用于获取容器的长度，make 用于创建切片、映射和通道等。在使用这些标识符时，要理解其用途和作用，以正确地应用它们。
- 错误处理：预定义标识符 error 用于表示错误类型。在处理错误时，可以使用该标识符来定义和返回错误值，以及进行错误检查和处理。
- 异常处理：预定义标识符 panic 和 recover 用于处理异常。panic 用于引发异常，而 recover 用于恢复异常并进行处理。在使用这些标识符时，要了解它们的行为和使用方式，以确保正确处理异常情况。
总之，在使用预定义标识符时，要遵循它们的规则和语义，以确保代码的正确性和可读性。熟悉这些标识符的用途和功能将有助于你更好地理解和使用 Go 语言的标准库。
数据类型
Go语言的数据类型分为两大类：基本类型、复合类型(派生类型)。
基本类型
- 数值类型：
- 有符号位：int、int8、int16、int32、int64
- 无符号位：uint、uint8、uint16、uint32、uint64
- 浮点类型：float32、float64
- 布尔类型：bool
- 复数类型：complex64、complex128
- 字符串：string
- 字符：byte【uint8】、rune【int32】
复合类型(派生类型)
- 指针(pointer)
- 数组(array)
- 切片(slice)
- 字典(map)
- 通道(channel)
- 结构体(struct)
- 函数(function)
- 接口(interface)
接下来详细介绍基本类型，关于复合类型后面的文档再详细说明，就不在基础语法和数据类型该文档详细讲解。
数值类型
| 类型 | 取值范围 | 占用内存空间大小 |
|---|---|---|
| uint8 | 0 到 255 | 1 字节 |
| uint16 | 0 到 65535 | 2 字节 |
| uint32 | 0 到 4294967295 | 4 字节 |
| uint64 | 0 到 18446744073709551615 | 8 字节 |
| int8 | -128 到 127 | 1 字节 |
| int16 | -32768 到 32767 | 2 字节 |
| int32 | -2147483648 到 2147483647 | 4 字节 |
| int64 | -9223372036854775808 到 9223372036854775807 | 8 字节 |
示例代码如下：
go
package main
import "fmt"
func main() {
// 数值类型
// 无符号整数
var n1 uint8 = 255
var n2 uint16 = 65535
var n3 uint32 = 4294967295
var n4 uint64 = 18446744073709551615
// 有符号整数
var n5 int8 = -128
var n6 int16 = -32768
var n7 int32 = -2147483648
var n8 int64 = -9223372036854775808
fmt.Println(n1)
fmt.Println(n2)
fmt.Println(n3)
fmt.Println(n4)
fmt.Println("============")
fmt.Println(n5)
fmt.Println(n6)
fmt.Println(n7)
fmt.Println(n8)
}浮点类型
| 类型 | 取值范围 | 占用内存空间大小 |
|---|---|---|
| float32 | 1.18e-38 到 3.4e+38 | 4 字节 |
| float64 | 2.23e-308 到 1.8e+308 | 8 字节 |
示例代码如下：
go
package main
import "fmt"
func main() {
// 浮点类型
// 浮点数
var f1 float32 = 3.14159265358979
var f2 float64 = 3.14159265358979323846264338327950288
fmt.Println(f1)
fmt.Println(f2)
}布尔类型
| 类型 | 取值范围 | 占用内存空间大小 |
|---|---|---|
| bool | true 或 false | 1 字节 |
示例代码如下：
go
package main
import (
"fmt"
)
func main() {
// 布尔类型
var b1 bool = true
var b2 bool = false
fmt.Println(b1)
fmt.Println(b2)
}复数类型
| 类型 | 取值范围 | 占用内存空间大小 |
|---|---|---|
| complex64 | 实部和虚部取值范围同float32 | 8 字节 |
| complex128 | 实部和虚部取值范围同float64 | 16 字节 |
示例代码如下：
go
package main
import "fmt"
func main() {
// 复数
var c1 complex64 = 3.14159265358979 + 2.71828182845905i
var c2 complex128 = 3.14159265358979323846264338327950288 + 2.71828182845904523536028747135266249i
fmt.Println(c1)
fmt.Println(c2)
}字符串类型
| 类型 | 说明 | 占用内存空间大小 |
|---|---|---|
| string | 字符串序列 | 取决于字符串长度,每个字符占2个字节 |
示例代码如下：
go
package main
import "fmt"
func main() {
// 字符串类型
var a string = "Hello, World!"
fmt.Println(a)
}字符类型
| 类型 | 说明 | 取值范围 | 占用内存空间大小 |
|---|---|---|---|
| byte | uint8 别名 | 0 到 255 | 1字节 |
| rune | int32 别名, 用于表示 Unicode 码点 | -2147483648 到 2147483647 | 4字节 |
示例代码如下：
go
package main
import "fmt"
func main() {
// 字符
var a byte = 'A' // 等同于 uint8
var b rune = '本' // 等同于 int32
fmt.Printf("%c %c\n", a, b)
}