🌷 博主 libin9iOak带您 Go to Golang Language.✨
🦄 个人主页——libin9iOak的博客🎐
🐳 《面试题大全》 文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺
🌊 《IDEA开发秘籍》学会IDEA常用操作，工作效率翻倍~💐
🪁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🐥
100天精通Golang（基础入门篇）
- 摘要:
- 引言:
- 运算符
- 一、运算符
- 1.1 算术运算符
- 1.2 关系运算符
- 1.3 逻辑运算符
- 1.4 位运算符
- 1.5 赋值运算符
- 1.6 运算符优先级
- 今日学习总结:
- 结语
摘要:
本文将介绍Golang中的各种运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符和赋值运算符。我们还将探讨运算符的优先级，以帮助读者更好地理解和使用Golang的运算符。
引言:
Golang是一种功能强大且易于学习的编程语言，它在开发高性能应用程序和分布式系统方面表现出色。熟练掌握Golang的基础知识对于成为一名优秀的开发人员至关重要。在本系列教程的基础入门篇中，我们将深入探讨Golang中的各个方面，从而帮助读者打下坚实的基础。本篇文章将专注于运算符，它们在编程中起着至关重要的作用。
运算符
表达式：(a + b) * c
a,b,c叫做操作数
+，*，叫做运算符
一、运算符
1.1 算术运算符
+ - * / %(求余) ++ --
代码案例：
package main
import "fmt"
func main() {
/*
算术运算符：+，-，*,/,%,++,--
+
-
*,乘法
/：取商，两个数相除，取商
%：取余，取模，两个数相除，取余数
++：给自己加1
i++
--：给自己减1
i--
整数
*/
a := 10
b := 3
sum := a + b
fmt.Printf("%d + %d = %d\n", a, b, sum)
sub := a - b
fmt.Printf("%d - %d = %d\n", a, b, sub)
mul := a * b
fmt.Printf("%d * %d = %d\n", a, b, mul)
div := a / b //取商
mod := a % b //取余
fmt.Printf("%d / %d = %d\n", a, b, div)
fmt.Printf("%d %% %d = %d\n", a, b, mod)
c := 3
c++ //就是给c+1
fmt.Println(c)
c-- //给c减1
fmt.Println(c)
}
运行结果：
GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day6_Operator.exe Day6-Operator #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day6_Operator.exe
10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3
10 % 3 = 1
4
3
进程 已完成，退出代码为 0
1.2 关系运算符
== != > < >= <=
代码案例：
package main
import "fmt"
func main() {
/*
关系运算符：>,<,>=,<=,==,!=
结果总是bool类型的：true，false
==：表示比较两个数值是相等的
!=：表示比较两个数值是不相等的
*/
a := 3
b := 5
c := 3
res1 := a > b
res2 := b > c
fmt.Printf("%T,%t\n", res1, res1)
fmt.Printf("%T,%t\n", res2, res2)
res3 := a == b
fmt.Println(res3)
res4 := a == c
fmt.Println(res4)
fmt.Println(a != b, a != c)
}
运行结果：
GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_relational_operator_go.exe D:\GolandProjects\Day6-Operator\relational_operator.go #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_relational_operator_go.exe
bool,false
bool,true
false
true
true false
进程 已完成，退出代码为 0
运行截图：
1.3 逻辑运算符
| 运算符 | 描述 |
|---|---|
| && | 所谓逻辑与运算符。如果两个操作数都非零，则条件变为真 |
| || | 所谓的逻辑或操作。如果任何两个操作数是非零，则条件变为真 |
| ! | 所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假 |
代码案例：
package main
import "fmt"
func main() {
/*
逻辑运算符：操作数必须是bool，运算结果也是bool
逻辑与：&&
运算规则：所有的操作数都是真，结果才为真，有一个为假，结果就为假
"一假则假，全真才真"
逻辑或：||
运算规则：偶有的操作数都是假，结果才为假，有一个为真，结果就为真
"一真则真，全假才假"
逻辑非：！
!T-->false
!F-->true
*/
f1 := true
f2 := false
f3 := true
res1 := f1 && f2
fmt.Printf("res1: %t\n", res1)
res2 := f1 && f2 && f3
fmt.Printf("res2: %t\n", res2)
res3 := f1 || f2
fmt.Printf("res3: %t\n", res3)
res4 := f1 || f2 || f3
fmt.Printf("res4: %t\n", res4)
fmt.Println(false || false || false)
fmt.Printf("f1:%t,!f1:%t\n", f1, !f1)
fmt.Printf("f2:%t,!f2:%t\n", f2, !f2)
a := 3
b := 2
c := 5
res5 := a > b && c%a == b && a < (c/b)
fmt.Println(res5)
res6 := b*2 < c || a/b != 0 || c/a > b
fmt.Println(res6)
res7 := !(c/a == b)
fmt.Println(res7)
}
运行结果：
res4: true
false
f1:true,!f1:false
f2:false,!f2:true
false
true
true
进程 已完成，退出代码为 0
运行截图：
1.4 位运算符
| A | B | A&B | A|B | A^B |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
这里最难理解的就是^了，只要认为AB两者都相同的时候，为0，其他都为1
假设A为60，B为13
| 运算 | 描述 | 示例 |
|---|---|---|
| & | 二进制与操作副本位的结果，如果它存在于两个操作数 | (A & B) = 12, 也就是 0000 1100 |
| | | 二进制或操作副本，如果它存在一个操作数 | (A | B) = 61, 也就是 0011 1101 |
| ^ | 二进制异或操作副本，如果它被设置在一个操作数就是按位取非 | (A ^ B) = 49, 也就是 0011 0001 |
| &^ | 二进制位清空&^ | (A&^B)=48，也就是110000 |
| << | 二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数 | A << 2 =240 也就是 1111 0000 |
| >> | 二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动 | A >> 2 = 15 也就是 0000 1111 |
代码案例：
package main
import "fmt"
func main() {
/*
位运算符：
将数值，转为二进制后，按位操作
按位&：
对应位的值如果都为1才为1，有一个为0就为0
按位|：
对应位的值如果都是0才为0，有一个为1就为1
异或^：
二元：a^b
对应位的值不同为1，相同为0
一元：^a
按位取反：
1--->0
0--->1
位清空：&^
对于 a &^ b
对于b上的每个数值
如果为0，则取a对应位上的数值
如果为1，则结果位就取0
位移运算符：
<<：按位左移，将a转为二进制，向左移动b位
a << b
>>: 按位右移，将a 转为二进制，向右移动b位
a >> b
*/
a := 60
b := 13
/*
a: 60 0011 1100
b: 13 0000 1101
& 0000 1100
| 0011 1101
^ 0011 0001
&^ 0011 0000
a : 0000 0000 ... 0011 1100
^ 1111 1111 ... 1100 0011
*/
fmt.Printf("a:%d, %b\n", a, a)
fmt.Printf("b:%d, %b\n", b, b)
res1 := a & b
fmt.Println(res1) // 12
res2 := a | b
fmt.Println(res2) // 61
res3 := a ^ b
fmt.Println(res3) // 49
res4 := a &^ b
fmt.Println(res4) // 48
res5 := ^a
fmt.Println(res5)
c := 8
/*
c : ... 0000 1000
0000 100000
>> 0000 10
*/
res6 := c << 2
fmt.Println(res6)
res7 := c >> 2
fmt.Println(res7)
}
运行结果：
a:60, 111100
b:13, 1101
12
61
49
48
-61
32
2
进程 已完成，退出代码为 0
运行截图：
1.5 赋值运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
| = | 简单的赋值操作符，分配值从右边的操作数左侧的操作数 | 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 |
代码案例：
package main
import "fmt"
func main() {
/*
赋值运算符：
=,+=,-=,*=,/=,%=,<<=,>>=,&=,|=,^=...
=，把=右侧的数值，赋值给=左边的变量
+=, a += b,相当于a = a + b
a++, a += 1
*/
var a int
a = 3
fmt.Println(a)
a += 4 // a = a + 4
fmt.Println(a) // 7
a -= 3
fmt.Println(a) // 4
a *= 2
fmt.Println(a) // 8
a /= 3
fmt.Println(a) // 2
a %= 1
fmt.Println(a) // 0
}
运行结果：
3
7
4
8
2
0
进程 已完成，退出代码为 0
运行截图：
1.6 运算符优先级
有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：
| 优先级 | 运算符 |
|---|---|
| 7 | ~ ! ++ – |
| 6 | * / % << >> & &^ |
| 5 | + - ^ |
| 4 | == != < <= >= > |
| 3 | <- |
| 2 | && |
| 1 | || |
当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。
今日学习总结:
今天我们详细了解了Golang中的各种运算符。我们学习了算术运算符，用于执行基本的数学运算，关系运算符，用于比较两个值之间的关系，逻辑运算符，用于执行逻辑操作，位运算符，用于对二进制位进行操作，以及赋值运算符，用于给变量赋值。我们还了解了运算符的优先级，这对于正确理解表达式的计算顺序非常重要。通过深入学习和练习，我们现在对Golang的运算符有了更深入的理解，为进一步探索Golang的编程能力打下了坚实的基础。
结语
通过今天的学习，您已经踏上了Golang的学习之旅。在未来的日子里，您将探索Golang的各个方面，从基础概念到高级技巧，从实际应用到性能优化。
学习一门编程语言是一个持续的过程，每一天都是您向Golang的精通迈进的重要一步。我鼓励您坚持每天学习，保持热情和好奇心，解决挑战并享受成功的喜悦。
在您的学习旅程中，不要忘记参与社区和与其他Golang开发者交流。分享您的见解和经验，向他人学习，并在开源项目或实际应用中展示您的技能。
如果您在学习过程中遇到困难或有任何问题，不要犹豫向社区和专家寻求帮助。持续学习，勇敢探索，您将在Golang领域取得令人瞩目的成就。
最后，感谢您的阅读和支持！祝愿您在未来的每一天中都能够成为一名精通Golang的开发者！
期待听到您在学习过程中的进展和成就。如果您需要进一步的帮助，请随时告诉我。祝您在学习Golang的旅程中取得巨大成功！
如果您在学习过程中有任何疑惑，请点击下方名片，带您一对一快速入门 Go语言 的世界 ~
