Go语言学习笔记二

Go语言运算符

运算符用于在程序运行时执行数学或者逻辑运算

Go语言内置的运算符有：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其他运算符

算术运算符

运算符	描述
+	相加
-	相减
*	相乘
/	相除
%	求余
++	自增
–	自减

package main

import "fmt"

func main() {
	var a int = 20
	var b int = 10
	fmt.Println("a + b =", a+b)
	fmt.Println("a - b =", a-b)
	fmt.Println("a * b =", a*b)
	fmt.Println("a / b =", a/b)
	fmt.Println("a % b =", a%b)
	a++
	b--
	fmt.Printf("a = %d, b = %d", a, b)
}

关系运算符

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

package main

import "fmt"

func main() {
	var a int = 20
	var b int = 10
	if a == b {
		fmt.Println("a=b")
	} else {
		fmt.Println("a!=b")
	}
	if a < b {
		fmt.Println("a<b")
	} else {
		fmt.Println("a>b")
	}
	if a > b {
		fmt.Println("a>b")
	} else {
		fmt.Println("a<b")
	}
	if a <= b {
		fmt.Println("a<=b")
	}
	if a >= b {
		fmt.Println("a>=b")
	}
}

逻辑运算符

运算符	描述
&&	逻辑and运算符，如果两边的操作数都是true，则条件为true，否则为false
||	逻辑or运算符，如果两边的操作数有一个true，则条件为true，否则是false
!	逻辑not运算符，如果条件为true，则逻辑not条件false，否则是true

package main

import "fmt"

func main() {
	var a bool = true
	var b bool = false
	if a && b {
		fmt.Println("a=b")
	}
	if a || b {
		fmt.Println("a!=b")
	}
	if a && !b {
		fmt.Println("true")
	}
}

位运算符

运算符	描述
&	按位与运算符”&”是双目运算符。参与运算的两数各对应的二进位相与。
|	按位或运算符”|”双目运算符。参与运算的两数各对应的二进位相或
^	按位异或运算符”^”双目运算符。参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1
<<	左移运算符”<<”双目运算符，左移N位就是乘以2的N次方。功能是把”<<”左边的运算数的各二进位全部左移若干位，由”<<”右边的数指定移动的位数，高位丢弃，低位补0
>>	右移运算符”>>”双目运算符，右移N位就是除以2的N次方。功能是把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数。

package main

import "fmt"

func main() {
	var a uint = 60
	var b uint = 13
	fmt.Println(a & b)
	fmt.Println(a | b)
	fmt.Println(a ^ b)
	fmt.Println(a << 2)
	fmt.Println(a >> 2)
}

赋值运算符

运算符	描述
=	简单的赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值
<<=	左移后赋值
>>=	右移后赋值
&=	按位与后赋值
^=	按位异或后赋值
|=	按位或后赋值

package main

import "fmt"

func main() {
	var a int = 21
	var c int
	c = a
	fmt.Println(c)
	c += a
	fmt.Println(c)
	c -= a
	fmt.Println(c)
	c *= a
	fmt.Println(c)
	c /= a
	fmt.Println(c)
	c = 20
	c <<= 2
	fmt.Println(c)
	c >>= 1
	fmt.Println(c)
	c &= 5
	fmt.Println(c)
	c ^= 10
	fmt.Println(c)
	c |= 2
	fmt.Println(c)
}

其他运算符

运算符	描述
&	返回变量的存储地址
*	指针变量

package main

import "fmt"

func main() {
	var a int = 4
	var ptr *int
	ptr = &a
	fmt.Printf("a 的值为  %d\n", a)
	fmt.Printf("*ptr 为 %d\n", *ptr)
	fmt.Printf("%p\n", &a)
	fmt.Printf("%p\n", ptr)
}

运算符优先级

优先级，就是当多个运算符出现在同一个表达式之中时，先执行哪个运算符。运算符优先级如下表：

优先级	分类	运算符	结合性
1	逗号运算符	,	从左到右
2	赋值运算符	=、+=、-=、*=、/=、%=、>>=、<<=、&=、^=、|=	从友到左
3	逻辑或	||	从左到右
4	逻辑与	&&	从左到右
5	按位或	|	从左到右
6	按位异或	^	从左到右
7	按位与	&	从左到右
8	相等/不等	==、!=	从左到右
9	关系运算符	<、<=、>、>=	从左到右
10	位移运算符	<<、>>	从左到右
11	加法/减法	+、-	从左到右
12	乘法/除法/除余	*、/、%	从左到右
13	单目运算符	!、*（指针）、&、++、–、+（正号）、-（负号）	从右到左
14	后缀运算符	()、[]、->	从左到右

优先级值越大，表示优先级越高

Go语言条件语句

if…else语句的语法如下：

if 布尔表达式{
	/*在布尔表达式为true时执行*/
}else{
	/*在布尔表达式为false时执行*/
}

package main

import "fmt"

func main() {
	var a int
	var b int = 10
	fmt.Println("输入a")
	fmt.Scanf("%d", &a)
	if a < b {
		fmt.Println("a<10")
	}
	if a > b {
		fmt.Println("a>10")
	}
	if a == b {
		fmt.Println("a==10")
	}
}

switch语句用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上到下逐一测试，直到匹配为止。

switch语句执行的过程从上到下，直到匹配项，在匹配项后面也不需要加break。

switch默认情况下case最后自带break语句，匹配成功后就不会执行其他case，如果需要执行后面的case，可以使用fallthrough

package main

import "fmt"

func main() {
	var num int
	fmt.Scanf("%d", &num)
	switch {
	case num < 60:
		fmt.Println("F")
	case num < 70:
		fmt.Println("D")
	case num < 80:
		fmt.Println("C")
	case num < 90:
		fmt.Println("B")
	default:
		fmt.Println("A")
	}

}

Go语言循环语句

for循环是循环控制结构，可以执行指定次数的循环。

Go的For循环有三种方式，只有其中的一种使用分号。

和C的for一样：

for inir; condition; post {}

和C的while一样：

for condition{}

和C的for(;;)一样：

for {}

• init：一般为赋值表达式，给控制变量赋初值
• condition：关系表达式或逻辑表达式，循环控制条件
• post：一般为赋值表达式，给控制变量增量或减量

计算1加到100的和

package main

import "fmt"

func main() {
	var sum int = 0
	for i := 0; i <= 100; i++ {
		sum += i
	}
	fmt.Print(sum)
}

无限的循环，相当于while（1）

package main

import "fmt"

func main() {
	sum := 0
	for {
		sum++
		fmt.Println(sum)
	}
}

使用break跳出循环，以下示例演示了使用标记和不使用的区别：

package main

import "fmt"

func main() {
re:
	for i := 1; i < 4; i++ {
		fmt.Println(i)
		for j := 10; j < 13; j++ {
			fmt.Println(j)
			break re
		}
	}
}

package main

import "fmt"

func main() {

	for i := 1; i < 4; i++ {
		fmt.Println(i)
		for j := 10; j < 13; j++ {
			fmt.Println(j)
			break
		}
	}
}

continue语句

package main

import "fmt"

func main() {

	for i := 1; i < 8; i++ {
		if i == 5 {
			continue
		}
		fmt.Println(i)
	}
}

使用了标记和不使用标记的

package main

import "fmt"

func main() {
	fmt.Println("使用标记")
re:
	for i := 1; i < 5; i++ {
		fmt.Println(i)
		for j := 10; j < 13; j++ {
			fmt.Println(j)
			continue re
		}
	}
	fmt.Println("不使用标记")
	for i := 1; i < 5; i++ {
		fmt.Println(i)
		for j := 10; j < 13; j++ {
			fmt.Println(j)
			continue
		}
	}
}

Go函数

函数定义

go的函数定义格式如下：

func func_name ([parameter list]) [return types]{
	函数体
}

• func：函数由func开始声明
• func_name：函数名称，参数列表和返回值类型构成了函数签名
• parameter list：参数列表，参数就像一个占位符，当函数被调用的时候，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的。
• return types：返回类型，函数返回一列值。return types是该列值得数据类型。有些功能不需要返回值，这种情况下，不是必须的。

package main

import "fmt"

func add(num1, num2 int) int {
	return num1 + num2
}

func main() {
	var ret int
	ret = add(15, 30)
	fmt.Print(ret)
}

Go变量作用域

作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。

Go中的变量可以在三个地方声明：

• 函数内定义的变量称为局部变量
• 函数外定义的变量称为全局变量
• 函数定义的变量称为形式参数

package main

import "fmt"

//全局变量
var c int = 1

func main() {
	//局部变量
	var a, b int
	a = 1
	b = 2
	fmt.Println(a, b, c)
	d := add(a, b)
	fmt.Println(d)
}
func add(a, b int) int {
	return a + b
}