go语言基础学习随笔＜2＞

最新推荐文章于 2024-01-15 21:32:25 发布

独具慧欣

最新推荐文章于 2024-01-15 21:32:25 发布

阅读量129

点赞数 1

文章标签： golang 后端 idea

本文链接：https://blog.csdn.net/qq_32539157/article/details/126539109

版权

5、Golang 中的运算符

5.1、Golang 内置的运算符

（1）、算术运算符

（2）、关系运算符

（3）、逻辑运算符

（4）、位运算符

（5）、赋值运算符

5.2、算数运算符

运算符	描述
+	相加
-	相减
*	相乘
/	相除
%	求余=被除数-（被除数/除数）*除数

fmt.Println(-10%3)  -1;= -10 -(-10/3)*3

注意： ++（自增）和--（自减）在Go 语言中是单独的语句，并不是运算符。

（1）、在golang 中，++ 和-- 只能独立使用。错误写法如下：

var i int = 8
var a int
a = i++ //错误，i++只能独立使用
a = i-- //错误, i--只能独立使用

（2）、在golang 中没有前++ 错误写法如下：

var i int = 1
++i // 错误，在golang 没有前++
--i // 错误，在golang 没有前--
fmt.Println("i=", i)

（3）、++和--正确写法：

var i int = 1
i++
fmt.Println("i=", i)
3

5.3、关系运算符

运算符	描述
==	两个值是否相等，如果相等返回True 否则返回False。
!=	两个值是否不相等，如果不相等返回True 否则返回False。
>	左边值是否大于右边值，如果是返回True 否则返回False。
>=	左边值是否大于等于右边值，如果是返回True 否则返回False。
<	左边值是否小于右边值，如果是返回True 否则返回False。
<=	左边值是否小于等于右边值，如果是返回True 否则返回False。

5.4、逻辑运算符

运算符	描述
&&	逻辑AND 运算符。如果两边的操作数都是True，则为True，否则为False。
\|\|	逻辑OR 运算符。如果两边的操作数有一个True，则为True，否则为False。
!	逻辑NOT 运算符。如果条件为True，则为False，否则为True。

5.5、赋值运算符

运算符	描述
=	赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值

5.6、位运算符(了解)

位运算符对整数在内存中的二进制位进行操作。

运算符	描述
&	参与运算的两数各对应的二进位相与。（两位均为1 才为1）
\|	参与运算的两数各对应的二进位相或。（两位有一个为1 就为1）
^	参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。（两位不一样则为1）
<<	左移n 位就是乘以2 的n 次方。“a<<b”是把a 的各二进位全部左移b 位，高位丢弃，低位补0。
>>	右移n 位就是除以2 的n 次方。“a>>b”是把a 的各二进位全部右移b 位。

package main
import "fmt"
func main() {
	/*
		& 两位均为1 才为1
		| 两位有一个为1 就为1
		^ 相异或两位不一样则为1
		<< 左移n 位就是乘以2 的n 次方。“a<<b”是把a 的各二进位全部左移b 位，
		高位丢弃，低位补0。
		右移n 位就是除以2 的n 次方。
	*/
	var a int = 5 // 101
	var b int = 2 // 010
	fmt.Println("a&b=", a&b) // 000 值0
	fmt.Println("a|b=", a|b) // 111 值7
	fmt.Println("a^b=", a^b) // 111 值7
	fmt.Println("5>>2=", a>>b) // 5 右移2 位1
	fmt.Println("5<<2=", a<<b) // 5 左移2 位10100
	fmt.Println("5<<1=", 5<<1) // 1010
	fmt.Println("5>>1=", 5>>1) // 10
	fmt.Println("7>>2=", 7>>2) // 1
}

6、Golang 中的流程控制

Go 语言中最常用的流程控制有if 和for，而switch 和goto 主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制。

6.1、if else(分支结构)

6.1.1、if 条件判断基本写法

Go 语言中if 条件判断的格式如下：

if 表达式1 {
	分支1
} else if 表达式2 {
	分支2
} else{
	分支3
}

注意：Go 语言规定，与if 匹配的左括号{必须与if 和表达式放在同一行，{放在其他位置会触发编译错误。同理，与else 匹配的{也必须与else 写在同一行，else 也必须与上一个if 或else if 右边的大括号在同一行。

func ifDemo1() {
	score := 65
	if score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}

6.1.2、if 条件判断特殊写法

if 条件判断还有一种特殊的写法，可以在if 表达式之前添加一个执行语句，再根据变量值进行判断，举个例子：

if score := 56; score >= 90 {
	fmt.Println("A")
} else if score > 75 {
	fmt.Println("B")
} else {
	fmt.Println("C")
}

6.2、for(循环结构)

Go 语言中的所有循环类型，均可以使用for 关键字来完成。

6.2.1、for 循环的基本格式

for 初始语句;条件表达式;结束语句{
	循环体语句
}

条件表达式返回true 时循环体不停地进行循环，直到条件表达式返回false 时自动退出循环。

for i := 0; i < 10; i++ {
	fmt.Println(i)
}

for 循环的初始语句可以被忽略，但是初始语句后的分号必须要写，例如：

i := 0
for ; i < 10; i++ {
	fmt.Println(i)
}

for 循环的初始语句和结束语句都可以省略，例如：

i := 0
for i < 10 {
	fmt.Println(i)
	i++
}

这种写法类似于其他编程语言中的while，在while 后添加一个条件表达式，满足条件表达式时持续循环，否则结束循环。

注意：Go 语言中是没有while 语句的，我们可以通过for 代替

6.2.2、for 无限循环

for {
	循环体语句
}

for 循环可以通过break、goto、return、panic 语句强制退出循环。

k := 1
// 这里也等价for ; ; {
for {
	if k <= 10 {
		fmt.Println("ok~~", k)
	} else {
		break //break 就是跳出这个for 循环
	}
	k++
}

6.2.3、for range(键值循环)

Go 语言中可以使用for range 遍历数组、切片、字符串、map 及通道（channel）。通过for range 遍历的返回值有以下规律：

（1）、数组、切片、字符串返回索引和值；

（2）、map 返回键和值；

（3）、通道（channel）只返回通道内的值。

str := "abc 上海"
for index, val := range str {
  	fmt.Printf("index=%d, val=%c \n", index, val)
}
str := "abc 上海"
for _, val := range str {
	fmt.Printf("val=%c \n", val)
}

6.2.4、switch case

使用switch 语句可方便的对大量的值进行条件判断。Go 语言规定每个switch 只能有一个default 分支；每个case 语句中可以不写break，不加break 也不会出现穿透的现象，如下例子：

extname := ".a"
switch extname {
	case ".html":
		fmt.Println("text/html")
	case ".css":
		fmt.Println("text/css")
	case ".js":
		fmt.Println("text/javascript")
	default:
		fmt.Println("格式错误")
}

一个分支可以有多个值，多个case 值中间使用英文逗号分隔。

n := 2
switch n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
}

另一种写法：

switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
}

注意：上面两种写法的作用域

分支还可以使用表达式，这时候switch 语句后面不需要再跟判断变量。例如：

age := 56
switch {
	case age < 25:
		fmt.Println("好好学习吧！")
	case age > 25 && age <= 60:
		fmt.Println("好好工作吧！")
	case age > 60:
		fmt.Println("好好享受吧！")
	default:
		fmt.Println("活着真好！")
}

switch 的穿透fallthrought。fallthrough语法可以执行满足条件的case 的下一个case，是为了兼容C 语言中的case 设计的。

func switchDemo5() {
	s := "a"
	switch {
		case s == "a":
			fmt.Println("a")
			fallthrough
		case s == "b":
			fmt.Println("b")
		case s == "c":
			fmt.Println("c")
		default:
			fmt.Println("...")
	}
}

// 输出：
// a
// b

var num int = 10
switch num {
	case 10:
		fmt.Println("ok1")
		fallthrough //默认只能穿透一层
	case 20:
		fmt.Println("ok2")
		fallthrough
	case 30:
		fmt.Println("ok3")
	default:
		fmt.Println("没有匹配到..")
}
// 输出：
// ok1
// ok2
// ok3

6.2.5、break(跳出循环)

Go 语言中break 语句用于以下几个方面：

（1）、用于循环语句中跳出循环，并开始执行循环之后的语句；

（2）、break 在switch（开关语句）中在执行一条case 后跳出语句的作用；

（3）、for 循环中默认break 只能跳出一层循环；在多重循环中，可以用标号label 标出想break 的循环。

package main
import "fmt"
func main() {
    lable2:
        for i := 0; i < 2; i++ {
            for j := 0; j < 10; j++ {
                if j == 2 {
                    break lable2
                }
                fmt.Println("i j 的值", i, "-", j)
            }
        }
}

6.2.6、continue(继续下次循环)

continue语句可以结束当前循环，开始下一次的循环迭代过程，仅限在for 循环内使用。

在continue 语句后添加标签时，表示开始标签对应的循环。例如：

package main
import "fmt"
func main() {
	here:
		for i := 0; i < 2; i++ {
			for j := 0; j < 4; j++ {
				if j == 2 {
					continue here
				}
				fmt.Println("i j 的值", i, "-", j)
			}
		}
}
// 输出：
// i j 的值0 - 0
// i j 的值0 - 1
// i j 的值1 - 0
// i j 的值1 - 1

6.2.7、goto(跳转到指定标签)

goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go 语言中使用goto 语句能简化一些代码的实现过程。

package main

import "fmt"
func main() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 标签
	breakTag:
		fmt.Println("结束for 循环")
}
// 输出：
// 0-0
// 0-1