Go语言的中间件（middleware）是如何实现的？

目录

运算符

算术运算符

赋值运算符

关系运算符

逻辑运算符

位运算符

其他运算符

流程控制

条件语句

循环语句

跳转语句

运算符

运算符用于对操作数执行算术、逻辑、位或其他运算。Go语言中的运算符包括如下几种情况：

算术运算符

举例的代码如下：

package main
import "fmt"
func main() {
	// + 加号的三个作用
	// 1. 用于表示正数
	var n1 int = +10
	fmt.Println(n1)
	// 2. 相加操作
	var n2 int = 10 + 12
	fmt.Println(n2)
	// 3. 字符串拼接
	var s1 string = "hello" + "world"
	fmt.Println(s1)

	// / 除号
	fmt.Println(10 / 3)   // 两个整数相除，结果也是整数
	fmt.Println(10.0 / 3) // 浮点数相除，结果也是浮点数

	// % 取余
	fmt.Println(10 % 3)  // 两个整数相除，结果也是整数
	fmt.Println(-10 % 3) // 浮点数相除，结果也是浮点数
	
	// ++ 自增操作 (go语言中，++或者-- 只能放在变量后面，不能放在变量前面，只能单独使用，不能放在表达式中)
	var n3 int = 10
	n3++
	fmt.Println(n3)
}

最终达到的效果如下所示：

赋值运算符

举例的代码如下：

package main
import "fmt"
func main() {
	var a int = 10
	var b int = 20
	fmt.Printf("a = %v, b = %v\n", a, b) // a = 10, b = 20
	// 交互数值
	var c int
	c = a
	a = b
	b = c
	fmt.Printf("a = %v, b = %v\n", a, b) // a = 20, b = 10
}

关系运算符

举例的代码如下：

package main
import "fmt"
func main() {
	// 判断左右两边是否相等，相等返回true，否则返回false
	fmt.Println(5 == 9) // false
	fmt.Println(5 == 5) // true
	fmt.Println(5 > 6)  // false
	fmt.Println(5 < 6)  // true
}

逻辑运算符

举例的代码如下：

package main
import "fmt"
func main() {
	// 与逻辑：&& 两个数值都为真时才为真，否则为假
	fmt.Println(true && true)  // true
	fmt.Println(true && false) // false
	// 或逻辑：|| 两个数值有一个为真时，则结果为真
	fmt.Println(true || true)   // true
	fmt.Println(true || false)  // true
	fmt.Println(false || false) // false
	// 非逻辑：! 逻辑非，取反
	fmt.Println(!true)  // false
	fmt.Println(!false) // true
}

位运算符

举例的代码如下：

package main
import "fmt"
func main() {
	var num1 uint8 = 5 // 二进制表示: 0000 0101
	var num2 uint8 = 3 // 二进制表示: 0000 0011

	//比较两个数的每一位，并将至少有一个数为1的位设置为1。
	/*
		num1: 0000 0101 (十进制中的5)
		num2: 0000 0011 (十进制中的3)
		------------
		result: 0000 0111 (十进制中的7)
	*/
	result := num1 | num2 // 结果为 7，二进制表示: 0000 0111
	fmt.Printf("Result: %d\n", result)
}

其他运算符

举例的代码如下：

package main
import "fmt"
func main() {
	// 定义一个变量
	var a int = 10
	fmt.Println("a对应的存储空间地址为：", &a) //  0xc000116068

	var ptr *int = &a
	fmt.Println(ptr) //  0xc000116068
	fmt.Println("ptr这个指针指向的具体数值为：", *ptr) // 10

}

Go语言有几十种运算符，被分成十几个级别，有的运算符优先级不同，有的运算符优先级相同，请看下表，为了提高优先级可以加()：

流程控制

流程控制决定了代码的执行顺序。Go语言中的流程控制结构包括如下几种情况：

条件语句

条件语句也叫分支结构，主要分为if分支和switch分支：

举例的代码如下：

package main
func main() {
	// 实现如果成绩低于60则提示成绩不及格
	var score int = 69
	// 判断变量可以不需要加括号，但是需要加{}
	if score < 70 {
		println("成绩不及格")
	}
	// 在golang中，if后面可以并列的加入变量的定义，这里通过if else实现
	if count := 10; count < 20 {
		println("count小于20")
	} else {
		println("count大于等于20")
	}
	// 对学生的成绩级别进行判别
	if score < 60 {
		println("不及格")
	} else if score < 80 {
		println("及格")
	} else if score < 90 {
		println("良好")
	} else if score <= 100 {
		println("优秀")
	} else {
		println("成绩有误")
	}
}

举例的代码如下：

package main
import "fmt"
func main() {
	// 输入学生成绩，判断成绩等级
	var score int
	var grade string
	println("请输入成绩：")
	fmt.Scanln(&score)
	// 使用switch语句进行判断
	switch {
	case score < 60:
		grade = "不及格"
	case score >= 60 && score <= 70:
		grade = "及格"
	case score > 70 && score <= 80:
		grade = "良好"
	case score > 80 && score <= 100:
		grade = "优秀"
	default:
		grade = "请输入正常的成绩"
	}
	// 输出成绩等级
	println("成绩等级为：", grade)
}

最终得到的结果如下所示：

循环语句

go语言中循环语句只有for 循环，用于重复执行代码块，直到满足某个条件。

举例的代码如下：

func main() {
	// 求和 1-100
	var sum int = 0
	// 注意：for循环初识表达式，不能用var定义变量的形式，要用 :=
	for i := 1; i <= 100; i++ {
		sum += i
	}
	println(sum) // 5050
}

如果想书写死循环的话，可以采用下面的方式进行：

func main() {
	// 死循环实现方式1
	for {
		println("死循环")
	}
	// 死循环实现方式2
	for ;; {
		println("死循环")
	}
}

for key, val := range coll {
    ...
}

举例的代码如下：

func main() {
	var str string = "hello world"
	// 对str进行遍历，i是索引，value是str的每个字符
	for i, value := range str {
		println(i, string(value))
	}
}

最终得到的结果如下所示：

跳转语句

跳转语句是编程中用于改变程序正常执行流程的一种控制语句。它们允许程序在特定条件下跳过某些代码段，或者立即结束某个循环或函数，从而改变程序的执行路径。以下是四种常见的跳转语句及其描述：

举例的代码如下：

func main() {
	var sum int = 0
	for i := 1; i <= 100; i++ {
		sum += i
		fmt.Println(sum)
		if sum >= 300 {
			break
		}
	}
	fmt.Println(sum, "sum > 300, 程序停止了")
}

最终得到的结果如下所示：

举例的代码如下：

func main() {
	// 输出1-100中被6整除的数：
	// 正常使用if语句
	for i := 1; i <= 100; i++ {
		if i%6 == 0 {
			println(i)
		}
	}
	// 采用continue语句
	for i := 1; i <= 100; i++ {
		if i%6 != 0 {
			continue
		}
		println(i)
	}
}

最终得到的结果如下所示：

举例的代码如下：

package main
import "fmt"
func main() {
	i := 0
	// 定义一个标签
	startLoop:
	// 使用for循环和goto模拟一个可能使用goto的场景
	// 在实际编程中，通常不需要使用goto来实现循环
	for {
		if i > 10 {
			// 当i大于10时，跳转到endLoop标签处
			goto endLoop
		}
		fmt.Println(i)
		i++
		// 假设有一些复杂的条件判断，导致我们需要重新开始循环
		// 这里使用goto来模拟这种情况
		goto startLoop
	}

	// 这个endLoop标签在for循环内部是访问不到的，但为了演示goto的用法，我们放在这里
	endLoop:
	fmt.Println("Loop ended")

	// 注意：在实际程序中，endLoop标签后面的代码永远不会被执行到，
	// 因为for循环会无限循环直到i大于10，然后goto跳转到endLoop，
	// 接着main函数就结束了，不会继续执行endLoop后面的代码。
}

最终得到的结果如下所示：

举例的代码如下：

package main
import "fmt"
func main() {
	for i := 1; i <= 100; i++ {
		fmt.Println(i)
		if i == 10 {
			return
		}
	}
	fmt.Println("由于return，我无法被执行")
}

最终得到的结果如下所示：