欢迎来到Golang的世界!在当今快节奏的软件开发领域,选择一种高效、简洁的编程语言至关重要。而在这方面,Golang(又称Go)无疑是一个备受瞩目的选择。在本文中,带领您探索Golang的世界,一步步地了解这门语言的基础知识和实用技巧。
目录
运算符
算术运算符
赋值运算符
关系运算符
逻辑运算符
位运算符
其他运算符
流程控制
条件语句
循环语句
跳转语句
运算符
运算符用于对操作数执行算术、逻辑、位或其他运算。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语言有几十种运算符,被分成十几个级别,有的运算符优先级不同,有的运算符优先级相同,请看下表,为了提高优先级可以加():
优先级 | 分类 | 运算符 | 结合性 |
---|---|---|---|
1 | 逗号运算符 | , | 从左到右 |
2 | 赋值运算符 | =、+=、-=、/=、%=、>=、<<=、&=、^=、|= | 从右到左 |
3 | 逻辑或 | || | 从左到右 |
4 | 逻辑与 | && | 从左到右 |
5 | 按位或 | | | 从左到右 |
6 | 按位异或 | ^ | 从左到右 |
7 | 按位与 | & | 从左到右 |
8 | 相等/不等 | ==、!= | 从左到右 |
9 | 关系运算符 | <、<=、>、>= | 从左到右 |
10 | 位移运算符 | <<、>> | 从左到右 |
11 | 加法/减法 | +、- | 从左到右 |
12 | 乘法/除法/取余 | *、/、% | 从左到右 |
13 | 单目运算符 | !、*、&、++、--、+、- | 从右到左 |
14 | 后缀运算符 | ( )、[ ]、-> | 从左到右 |
流程控制
流程控制决定了代码的执行顺序。Go语言中的流程控制结构包括如下几种情况:
条件语句
条件语句也叫分支结构,主要分为if分支和switch分支:
if分支有如下情况:
if 语句:用于基于条件执行代码块。
if-else 语句:用于基于条件执行两个代码块之一。
if-else if-else 语句:用于基于多个条件执行不同的代码块。
举例的代码如下:
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("成绩有误")
}
}
switch分支有如下情况:
switch 语句:类似于其他语言中的 switch-case 结构,但go的 switch 可以使用任何类型作为条件表达式,并且不需要 break 语句来终止每个 case。
举例的代码如下:
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)
}
最终得到的结果如下所示:
注意事项:
1)switch后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以)
2)case后面的表达式如果是常量值(字面量),则要求不能重复
3)case后的各个值的数据类型,必须和switch的表达式数据类型一致
4)case后面可以带多个值,使用逗号间隔。比如case值1,值2...
5)case后面不需要带break
6)default语句不是必须的,位置也是随意的。
7)switch后也可以不带表达式,当做if分支来使用
8)switch后也可以直接声明/定义一个变量,分号结束,不推荐
9)switch穿透,利用fallthrough关键字,如果在case语句块后增加fallthrough,则会继续执行下一个case,也叫switch穿透。
循环语句
go语言中循环语句只有for 循环,用于重复执行代码块,直到满足某个条件。
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("死循环")
}
}
range 关键字:常与 for 循环一起使用,用于迭代数组、切片、映射或通道的元素。其在语法上类似其他语言中的foreach,一般形式如下:
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))
}
}
最终得到的结果如下所示:
跳转语句
跳转语句是编程中用于改变程序正常执行流程的一种控制语句。它们允许程序在特定条件下跳过某些代码段,或者立即结束某个循环或函数,从而改变程序的执行路径。以下是四种常见的跳转语句及其描述:
break语句:用于立即退出最内层的循环或 switch 语句。用于立即终止离它最近的循环(如while、do-while、for)或switch语句,并从这些语句之后的第一条语句继续执行。
举例的代码如下:
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, 程序停止了")
}
最终得到的结果如下所示:
continue语句:用于跳过当前循环的剩余部分,并立即开始下一次迭代。用于终止当前循环的本次迭代,并立即开始下一次迭代。
举例的代码如下:
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)
}
}
最终得到的结果如下所示:
goto语句:用于无条件地跳转到程序中的指定标签。尽管 goto 在某些情况下可能有用,但过度使用它可能会导致代码难以理解和维护,因此通常建议避免使用。
举例的代码如下:
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后面的代码。
}
最终得到的结果如下所示:
return语句:return语句后面的代码不会被执行,因为函数已经退出。用于立即结束当前函数,并将控制权返回给调用该函数的地方。
举例的代码如下:
package main
import "fmt"
func main() {
for i := 1; i <= 100; i++ {
fmt.Println(i)
if i == 10 {
return
}
}
fmt.Println("由于return,我无法被执行")
}
最终得到的结果如下所示: