Go语言基本语法

Go语言关键字

1、Go语言有25个关键字

2、关键字用途

var ：用于变量的声明
const ：用于常量的声明
type ：用于声明类型
func ：用于声明函数和方法
package ：用于声明包文件
import ：用于导入其它package
return ：用于从函数返回
defer ：延迟调用，在函数退出之前执行
go ：创建一个协程
select ：用于选择不同类型的通讯
interface ：用于定义接口
struct ：用于定义数据类型
break、case、continue、for、fallthrough、else、if、switch、goto、default ：用于流程控制
chan ：用于声明chan类型数据
map ：用于声明map类型数据
range ：用于遍历array、slice、map、channel数据

Go语言保留字

Go语言有37个保留字：

Go语言命名规范

Go语言的包（package）、变量、常量、自定义类型、函数、方法的命名方式遵循以下规则：

1）首字符可以是任意的Unicode字符或者下划线
2）剩余字符可以是Unicode字符、下划线、数字
3）字符长度不限
4）不要使用Go语言的关键字和保留字命名

Go语言变量

变量的声明

Go 语言的每一个变量都拥有自己的类型，必须经过声明才能开始用。

标准格式：

var 变量名 变量类型

变量的声明以关键字 var 开头，行尾不需要写分号

常见变量的数据类型有：整型、浮点型、布尔型、结构体等。

例如

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

代码说明：

• 第1行，声明一个整型类型的变量，可以保存整数数值。
• 第2行，声明一个字符串类型的变量。
• 第3行，声明一个 32 位浮点切片类型的变量，浮点切片表示由多个浮点类型组成的数据结构。
• 第4行，声明一个返回值为布尔类型的函数变量，这种形式一般用于回调函数，即将函数以变量的形式保存下来，在需要的时候重新调用这个函数。
• 第5行，声明一个结构体类型的变量，这个结构体拥有一个整型的 x 字段。

优雅格式声明(推荐)：

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

使用关键字var和括号，可以将一组变量定义放在一起。

变量的初始化

变量的声明可以包含初始值，每一个变量对应一个值。

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。

变量初始化的标准格式：

var 变量名 类型 = 表达式

简化形式：

var 变量名 = 表达式

例如：

var x int = 100

可以写成：

var x = 100　

默认值：

没有明确初始值的变量声明会被赋予它们一个默认值：

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

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。

注意：函数外的每个语句都必须以关键字开始（var等），因此 := 结构不能在函数外使用。

例如：

x := 100

编译器会自动根据右值类型推断出左值的对应类型。

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

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

x, z := a, b
y, z := a, b

多个变量同时赋值

使用Go的“多重赋值特性”，可以轻松完成变量交换的任务。

package main
import "fmt"
 
func main() {
    var a = 100
    var b = 200
    a, b = b, a
    fmt.Println(a, b)
}

多重赋值时，变量的左值和右值按从左到右的顺序赋值。

 匿名变量(_)

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

匿名变量用一个下划线 _ 来表示，使用匿名变量时，只需要在变量声明的地方使用下划线替换即可。例如：

var a int
a, _ = 100, 200

注意：匿名变量不占用命名空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

常量

常量是恒定不变的值，例如圆周率。

常量的声明与变量类似，只不过是使用 const 关键字。

常量可以是字符、字符串、布尔值和数值。

常量不能用 := 语法声明。

常量的声明, 例如：

const pi = 3.1415926

注意：常量在声明的时候必须赋值。

多个变量可以一起声明，类似的，多个变量也可以一起声明。例如：

const (
    pi = 3.1415926
    e = 2.718281
)

基本数据类型

Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有切片、结构体、函数、map、通道（channel）等。

Go 语言的基本类型和其他语言大同小异。

整型

整型可以分成以下两个大类：

按长度分为：int8、int16、int32、int64

对应的无符号整型：uint8、uint16、uint32、uint64

其中，uint8 就是我们熟知的 byte 型.

浮点型

Go语言支持两种浮点型数：

float32、float64.

注意：没有float

Go语言的浮点型默认声明为float64.

布尔型

 布尔型数据只有 true（真）和 false（假）两个值。

注意：

在Go语言中，
 
true和false均为小写
 
不允许将整型强制转换为布尔型

字符串

字符串的两种表示形式：

1. 双引号，会识别转义字符

2. 反引号，不会识别转义字符。以字符串的原生形式输出，包括换行和特殊字符。

字符串常见转义符

反引号定义多行字符串

const str = ` 第一行
第二行
第三行
\r\n
`
fmt.Println(str)

结果：
第一行

第二行

第三行

\r\n

字符

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

Go语言的字符有以下两种：

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

数据类型的转换

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

T(表达式)

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

注意：在类型转换时，需要考虑两种类型的关系和范围，是否会发生数值截断等。

package main
 
import "fmt"
 
func main(){
    var n1 int = 20
    var n2 float64 = float64(n1)
 
    n2 = n2 + 3.6
 
    var n3 int32 = int32(n2) // 当将一个float类型转成 int时，是直接去掉小数点后的部分
 
    fmt.Printf("n1 type=%T, val=%v; n2 type=%T, val=%v; n3 type=%T, val=%v\n",
        n1, n1, n2, n2, n3, n3)
}

运行结果：

n1 type=int, val=20; n2 type=float64, val=23.6; n3 type=int32, val=23