Go语言基础之流程结构
位运算符
（数的二进制来进行计算的，加密解密，一些特殊的高效运算）
Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符"&"是双目运算符。都是1结果为1，否则是0 | (A & B) 结果为 12, 二进制为 0000 1100 |
| 丨 | 按位或运算符"丨"是双目运算符。 都是0结果为0，否是是1 | (A 丨 B) 结果为 61, 二进制为 0011 1101 |
| ^ | 按位异或运算符"^"是双目运算符。 不同则为1，相同为0 | (A ^ B) 结果为 49, 二进制为 0011 0001 |
| &^ | 位清空，a &^ b，对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0. | (A &^ B) 结果为 48, 二进制为 0011 0000 |
| << | 左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。 其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0。 | A << 2 结果为 240 ，二进制为 1111 0000 |
| >> | 右移运算符">>“是双目运算符。右移n位就是除以2的n次方。 其功能是把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。 | A >> 2 结果为 15 ，二进制为 0000 1111 |
package main
import "fmt"
// 位运算符（二进制相关的,只需要作为了解） 假定 A 为60，B 为13
// A 60 0011 1100
// B 13 0000 1101
func main() {
// 0 false 1 true
var a int = 60
var b int = 13
// & 按位与 两个都是真，结果为真
// 0011 1100
// 0000 1101
// ---------
// 0000 1100
fmt.Println(a & b) // 60&13 = 12 (二进制转换为10进制的结果)
// | 按位或 如果都是假的结果才为假0,如果有一个1则为1
// 0011 1100
// 0000 1101
// ---------
// 0011 1101
fmt.Println(a | b) // 61
// ^ 按位异或， 不同则为1.相同就为0
// 0011 1100
// 0000 1101
// ---------
// 0011 0001
fmt.Println(a ^ b) // 49
// &^ 位清空，对于b上的每个数值，如果为0，则取a对应位上的数值;如果为1，则取0.
// 0011 1100
// 0000 1101
// ---------
// 0011 0000
fmt.Println(a &^ b) // 48
// 左移 << n 、右移 >> n 移动的位数
// 移动完毕后，需要补位（左移补右边，相反一样）
// 1111 0000
// 60 -> 240
fmt.Println(a << 2) // 240
// 0000 1111
fmt.Println(a >> 2) // 15
}
赋值运算符
下表列出了所有Go语言的赋值运算符。
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 | 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() {
// = 赋值
var a int = 1
var c int // 0
// a = a + b （语法糖）
c += a // c = c + a
fmt.Println(c)
c -= a // c = c - a
c *= a // c = c * a
c /= a // c = c / a
// c = c + a
// c += a
}
其他运算符
下表列出了Go语言的其他运算符。
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 返回变量存储地址 | &a; 将给出变量的实际地址。 |
| * | 指针变量。 | *a; 是一个指针变量 |
流程控制
面向过程编程
- 自上而下的执行（）
面向对象编程：让程序像人一样的思考来运行，而不是机械式的自上而下 （架构）
- 将世界抽象为一个个的对象，然后用程序来模拟这一个个的对象，然后进行一些人工化的操作实现
现实世界的逻辑
- 定义 （属性）
- 判断 （对错，导向不同的结果）
- 循环 （很多事情本质上都是在循环的） 时间（秒、时、分、日、月、年、周）
程序代码底层的本质，也和上面相同，所有编程语言都有的
- 定义 变量、常量
- 需要在程序中进行一些判断，来做出一些不同的决定 if 如果…如果条件二else if…否则else…
- 考分，90 + A 80 - 90 B 70-80 C 0-60 D …
- 循环，我们希望程序不停的做一件事情 for 循环
- 服务器，我们希望程序是一直执行
- 大量计算，1 + … + 100000000
顺序结构：自上而下运行
选择结构：满足了某些条件才会执行
- if （常用的）
- switch （也要学会使用，某些情况下可以优化代码结构）
循环结构：条件满足的情况，我们会去循环0 - N次。
- for
if 如果
- if可以单独存在，不一定要陪 else
- if … else
- if … elseif … else if … else
判断：对和错
if 条件：bool{
}
package main
import "fmt"
func main() {
//
var num int = 15
// if 不满足则跳过该if里面的代码，程序不会执行
if num > 100 {
fmt.Println("num > 100")
}
// if的代码必须要条件满足才可以执行
if num > 10 {
fmt.Println("num > 10")
}
fmt.Println("main end")
}
如果 。。。 否则。。。
// 成绩
var score int = 90
// 满足一个条件，则进入对应的处理代码
if score == 100 {
fmt.Println("满分")
} else { // 不满足就进入else
fmt.Println("不及格")
}
if小练习
package main
import "fmt"
// 命令行程序 go build xxx.go 生成可执行程序。
func main() {
// 练习：if的练习
// 判断用户密码输入是否正确
// 输入框 ： 接收用户的输入 （新知识）
// 第一次判断
// 输入框 ：请再次输入密码 接收用户的输入 （新知识）
// 第二次判断
// 如果两次都是对的，那么则登录成功
//
var num1 int
var num2 int
// 提示用户输入
fmt.Printf("请输入密码 ： \n")
// 接收用户的输入 （阻塞式等待... 直到用户输入之后才继续运行）最简单的人机交互
// Scan() &num1地址，
fmt.Scan(&num1) // 等待你的输入，卡住... 如果你输入完毕，回车。输入内容就会赋值给num
// 123456 模拟数据，未来是在数据库中查询出来的。根据用户查的
if num1 == 123456 {
fmt.Println("请再次输入密码: ")
fmt.Scan(&num2)
if num2 == 123456 {
fmt.Println("登录成功")
} else {
fmt.Println("登录失败")
}
} else {
fmt.Println("登录失败")
}
}
多个条件的判断
package main
import "fmt"
func main() {
// 分数
var score int
fmt.Println("请输入你的成绩：")
fmt.Scan(&score)
// 逻辑运算符应用 90<=score<=100 不能这样写的
if score >= 90 && score <= 100 {
fmt.Println("A")
} else if score >= 80 && score < 90 {
fmt.Println("B")
} else if score >= 70 && score < 80 {
fmt.Println("C")
} else if score >= 60 && score < 70 {
fmt.Println("D")
} else if score < 0 || score > 100 { // 健壮性判断
fmt.Println("输入不合法")
} else { // else 如果以上的条件都不满足，则执行 else
fmt.Println("不及格")
}
}
switch
if var == 1{
}else if var == 2{
}else if var == 3{
}else{
}
// 匹配机制 var1 ，根据下面的case结果来进行校验，满足则执行，不满足 default
switch var1 {
case val1：
case val2：
default:
}
switch的基本使用
package main
import "fmt"
func main() {
var score int = 100
// 通过switch来判断score
// case , 后面可以写多个条件
switch score {
case 100, 95, 91:
fmt.Println("A")
case 90:
fmt.Println("B")
case 80, 70, 60:
fmt.Println("C")
default:
fmt.Println("other")
}
// switch 是可以省略条件的，默认是 switch true
switch{
case false:
fmt.Println("false")
case true:
fmt.Println("true")
default:
fmt.Println("其他")
}
//var flag bool
//switch flag {
//case score<100 :
//
//}
}
特殊的情况：需要多个条件结果的输出，case穿透 。fallthrough
package main
import "fmt"
func main() {
a := false
// 这里的爆红不影响
switch a {
case false:
fmt.Println("1") // 默认只会输出1
fallthrough // 在case中 一旦使用了 fallthrough，则会强制执行下一个case语句
case true:
fmt.Println("2")
case false:
fmt.Println("3")
case true:
fmt.Println("4")
case false:
fmt.Println("5")
default:
fmt.Println("6")
}
}
退出case穿透
package main
import "fmt"
func main() {
a := false
// 这里的爆红不影响 if{....}
switch a {
case false: // 基本业务代码
fmt.Println("1") // 业务代码
fallthrough // 在case中 一旦使用了 fallthrough，则会强制执行下一个case语句，不会去判断条件的
case true: // 善后代码
fmt.Println("2")
fallthrough
case false:
fmt.Println("3")
fallthrough
case true:
// 判断了一些错误... 跳出终止这个case
if a == false {
break
}
fmt.Println("4")
fallthrough
case false:
fmt.Println("5")
fallthrough
default:
fmt.Println("6")
}
// 如果满足，则返回基本查询结果，和一个状态结果
// name success 用户信息 ok 200... 状态码结果.. 其他东西
}
分支结构小结
- if
- if … else if
- if … else
- if … else if … else if … else if… else
- swtich - case
- swtich - case - fallthrough
- swtich - case - default
for
循环：做一些重复性的操作
package main
import "fmt"
// 输出0-10，每输出完一个换行
func main() {
// 了解for循环
//for 参数1：从哪里开始 参数2：到哪里结束 参数3：控制这个循环条件变量（自增和自减）
for i := 0; i <= 10; i++ {
fmt.Println(i)
}
}
计算1 + 10 的和
package main
import "fmt"
// 计算1 + 10 的和
func main() {
sum := 0 // 相加的一个结果
// goland的快捷输入 fori
for i := 1; i <= 123133; i++ {
fmt.Println("i=", i, " , sum=", sum)
sum = sum + i
}
fmt.Println(sum) // 7580929411
}
for循环的探究
package main
import "fmt"
// 探究for循环 init：起始值 end：结束值 condition：条件变量
func main() {
i := 0
// for 循环可以直接
// 在for循环中定义的变量，作用域就只在 for循环内，外面是无法调用的
// for + 结束for条件就可以跑起来
for i <= 5 {
i++
}
fmt.Println(i)
}
package main
import (
"fmt"
)
// 探究for循环 init：起始值 end：结束值 condition：条件变量
func main() {
// 没有起始值、没有结束... 无限循环，死循环, 不要在开发中写这种代码。会内存溢出
for {
fmt.Println("hello,world")
}
}
终止循环
break ： 结束整个循环，立即停止
continue ：结束当前这次循环，继续进行下一次循环
package main
import "fmt"
func main() {
for i := 1; i <= 10; i++ {
if i == 5 {
//break
continue // 到这里就结束了当次循环，不会向下了，继续从头开始
}
fmt.Println(i)
}
}
练习：
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
package main
import "fmt"
/*
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
*/
func main() {
// for循环的嵌套
for i := 1; i <= 5; i++ {
for j := 0; j < 5; j++ {
fmt.Print("* ")
}
fmt.Println()
}
}
循环小结
- for init；end；post {}
- for { } 死循环
- break
- continue
- for循环的嵌套使用。
阅读建议
评论
匿名评论
隐私政策
你无需删除空行，直接评论以获取最佳展示效果