Go中的逻辑处理
if 语句
package main
import "fmt"
func main() {
if stu != nil {
//如果逻辑表达式成立,则执行这的代码
}
for i := 0; i < 100; i++ {
if i > 98 {
fmt.Println("hello")
}
}
for i := 0; i < 3; i++ {
//逻辑表达式中可以有变量或者常量
//if句子中云粗包含一个分号
//常见的if语句的形式
/**
if 条件表达式{
}
或者
if 初始化变量;条件{
}
*/
if c, d, e := 10, 12, 15; c < d && e > d {
fmt.Println("条件成立")
} else if i < 69 {
fmt.Println("条件不成立")
} else {
fmt.Println("条件不成立")
}
}
}
1,逻辑表达式中可以有变量或者常量
if句子中云粗包含一个分号常见的if语句的形式
/**
if 条件表达式{
}
或者
if 初始化变量;条件{
}
*/
注意:if所在行的大括号要跟if处在同一行,否则会报错:
在if中声明的局部变量只是作用在if这个判断逻辑里,
for i := 0; i < 100; i++ {
if i > 90 {
fmt.Println("hello")
}else if i<99{
fmt.Println("hi")
}
}
//看一下时间的包中的函数:
func TimeTest() {
now := time.Now()//2022-08-21 19:32:41.6640761 +0800 CST m=+0.001829201
weekday := now.Weekday()//Sunday
day := weekday.String()//Sunday
hour:=time.Now().Hour()//19
fmt.Println(now,weekday,day,hour)
}
switch语句
if可以嵌套,但是如果是多个判断条件,那么可以使用switch
func switchTest() {
day := time.Now().Weekday().String()
switch day {
case "Sunday":
fmt.Println("今天周日")
case "Saturday":
fmt.Println("今天周六")
case "Monday", "TuesDay"://case后面可以跟多个值,只要有一个匹配就可以了
default:
fmt.Println("滚去上班")
}
}
func main() {
switchTest()
}
switch -case-default 这个跟java类似;
switch 和case后面可以跟常量,变量,表达式,只要switch后面的数据类型跟case后面的数据类型相匹配就可以了;
switch 支不支持穿透呢?
上面的案例看到switch是不支持穿透的,
从上往下,只要找到成立的case,就不在执行后面的case了,所以为了提高亿点点性能,把大概率的情况放在前面
但是—>>
case里如果带了fallthrouth,则执行完本case之后还会去判断下一个case是否满足;
在switch type 语句中case字句不能使用fallthrough
func main() {
TimeDemo()
}
func TimeDemo(){
t:=time.Now().Month().String()
switch{
case t=="September":
fmt.Println("九月了")
default:
fmt.Println("还是夏天")
}
switch {
case add(12,13)<30:
fmt.Println("不符合条件")
//case add(0,12):
fmt.Println("不能同名呀")
fallthrough
case t=="August":
fmt.Println("八月")
fallthrough
default:
fmt.Println("如果switch后面无数据,则case后面可以接任意的常量,表达式的逻辑的判断")
}
}
func add(a,b int) int{
return a+b
}
switch 后面没有加条件时,我们可以将条件写在case后面
func main() {
TimeDemo()
}
func TimeDemo(){
t:=time.Now().Month().String()
switch{
case t=="September":
fmt.Println("九月了")
default:
fmt.Println("还是夏天")
}
switch {
case add(12,13)<30:
fmt.Println("不符合条件")
//case add(0,12):
fmt.Println("不能同名呀")
case t=="August":
fmt.Println("八月")
default:
fmt.Println("如果switch后面无数据,则case后面可以接任意的常量,表达式的逻辑的判断")
}
}
func add(a,b int) int{
return a+b
}
switch 来判断数据类型:
这里提示要求是左侧应该是接口类型的数据类型
查资料—>>
即下面这种方式:
//这里用接口来声明
var str interface{}=10.889
接口之后再去深入学习,先简单了解下—
//switch判断数据类型
func switchType(){
//这里用接口来声明
var str interface{}=10.889
switch str.(type){
case int:
fmt.Println("int")//这里已经被强制转换为int类型了,如果数据类型是int的话;
case float64:
fmt.Println("float64")
default:
fmt.Println("other type")
}
}
func main() {
var a interface{}=64.0
fmt.Println(square(a))
}
func square(a interface{}) interface{} {
switch value := a.(type) {
case int:
return value * value
case float64:
return value * value
default:
return value
}
}
//相当于已经强制转换了数据类型
func square2(a interface{}) interface{} {
switch a.(type) {
case int:
value:=a.(int)
return value * value
case float64:
value:=a.(float64)
return value * value
default:
value:=a.(byte)
return value
}
}
for循环
fori
func forTest() {
arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
for i := 0; i < len(arr); i++ {
fmt.Println(arr[i])
}
var i = 0
for i < len(arr) {
fmt.Println(arr[i])
i++
}
for i,con:= range arr{
fmt.Println(arr[i],con)
}
for a,sum:=0,0;a<len(arr)&&sum<60;a++ {
sum+=a
fmt.Println(sum)
}
}
func main() {
forTest()
}
关于for循环,
1. 初始化变量可以放在for()之外(上),后续操作可以放在for内部
2. 只有条件判断时可以不适用分号
3. 死循环for{}
for range
1,遍历数组或切片
//声明一个数组
a := [...]int{1, 2, 3, 4}
//遍历数组
//方式1
for i := 0; i < len(a); i++ {
fmt.Println(a[i])
}
//方式2
for i, ele := range a {
fmt.Println(i, ele)
fmt.Println(a[i], ele)
}
//同理遍历切片
2,遍历string
//声明一个string
str := "床前明月光"
//遍历string
//这里应该把string转为数组
brr:=[]byte(str)
for i := 0; i < len(brr); i++ {
//这怎么输出呢?
fmt.Println(brr[i])
}
for i, ele := range str {
fmt.Println(i, ele)
}
3,遍历map
//声明一个map
var m map[string]string
//实例化map
m = make(map[string]string, 5)
m = map[string]string{"hello": "你好", "hi": "你也好"}
//遍历map
for i := 0; i < len(m); i++ {
//这里没法输出呀
}
//使用range ----有点类似于java中iterator 不保证便利的顺序
for key, value := range m {
fmt.Println(key, m[key], value)
}
4,遍历管道
//声明一个channel
var ch chan string
//实例化一个管道
ch = make(chan string, 9)
//管道中添加元素
ch <- "1"
ch <- "2"
//关闭管道之后才能 用range遍历
close(ch)
for ele := range ch {
fmt.Println(ele)
}
//这种方式不要求关闭管道
for i := 0; i < len(ch); i++ {
value := <-ch
fmt.Println(value)
}
for range拿到的是数据的拷贝
continue 与break
package main
import "fmt"
func main() {
arr := [5]int{1, 2, 3, 4, 5}
breakTest(arr)
var fast = [4][4]int{{1, 2, 3, 4}, {5, 4, 3, 2}, {6, 7, 8, 9}, {9, 8, 7, 6}}
test(fast)
}
func breakTest(a [5]int) {
for i := 0; i < len(a); i++ {
fmt.Println(i, a[i])
if i > 2 {
continue //
}
fmt.Printf("next I %d\n", i+1)
}
}
func test(a [4][4]int) {
for i := 0; i < len(a[i]); i++ {
if i%2==1 {
break
}
for j := 0; j < len(a[j]); j++ {
if j%2==0 {
continue
}
fmt.Println(a[i][j])
}
}
}
goto 与label
简单的goto 与label
func master() {
var result int
var i = 0
goto LB1
LB1:
i=i+999
result = result + i
fmt.Println(result)
}
结果 999
在if使用goto 和label:
func test() {
var i int
i = 100
if i%2 == 0 {
goto L1
} else {
goto L2
}
L1:
i = i + 19
L2:
i = i - 1
fmt.Println(i)
}
猜一下结果---->>
100%20是成立的,所以跳到L1中执行,此时i=119 但是119%20是不成立的所以会执行L2,最后输出了 118
break continue 与lable 也可以结合使用:
我们来看一下在没有使用 label时,
func break_GOTO() {
//Lb:
for i := 0; i < 100; i++ {
for j := 0; j < 100; j++ {
if j == 50 {
fmt.Println(i)
break //跳出循环到外层循环--本来break只能中断内存循环
}
}
//continue Lb
}
}
此时代码输出结果:
可以看到并没有影响到 外层循环,那如果我想要在某一个条件下退出,那怎么办呢?
func break_GOTO() {
Lb:
for i := 0; i < 100; i++ {
for j := 0; j < 100; j++ {
if j == 50 {
fmt.Println(i)
break Lb //跳出循环到外层循环--本来break只能中断内存循环
}
}
//continue Lb
}
}
执行结果:
这个就像java中的 那一种形式 循环标签
//这是java代码
public class Demo {
public static void main(String[] args) {
outer:
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
if(j==56){
break outer;
}
System.out.println(j);
}
System.out.println("测测试");
}
System.out.println("完成了");
}
}