1.关键字和标识符
关键字是被语言赋予特殊含义的单词，在编写程序中并不能将关键字作为标识符使用。Go语言的关键字只有25个
|---------|--------|-------------|-----------|--------|
| break | struct | range | chan | type |
| default | else | continue | interface | goto |
| func | for | select | package | import |
| case | switch | return | defer | const |
| var | go | fallthrough | map | if |
这些关键字先自行观看其他相关文章，本章节暂不解释其关键字的含义
标识符是对各种变量、方法、函数等命名时使用的字符序列，标识符由若干个英文字母、数字和下划线组成，且第一个字符必须是英文字母标识符的命名规则如下：
1.由英文字母、数字和下划线组成
2.不能以数字开头
3.Go语言严格区分大小写
4.标识符不能包含空格
5.不能以系统保留的关键字作为标识符
6.标识符的命名要尽量以简短而有意义的词
7.不能和标准库中的包名重复
2.变量和常量
2.1变量
Go语言变量的命名遵从标识符的基本规则，变量声明有3种格式，分别是标准格式、批量格式和简短格式
标准格式：var 变量名 变量格式
批量格式：var{
变量名1 变量格式
变量名2 变量格式
变量名3, 变量名4 变量格式
}
简短格式：变量名 := 变量名
变量名1,变量名2 := 变量名1,变量名2
简短格式被广泛用于大部分的局部变量的声明和初始化，标准格式的声明语句用于需要显式指定变量类型的地方。在变量声明时也可以赋予变量一个初始化值。格式如下：
var 变量名 变量类型 = 初始化值
2.2 常量
常量是一个简单值的标识符，在程序运行时它的值不会被改变。常量的数据类型只可以是布尔型、数字型和字符串型，定义标准格式如下：
const 常量名 [常量类型] = 值
在Go语言中，编译器可以根据变量和常量的值来判断其类型，定义格式可以分为显式类型定义和隐式类型定义
显式类型定义：const 常量名[常量类型] = 值
隐式类型定义：const 常量名 = 值
常量声明语句和变量类似，可支持批量格式声明，格式如下：
const {
常量名1 = 值
常量名2 = 值
常量名3 = 值
}
提示：在Go语言中，所声明的常量可以不使用，但所声明的变量必须使用，否则程序在编译的过程会报错
3.数据类型
数据类型的出现是为了把数据分成内存大小不同的数据，Go语言数据类型分为基本数据类型和组合数据类型
Go语言数据类型
|--------|--------------|-----------------------|
| 分类 | 数据类型 | 解释 |
| 基本数据类型 | 布尔型 | 布尔型的值只能是true和false |
| 基本数据类型 | 数字型 | 整型、浮点型、复数型 |
| 基本数据类型 | 字符串型(String) | 字符串就是一串固定长度的字符拼接的字符序列 |
| 组合数据类型 | 派生类型 | 指针类型 |
| 组合数据类型 | 派生类型 | 数组类型 |
| 组合数据类型 | 派生类型 | 结构体类型 |
| 组合数据类型 | 派生类型 | 通道类型 |
| 组合数据类型 | 派生类型 | 函数类型 |
| 组合数据类型 | 派生类型 | 切片类型 |
| 组合数据类型 | 派生类型 | 接口类型 |
| 组合数据类型 | 派生类型 | 集合类型 |
基本的数字型又分为整型和浮点型，整型以及浮点型根据其存储空间以及是否带有符号又有更细的划分，如以下图所示：
|------------|----------------------------------------------------------------------------|
| 类型 | 解释 |
| uint8 | 无符号8位整型。取值范围：0~255 (2^8) |
| uint16 | 无符号16位整型。取值范围：0~65535 (2^16) |
| uint32 | 无符号32位整型。取值范围：0~4294967295 (2^32) |
| uint64 | 无符号64位整型。取值范围：0~255 (2^64) |
| int8 | 有符号8位整型。取值范围：-128 (-2^8)~127 (2^7 -1) |
| int16 | 有符号16位整型。取值范围：-32768 (-2^15)~32767 (2^15 -1) |
| int32 | 有符号32位整型。取值范围：-2147483648 (-2^31)~2147483647 (2^31-1) |
| int64 | 有符号64位整型。取值范围：-9223372036854775808 (-2^63)~9223372036854775807 (2^63-1) |
| float32 | IEEE---754 32位浮点型数据 |
| float64 | IEEE---754 64位浮点型数据 |
| complex64 | 32位实数和虚数 |
| complex128 | 64位实数和虚数 |
| byte | 类似uint8 |
| rune | 类似int32 |
| uintptr | 无符号整型，用于存放一个指针 |
4.运算符
运算符用于程序运行时执行变量、常量间的数字或逻辑运算，Go语言内置的运算符包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符
算术运算符
算术运算符要求两个运算符的类型必须相同且同为基本数据类型，其中自增和自减两个运算符在Go语言可以构成单独的语句
| 运算符 | 描述 | 示例 | 结果 |
|---|---|---|---|
+ |
加法 | 5 + 3 |
8 |
- |
减法 | 7 - 2 |
5 |
* |
乘法 | 4 * 6 |
24 |
/ |
除法 | 10 / 2 |
5 |
% |
取模（取余数） | 10 % 3 |
1 |
** |
幂运算 | 2 ** 3 |
8 |
// |
整除（向下取整） | 7 // 2 |
3 |
关系运算符
关系运算符设计到两个值的比较，返回的结果是布尔值
| 运算符 | 描述 | 示例（假设 a = 5，b = 3） |
|---|---|---|
== |
等于 | a == b 结果为 false |
!= |
不等于 | a != b 结果为 true |
> |
大于 | a > b 结果为 true |
< |
小于 | a < b 结果为 false |
>= |
大于或等于 | a >= b 结果为 true |
<= |
小于或等于 | a <= b 结果为 false |
逻辑运算符
逻辑运算符用来判断变量或值之间的逻辑关系，判断的结果是布尔值
| 运算符 | 名称 | 描述 | 示例（编程语言通用） |
|---|---|---|---|
&& |
逻辑与 | 当两个操作数都为真时返回真，否则返回假 | A && B |
| ` | ` | 逻辑或 | |
! |
逻辑非 | 对操作数的布尔值取反（真变假，假变真） | !A |
^ |
逻辑异或 | 当两个操作数的布尔值不同时返回真，相同时返回假 | A ^ B |
& |
按位与 | 对操作数的每一位执行与操作（通常用于位运算） | A & B |
| ` | ` | 按位或 | 对操作数的每一位执行或操作（通常用于位运算） |
~ |
按位非 | 对操作数的每一位取反（通常用于位运算） | ~A |
真值表（逻辑与、逻辑或、逻辑非）
以下表格展示了逻辑运算符的真值表：
| A | B | A && B | A || B | !A | A ^ B |
|---|---|---|---|---|---|
| true | true | true | true | false | false |
| true | false | false | true | false | true |
| false | true | false | true | true | true |
| false | false | false | false | true | false |
按位运算符示例（假设 8 位二进制数）
以下表格展示按位运算符的具体行为：
| A (二进制) | B (二进制) | A & B | A | B | ~A | A ^ B |
|---|---|---|---|---|---|
00001111 |
00110011 |
00000011 |
00111111 |
11110000 |
00111100 |
不同编程语言的逻辑运算符
部分语言可能使用不同的符号表示逻辑运算：
- Python :
and、or、not - JavaScript/C/C++/Java :
&&、||、! - SQL :
AND、OR、NOT - Shell脚本 :
-a（与）、-o（或）
注意事项
- 逻辑运算符通常支持短路求值（如
A && B中若A为假，则不会计算B）。 - 按位运算符直接操作二进制位，需注意数据类型和位数。
- 异或运算在某些语言中可能无专用符号，需通过组合运算实现。
位运算符
位运算符以一个二进制上的值作为操作数，提供不同的位运算符可以实现清零、判断等操作
| 运算符 | 名称 | 描述 | 示例（假设 A=60，B=13） |
|---|---|---|---|
& |
按位与 | 对两个数的二进制位逐位进行与运算，只有两个位都为1时结果位才为1 | A & B = 12 (0000 1100) |
| ` | ` | 按位或 | 对两个数的二进制位逐位进行或运算，只要有一个位为1时结果位就为1 |
^ |
按位异或 | 对两个数的二进制位逐位进行异或运算，当两个位不同时结果位为1 | A ^ B = 49 (0011 0001) |
~ |
按位取反 | 对一个数的二进制位逐位取反，0变1，1变0 | ~A = -61 (1100 0011) |
<< |
左移 | 将一个数的二进制位全部左移若干位，右侧补0 | A << 2 = 240 (1111 0000) |
>> |
右移 | 将一个数的二进制位全部右移若干位，左侧补符号位（算术右移） | A >> 2 = 15 (0000 1111) |
补充说明
- 位运算符直接操作整数的二进制表示，效率较高，常用于底层编程或优化场景。
- 左移和右移运算符在不同编程语言中的行为可能略有差异，特别是对于有符号数的处理。
- 按位取反的结果取决于整数的位数和表示方式（如补码表示）。
赋值运算符
赋值运算符用于变量赋值，其运算顺序是从有到左
| 运算符 | 描述 | 示例（假设 x = 5） |
|---|---|---|
= |
简单赋值 | x = 3 → x 值为 3 |
+= |
加后赋值 | x += 2 → x 值为 7（x = x + 2） |
-= |
减后赋值 | x -= 1 → x 值为 4（x = x - 1） |
*= |
乘后赋值 | x *= 3 → x 值为 15（x = x * 3） |
/= |
除后赋值 | x /= 2 → x 值为 2.5（x = x / 2） |
%= |
取模后赋值 | x %= 2 → x 值为 1（x = x % 2） |
**= |
幂运算后赋值 | x **= 2 → x 值为 25（x = x ** 2） |
//= |
整除后赋值 | x //= 2 → x 值为 2（x = x // 2） |
&= |
按位与后赋值 | x &= 3 → x 值为 1（x = x & 3） |
| ` | =` | 按位或后赋值 |
^= |
按位异或后赋值 | x ^= 3 → x 值为 6（x = x ^ 3） |
<<= |
左移位后赋值 | x <<= 1 → x 值为 10（x = x << 1） |
>>= |
右移位后赋值 | x >>= 1 → x 值为 2（x = x >> 1） |
注意事项
- 表格中的示例基于初始值
x = 5，实际结果可能因语言或数据类型不同而略有差异。 - 复合赋值运算符（如
+=）通常能提高代码简洁性和执行效率。
指针运算符
| 运算符 | 示例 | 说明 |
|---|---|---|
& |
&x |
取变量内存地址 |
* |
*p |
解引用指针 |
通道运算符
| 运算符 | 示例 | 说明 |
|---|---|---|
<- |
ch <- x |
发送数据到通道 |
<- |
x = <-ch |
从通道接收数据 |
其他特殊运算符
| 运算符 | 示例 | 说明 |
|---|---|---|
... |
func(x ...int) |
可变参数 |
: |
x := 10 |
短变量声明 |
<- |
close(ch) |
关闭通道 |
运算符优先级说明
Go语言运算符优先级从高到低部分关键顺序：
* / % << >> & &^+ - | ^== != < <= > >=&&||