目录
Go 语言
Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。
Go 语言特色
- 简洁、快速、安全
- 并行、有趣、开源
- 内存管理、数组安全、编译迅速
Go 语言用途
Go 语言被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。
对于高性能分布式系统领域而言，Go 语言无疑比大多数其它语言有着更高的开发效率。它提供了海量并行的支持，这对于游戏服务端的开发而言是再好不过了。
Golang官网：https://golang.google.cn/
安装
Windows
https://golang.google.cn/dl/go1.15.7.windows-amd64.msi
https://golang.google.cn/dl/go1.15.7.windows-386.msi
linux
https://golang.google.cn/dl/go1.15.7.linux-amd64.tar.gz
macOs
https://golang.google.cn/dl/go1.15.7.darwin-amd64.pkg
正常安装好了是会自动配置环境变量的，如果没有请自行配置。
第一个golang程序
main.go
package main //包名
import "fmt" //引入 fmt 包
func main() {
/*注释*/
fmt.Println("Hello,go!")
}- 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
- 下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
- 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
- 下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。
- 下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
使用 fmt.Print("hello, go\n") 可以得到相同的结果。
Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。 - 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
执行go运行得语句
go run main.go
Go 语言数据类型
布尔型
布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
数字类型
整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
字符串类型
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
派生类型
包括：
- 指针类型（Pointer）
- 数组类型
- 结构化类型（struct）
- 通道类型（Channel）
- 函数类型
- 切片类型（Slice）
- 接口类型（interface）
- 集合类型（Map）
数字类型
| unit8 | 无符号 8 位整型 (0 到 255) |
| unit16 | 无符号 16 位整型 (0 到 65535) |
| unit32 | 无符号 32 位整型 (0 到 4294967295) |
| unit64 | 无符号 64 位整型 (0 到 18446744073709551615) |
| int8 | 有符号 8 位整型 (-128 到 127) |
| int16 | 有符号 16 位整型 (-32768 到 32767) |
| int32 | 有符号 32 位整型 (-2147483648 到 2147483647) |
| int64 | 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) |
| float32 | IEEE-754 32位浮点型数 |
| float64 | IEEE-754 64位浮点型数 |
| complex64 | 32 位实数和虚数 |
| complex128 | 64 位实数和虚数 |
| byte | 类似 uint8 |
| rune | 类似 int32 |
| unit | 32 或 64 位 |
| int | 与 uint 一样大小 |
| uintptr | 无符号整型，用于存放一个指针 |
Go 语言变量
/*变量*/
func variable() {
var v int
v = 1
fmt.Println(v)
var v2, v3 int = 2, 3
fmt.Println(v2, v3)
v4 := 4
fmt.Println(v4)
v5, v6 := 5, 6
fmt.Println(v5, v6)
var v7 string = "v7"
fmt.Println(v7)
var v8 string = `v8`
fmt.Println(v8)
}
func variable2() {
/* 以下几种类型为 nil */
var a *int
var b []int
var c map[string]int
var d chan int
var e func(string) int
var f error //error 是接口
fmt.Println(a, b, c, d, e, f)
}Go 语言常量
/*常量*/
func constant() {
const LENGTH int = 10
const WIDTH int = 5
const a, b, c = 1, false, "str" //多重赋值
const (
d = "abc"
e = len(d)
f = unsafe.Sizeof(d) //返回数据类型的大小，不管引用数据的大小，string类型不是直接存的数据，而是一个结构体，用指针指向实际数据地址，
//string内部实现由两部分组成，一部分是指向字符串起始地址的指针，另一部分是字符串的长度，两部分各是8字节，所以一共是16字节
)
fmt.Println(LENGTH, WIDTH, a, b, c, d, e, f)
}
func variable3() {
//这种因式分解关键字的写法一般用于声明全局变量
var (
v1 int
v2 string
)
v1 = 1
v2 = "v2"
fmt.Println(v1, v2)
var (
v3, v4 int
)
v3 = 3
v4 = 4
fmt.Println(v3, v4)
}
iota
iota，特殊常量，可以认为是一个可以被编译器修改的常量。
iota 在 const 关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次（iota 可理解为 const 语句块中的行索引）。
iota 可以被用作枚举值。
第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式
func constant2() {
const (
a = iota // 0
b // 1
c // 2
d = "a" // a, iota += 1
e // a, iota += 1
f = 100 // 100, iota += 1
g // 100, iota += 1
h = iota // 7,恢复计数
i // 8
)
fmt.Println(a, b, c, d, e, f, g, h, i)
}
func constant3() {
const (
i = 1 << iota // 1 1 二进制左移0 i=1
j = 3 << iota // 3 11 二进制左移1 110 j=6
k // 3 11 二进制左移2 1100 k=12
l // 3 11 二进制左移3 11000 l=24
)
fmt.Println(i, j, k, l)
}
Go 语言运算符
算术运算符
| + | 相加 | A + B 输出结果 30 |
| - | 相减 | A - B 输出结果 -10 |
| * | 相乘 | A * B 输出结果 200 |
| / | 相除 | B / A 输出结果 2 |
| % | 求余 | B % A 输出结果 0 |
| ++ | 自增 | A++ 输出结果 11 |
| -- | 自减 | A-- 输出结果 9 |
关系运算符
| == | 检查两个值是否相等，如果相等返回 True 否则返回 False。 | (A == B) 为 False |
| != | 检查两个值是否不相等，如果不相等返回 True 否则返回 False。 | (A != B) 为 True |
| > | 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 | (A > B) 为 False |
| < | 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 | (A < B) 为 True |
| >= | 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 | (A >= B) 为 False |
| <= | 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 | (A <= B) 为 True |
逻辑运算符
| && | 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。 | (A && B) 为 False |
| || | 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。 | (A || B) 为 True |
| ! | 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 | !(A && B) 为 True |
位运算符
| & | 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。 | (A & B) 结果为 12, 二进制为 0000 1100 |
| | | 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或 | (A | B) 结果为 61, 二进制为 0011 1101 |
| ^ | 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 | (A ^ B) 结果为 49, 二进制为 0011 0001 |
| << | 左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | A << 2 结果为 240 ，二进制为 1111 0000 |
| >> | 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。 | A >> 2 结果为 15 ，二进制为 0000 1111 |
赋值运算符
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 | C = A + B 将 A + B 表达式结果赋值给 C |
| += | 相加后再赋值 | C += A 等于 C = C + A |
| -= | 相减后再赋值 | C -= A 等于 C = C - A |
| *= | 相乘后再赋值 | C *= A 等于 C = C * A |
| /= | 相除后再赋值 | C /= A 等于 C = C / A |
| %= | 求余后再赋值 | C %= A 等于 C = C % A |
| <<= | 左移后赋值 | C <<= 2 等于 C = C << 2 |
| >>= | 右移后赋值 | C >>= 2 等于 C = C >> 2 |
| &= | 按位与后赋值 | C &= 2 等于 C = C & 2 |
| ^= | 按位异或后赋值 | C ^= 2 等于 C = C ^ 2 |
| |= | 按位或后赋值 | C |= 2 等于 C = C | 2 |
其他运算符
| & | 返回变量存储地址 | &a; 将给出变量的实际地址。 |
| * | 指针变量。 | *a; 是一个指针变量 |
运算符优先级
| 5 | * / % << >> & &^ |
| 4 | + - | ^ |
| 3 | == != < <= > >= |
| 2 | && |
| 1 | || |
Go 语言条件语句
条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。
| if 语句 由一个布尔表达式后紧跟一个或多个语句组成。 | |
| if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。 | |
| 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。 | |
| switch 语句用于基于不同条件执行不同动作。 | |
| select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。 |
Go 语言 select 语句
select 语句的语法：
- 每个 case 都必须是一个通信
- 所有 channel 表达式都会被求值
- 所有被发送的表达式都会被求值
- 如果任意某个通信可以进行，它就执行，其他被忽略。
- 如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。
否则：- 如果有 default 子句，则执行该语句。
- 如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。
func selectFun() {
var c1, c2, c3 chan int
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("received ", i1, " from c1\n")
case c2 <- i2:
fmt.Println("sent ", i2, " to c2\n")
case i3, ok := (<-c3):
if ok {
fmt.Printf("received ", i3, " from c3\n")
} else {
fmt.Printf("c3 is closed\n")
}
default:
fmt.Printf("no communication\n")
}
}Go 语言循环语句
for 循环是一个循环控制结构，可以执行指定次数的循环。
语法
Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。
① 和 C 语言的 for 一样：
for init; condition; post { }② 和 C 的 while 一样：
for condition { }③ 和 C 的 for(;;) 一样：
for { }- init： 一般为赋值表达式，给控制变量赋初值；
- condition： 关系表达式或逻辑表达式，循环控制条件；
- post： 一般为赋值表达式，给控制变量增量或减量。
for语句执行过程如下：
- 1、先对表达式 1 赋初值；
- 2、判别赋值表达式 init 是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
for key, value := range oldMap {
newMap[key] = value
}func forFun() {
sum := 0
for i := 0; i <= 10; i++ {
sum += i
}
fmt.Println(sum)
sum = 1
for sum <= 10 {
sum += sum
}
fmt.Println(sum)
sum = 1
for sum <= 10 {
sum += sum
}
fmt.Println(sum)
strings := []string{"hello", "go"}
for i, s := range strings {
fmt.Println(i, s)
}
numbers := [6]int{1, 2, 3, 4}
for i, x := range numbers {
fmt.Println("第 %d 位x的值 = %d\n", i, x)
}
}循环控制语句
| break 语句 | 经常用于中断当前 for 循环或跳出 switch 语句 |
| continue 语句 | 跳过当前循环的剩余语句，然后继续进行下一轮循环。 |
| goto 语句 | 将控制转移到被标记的语句。 |
func forGotoFun() {
/* 定义局部变量 */
var a int = 10
/* 循环 */
LOOP:
for a < 20 {
if a == 15 {
/* 跳过迭代 */
a = a + 1
goto LOOP
}
fmt.Printf("a 的值为：%d\n", a)
a++
}
}
2825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
