Golang基础-2-CSDN博客

本文链接：https://blog.csdn.net/TimerSea/article/details/137073184

Go语言基础

介绍

基础

1. 关键字
2. 运算符
3. 运算符优先级

介绍

本文介绍Go语言中关键字、运算符、运算符优先级等相关知识。

基础

1. 关键字

关键字是语言约定的有特殊含义的词，又叫保留字。
Go语言约定的关键字有25个，去掉了一些不必要的关键字，和语言设计思想有关。

关键字	描述
break	用于跳出循环
default	用于选择结构的默认选项（switch、select）
func	用于函数定义
select	控制结构，类似于用于通信的 switch 语句
case	选择结构标签
chan	定义channel
interface	定义接口
const	定义常量
continue	跳过本次循环
defer	延迟执行函数
go	并发执行
map	map类型
struct	定义结构体
switch	选择结构
if	选择结构
else	选择结构
goto	跳转语句
package	包
fallthrough	case分支加上它，继续执行下一条分支语句
var	定义变量
return	返回
import	导入包
type	定义类型
range	遍历slice、map等结构元素
for	循环语句

2. 运算符

运算符是用于执行算术和逻辑操作的符号。
Go语言支持多种运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、指针运算符等。
算术运算符

运算符号	含义
+	相加
-	相减
*	相乘
/	相除
%	取余数
++	自增
–	自减

package main

import "fmt"

func main() {
	var a int = 10
	var b int = 20
	var c float32 = 10.123
	var d float32 = 20.123
	fmt.Println("a + b = ", a+b)
	fmt.Println("c + d = ", c+d)
	fmt.Println("a - b = ", a-b)
	fmt.Println("c - d = ", c-d)
	fmt.Println("a * b = ", a*b)
	fmt.Println("c * d = ", c*d)
	fmt.Println("a / b = ", a/b)
	fmt.Println("c / d = ", c/d)
	fmt.Println("a % b = ", a%b)
	// fmt.Println("c % d = ", c%d) // 浮点类型不能使用 %
	a++ // 必须写成单独语句
	fmt.Println("a++ = ", a)
	c++
	fmt.Println("c++ = ", c)
	// ++a  // 不支持前置 ++ 操作

	b--
	fmt.Println("b-- = ", b)
	d--
	fmt.Println("d-- = ", d)
}

输出结果
a + b = 30
c + d = 30.245998
a - b = -10
c - d = -9.999999
a * b = 200
c * d = 203.70512
a / b = 0
c / d = 0.5030562
a % b = 10
a++ = 11
c++ = 11.123
b-- = 19
d-- = 19.123

关系运算符

运算符号	含义
==	相等
!=	不相等
<	小于
<=	小于或等于
>	大于
>=	大于或等于

package main

import "fmt"

func main() {
	var a int = 10
	var b int = 20
	var e int = 10
	var g int8 = 20
	var c float32 = 10.123
	var d float32 = 20.123
	var f float32 = 20.123
	var h float64 = 20.123
	fmt.Println("a == b: ", a == b)
	fmt.Println("a == e: ", a == e)

	//不允许不同类型运算，需强制转换为相同数据类型
	// fmt.Println("b == g: ", b == g)
	fmt.Println("b == g: ", int8(b) == g)

	fmt.Println("c == d: ", c == d)
	fmt.Println("d == f: ", d == f)

	//不允许不同类型运算，需强制转换为相同数据类型
	// fmt.Println("f == h: ", f == h)
	fmt.Println("f == h: ", f == float32(h))

	fmt.Println("a != b: ", a != b)
	fmt.Println("c != d: ", c != d)

	fmt.Println("a < b: ", a < b)
	fmt.Println("c < d: ", c < d)

	fmt.Println("a <= e: ", a <= e)
	fmt.Println("d <= f: ", d <= f)

	fmt.Println("a > b: ", a > b)
	fmt.Println("c > d: ", c > d)

	fmt.Println("a >= e: ", a >= e)
	fmt.Println("d >= f: ", d >= f)
}

输出结果
a == b: false
a == e: true
b == g: true
c == d: false
d == f: true
f == h: true
a != b: true
c != d: true
a < b: true
c < d: true
a <= e: true
d <= f: true
a > b: false
c > d: false
a >= e: true
d >= f: true

逻辑运算符

运算符号	含义
&&	逻辑与（AND）
\|\|	逻辑或（OR）
!	逻辑非（NOT）

package main

import "fmt"

func main() {
	var a bool = true
	var b bool = false
	var c bool = true
	var d bool = false

	fmt.Println("a && b", a && b)
	fmt.Println("a && c", a && c)
	fmt.Println("a && d", a && d)
	fmt.Println("a && b && d", a && d)

	fmt.Println("a || b", a || b)
	fmt.Println("a || c", a || c)
	fmt.Println("b || d", b || d)
	fmt.Println("a || b || d", a && d)

	fmt.Println("!(a || b)", !(a || b))
	fmt.Println("!(a || c)", !(a || c))
	fmt.Println("!(b || d)", !(b || d))
	fmt.Println("!(a || b || d)", !(a || b || d))
}

输出结果
a && b false
a && c true
a && d false
a && b && d false
a || b true
a || c true
b || d false
a || b || d false
!(a || b) false
!(a || c) false
!(b || d) true
!(a || b || d) false

位运算符

运算符号	含义
&	按位与（AND）操作
\|	按位或（OR）操作
^	按位异或（XOR）操作
<<	按位左移操作
>>	按位右移操作

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var a int32 = 13 // 二进制赋值
	var b int32 = 18
	fmt.Println("int32 bit size: ", unsafe.Sizeof(a)*8)
	fmt.Printf("a: %#b\n", a)
	fmt.Printf("b: %#b\n", b)
	fmt.Printf("a&b: %#b\n", a&b)
	fmt.Printf("a|b: %#b\n", a|b)
	fmt.Printf("^a: %#b\n", ^a)
	fmt.Printf("^b: %#b\n", ^b)
	fmt.Printf("a<<2: %#b\n", a<<1)
	fmt.Printf("b<<2: %#b\n", b<<2)
	fmt.Printf("a>>2: %#b\n", a>>1)
	fmt.Printf("b>>2: %#b\n", b>>2)
}

输出结果
int32 bit size: 32
a: 0b1101
b: 0b10010
a&b: 0b0
a|b: 0b11111
^a: -0b1110
^b: -0b10011
a<<2: 0b11010
b<<2: 0b1001000
a>>2: 0b110
b>>2: 0b100

赋值运算符

运算符号	含义
=	右侧的值赋给左侧
+=	左侧的值与右侧的值相加，将和赋给左侧
-=	左侧的值与右侧的值相减，将差赋给左侧
*=	左侧的值与右侧的值相乘，将相乘结果赋给左侧
/=	左侧的值与右侧的值相除，将相除结果赋给左侧
%=	左侧的值与右侧的值相除取余数，将余数赋给左侧
<<=	左侧的值按位左移右侧指定的位数，将结果赋给左侧
>>=	左侧的值按位右移右侧指定的位数，将结果赋给左侧
&=	左侧的值与右侧的值按位与，将结果赋给左侧
\|=	左侧的值与右侧的值按位或，将结果赋给左侧
^=	左侧的值与右侧的值按位异或，将结果赋给左侧

package main

import (
	"fmt"
)

func main() {
	var a int32 = 13 // 二进制赋值
	var b int32 = 18
	var c int32 = a
	fmt.Println("c = a: ", c)
	c += b
	fmt.Println("c += b: ", c)
	c -= b
	fmt.Println("c -= b: ", c)
	c *= b
	fmt.Println("c *= b: ", c)
	c /= b
	fmt.Println("c /= b: ", c)
	c %= a
	fmt.Println("c %= a: ", c)
	c <<= 3
	fmt.Println("c <<= 3: ", c)
	c >>= 3
	fmt.Println("c >>= 3: ", c)
	c &= a
	fmt.Printf("c &= a: %#b\n", c)
	c |= b
	fmt.Printf("c |= b: %#b\n", c)
	c ^= a
	fmt.Println("c ^= a: ", c)
}

输出结果
c = a: 13
c += b: 31
c -= b: 13
c *= b: 234
c /= b: 13
c %= a: 0
c <<= 3: 0
c >>= 3: 0
c &= a: 0b0
c |= b: 0b10010
c ^= a: 31

指针运算符

运算符号	含义
&	获取某个变量在内存中的实际地址
*	声明一个指针变量

package main

import "fmt"

func main() {
	var a int = 16
	var ptr *int = &a

	fmt.Println("a: ", a)
	fmt.Println("ptr: ", *ptr)
	*ptr = 10
	fmt.Println("ptr: ", *ptr)

	// 指针不支持 ++ -- 操作
	// ptr++
}

输出结果
a: 16
ptr: 16
ptr: 10

3. 运算符优先级

不同的运算符具有不同的优先级和结合性。

分类	描述	关联性
后缀	() [] -> . ++ –	左到右
一元	+ - ! ~ ++ – (type)* & sizeof	右到左
乘法	* / %	左到右
加法	+ -	左到右
移位	<< >>	左到右
关系	<<= >>=	左到右
相等	== !=	左到右
按位与	&	左到右
按位异或	^	左到右
按位或	\|	左到右
逻辑与	&&	左到右
逻辑或	\|\|	左到右
赋值	= += -= *= /= %=>>= <<= &= ^=	=
逗号	,	左到右

起始