Go语言运算符全解析：算术、位运算与优先级

拾光

发布时间：2026-10-16| 2人浏览过

原创

掌握Go语言的运算符是编写健壮程序的基础。本文系统梳理了算数、关系、逻辑、位运算、赋值及其他（如指针）运算符的语法特性。通过实际代码演示字符串拼接、位操作计算及地址引用，并阐明由上至下的优先级规则与括号使用场景。

什么是Go语言的运算符

在Go语言中，运算符用于对变量和值执行数学或逻辑操作。根据其功能分类，主要包含：

算术运算符：进行加减乘除及取模运算。
关系运算符：比较两个值的相等性或大小关系。
逻辑运算符：组合布尔条件。
位运算符：处理整数在内存中的二进制位。
赋值运算符：为变量赋予新值。
其他运算符：主要用于指针操作。

第1步：使用算术运算符

算术运算符支持基本的数学计算。Go语言要求参与运算的数据类型必须一致。

除了数字类型，+ 号还可以用于 字符串拼接。此外，自增（++）和自减（--）作为语句存在，不作为表达式返回值。

以下为完整演示代码：

package main

import "fmt"

func main() {
	var a int = 21
	var b int = 10
	var c int

	c = a + b
	fmt.Printf("第一行 - c 的值为 %d\n", c)
	c = a - b
	fmt.Printf("第二行 - c 的值为 %d\n", c)
	c = a * b
	fmt.Printf("第三行 - c 的值为 %d\n", c)
	c = a / b
	fmt.Printf("第四行 - c 的值为 %d\n", c)
	c = a % b
	fmt.Printf("第五行 - c 的值为 %d\n", c)

	// a++ 等效于 a=a+1  等效于 a+=1
	a++
	fmt.Printf("第六行 - a 的值为 %d\n", a)
	a = 21 // 为了方便测试，a 这里重新赋值为 21
	// a-- 等效于 a=a-1  等效于a-=1
	a--
	fmt.Printf("第七行 - a 的值为 %d\n", a)
}

//输出结果：
第一行 - c 的值为 31
第二行 - c 的值为 11
第三行 - c 的值为 210
第四行 - c 的值为 2
第五行 - c 的值为 1
第六行 - a 的值为 22
第七行 - a 的值为 20

字符串拼接示例：

package main

import "fmt"

func main() {
	a := "hello"
	b := "world"
	c := a + b
	fmt.Println(c)
}

//输出结果:
helloworld

第2步：使用关系运算符

关系运算符用于判断两个数值之间的关系，返回布尔值 true 或 false。

运算符	描述	实例 (假设 A=10, B=20)
==	检查两边值是否相等	(A == B) 为 False
!=	检查两边值是否不相等	(A != B) 为 True
>	检查左边值是否大于右边值	(A > B) 为 False
<	检查左边值是否小于右边值	(A < B) 为 True
>=	检查左边值是否大于等于右边值	(A >= B) 为 False
<=	检查左边值是否小于等于右边值	(A <= B) 为 True

代码演示：

package main

import "fmt"

func main() {
	var a int = 21
	var b int = 10

	if( a == b ) {
		fmt.Printf("第一行 - a 等于 b\n" )
	} else {
		fmt.Printf("第一行 - a 不等于 b\n" )
	}
	if ( a < b ) {
		fmt.Printf("第二行 - a 小于 b\n" )
	} else {
		fmt.Printf("第二行 - a 不小于 b\n" )
	}

	if ( a > b ) {
		fmt.Printf("第三行 - a 大于 b\n" )
	} else {
		fmt.Printf("第三行 - a 不大于 b\n" )
	}

	/* Lets change value of a and b */
	a = 5
	b = 20
	if ( a <= b ) {
		fmt.Printf("第四行 - a 小于等于 b\n" )
	}
	if ( b >= a ) {
		fmt.Printf("第五行 - b 大于等于 a\n" )
	}
}

//输出结果
第一行 - a 不等于 b
第二行 - a 不小于 b
第三行 - a 大于 b
第四行 - a 小于等于 b
第五行 - b 大于等于 a

第3步：构建逻辑运算符

逻辑运算符连接多个布尔条件。前提是参与运算的操作数均为布尔类型。

运算符	描述	实例
&&	逻辑 AND（且）。两边都为 true 时结果为 true。	(A && B) 为 False
\|\|	逻辑 OR（或）。有一边为 true 时结果为 true。	(A \|\| B) 为 True
!	逻辑 NOT（非）。反转操作数的状态。	!(A && B) 为 True

代码演示：

package main

import "fmt"

func main() {
	var a bool = true
	var b bool = false
	if ( a && b ) {
		fmt.Printf("第一行 - 条件为 true\n" )
	}
	if ( a || b ) {
		fmt.Printf("第二行 - 条件为 true\n" )
	}
	/* 修改 a 和 b 的值 */
	a = false
	b = true
	if ( a && b ) {
		fmt.Printf("第三行 - 条件为 true\n" )
	} else {
		fmt.Printf("第三行 - 条件为 false\n" )
	}
	if ( !(a && b) ) {
		fmt.Printf("第四行 - 条件为 true\n" )
	}
}

//输出结果:
第二行 - 条件为 true
第三行 - 条件为 false
第四行 - 条件为 true

第4步：掌握位运算符

位运算符直接对存储在内存中的整数的二进制位进行操作。对于无符号整数 uint，右移时高位补 0。

关键规则：

AND (&)：两位均为 1 则结果为 1。
OR (|)：只要有一位为 1 则结果为 1。
XOR (^)：两位相异则结果为 1。
左移 (<<)：左边的数各二进位全部左移若干位，相当于乘以 2 的 n 次方。
右移 (>>)：右边的数各二进位全部右移若干位，相当于除以 2 的 n 次方。

假设 A = 60 (0011 1100)，B = 13 (0000 1101)。演示代码如下：

package main

import "fmt"

func main() {

	var a uint = 60 /* 60 = 0011 1100 */
	var b uint = 13 /* 13 = 0000 1101 */
	var c uint = 0

	c = a & b /* 12 = 0000 1100 */
	fmt.Printf("第一行 - c 的值为 %d\n", c)

	c = a | b /* 61 = 0011 1101 */
	fmt.Printf("第二行 - c 的值为 %d\n", c)

	c = a ^ b /* 49 = 0011 0001 */
	fmt.Printf("第三行 - c 的值为 %d\n", c)

	c = a << 2 /* 240 = 1111 0000 */
	fmt.Printf("第四行 - c 的值为 %d\n", c)

	c = a >> 2 /* 15 = 0000 1111 */
	fmt.Printf("第五行 - c 的值为 %d\n", c)
}

//输出结果为：
第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15

第5步：应用赋值与复合赋值运算符

基础的赋值运算符为 =，它会将右侧表达式的值赋给左侧变量。

Go还提供了复合赋值运算符，例如 += 等同于 a = a + b。此类运算符能简化代码书写，同时涵盖移位和位运算的赋值。

详细演示：

package main

import "fmt"

func main() {
	var a int = 21
	var c int

	c = a
	fmt.Printf("第 1 行 - =  运算符实例，c 值为 = %d\n", c)

	c += a
	fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c)

	c -= a
	fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c)

	c *= a
	fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c)

	c /= a
	fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c)

	c = 200

	c <<= 2
	fmt.Printf("第 6行  - <<= 运算符实例，c 值为 = %d\n", c)

	c >>= 2
	fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c)

	c &= 2
	fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c)

	c ^= 2
	fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c)

	c |= 2
	fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c)

}

//输出结果:
第 1 行 - =  运算符实例，c 值为 = 21
第 2 行 - += 运算符实例，c 值为 = 42
第 3 行 - -= 运算符实例，c 值为 = 21
第 4 行 - *= 运算符实例，c 值为 = 441
第 5 行 - /= 运算符实例，c 值为 = 21
第 6行  - <<= 运算符实例，c 值为 = 800
第 7 行 - >>= 运算符实例，c 值为 = 200
第 8 行 - &= 运算符实例，c 值为 = 0
第 9 行 - ^= 运算符实例，c 值为 = 2
第 10 行 - |= 运算符实例，c 值为 = 2

第6步：理解指针与其他特殊运算符

除了上述基本运算外，&（取地址符）和 *（指针解引用符）也是 Go 语言的重要组成部分。

&a：返回变量 a 在内存中的实际地址。
*ptr：访问指针 ptr 所指向的内存地址存储的值。

使用场景示例：

package main

import "fmt"

func main() {
	var a int = 4
	var b int32
	var c float32
	var ptr *int

	/* 运算符实例 */
	fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a)
	fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b)
	fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c)

	/*  & 和 * 运算符实例 */
	ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */
	fmt.Printf("a 的值为  %d\n", a)
	fmt.Printf("*ptr 为 %d\n", *ptr)
}

//输出结果:
第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
*ptr 为 4

正确设置运算符优先级

当表达式中包含多种运算符时，编译器按照预定义的优先级顺序执行。二元运算符的求值方向均是从左至右。

优先级由高到低排列如下：

优先级 5：* / % << >> & &^
优先级 4：+ - | ^
优先级 3：== != < <= > >=
优先级 2：&&
优先级 1：||

若需要改变默认的计算顺序，可以使用括号 ()。括号内的表达式将首先被计算。如下例所示：

package main

import "fmt"

func main() {
	var a int = 20
	var b int = 10
	var c int = 15
	var d int = 5
	var e int

	e = (a + b) * c / d // ( 30 * 15 ) / 5
	fmt.Printf("(a + b) * c / d 的值为 : %d\n", e)

	e = ((a + b) * c) / d // (30 * 15 ) / 5
	fmt.Printf("((a + b) * c) / d 的值为  : %d\n", e)

	e = (a + b) * (c / d) // (30) * (15/5)
	fmt.Printf("(a + b) * (c / d) 的值为  : %d\n", e)

	e = a + (b*c)/d //  20 + (150/5)
	fmt.Printf("a + (b * c) / d 的值为  : %d\n", e)
}

//输出结果:
(a + b) * c / d 的值为 : 90
((a + b) * c) / d 的值为  : 90
(a + b) * (c / d) 的值为  : 90
a + (b * c) / d 的值为  : 50

以上就是Go语言运算符的详细内容，更多关于Go语言开发进阶的资料请关注本站其它相关文章！