Go 语言运算符与控制台输入输出详解

文章目录

• [Go 语言运算符与控制台输入输出详解](#Go 语言运算符与控制台输入输出详解)
• • 一、前置准备
  • [二、Go 语言运算符大全（按指定顺序）](#二、Go 语言运算符大全（按指定顺序）)
  • • [1. 算术运算符（做数学计算）](#1. 算术运算符（做数学计算）)
    • [2. 关系运算符（判断大小、相等，又称比较运算符）](#2. 关系运算符（判断大小、相等，又称比较运算符）)
    • [3. 逻辑运算符（多条件判断）](#3. 逻辑运算符（多条件判断）)
    • [4. 位运算符（操作二进制位，进阶常用）](#4. 位运算符（操作二进制位，进阶常用）)
    • [5. 赋值运算符（简化赋值操作）](#5. 赋值运算符（简化赋值操作）)
    • [6. 其他运算符（常用补充）](#6. 其他运算符（常用补充）)
  • 三、控制台输出（打印内容）
  • • [1. `fmt\.Println\(\)`](#1. fmt\.Println\(\))
    • [2. `fmt\.Printf\(\)`](#2. fmt\.Printf\(\))
  • 四、控制台输入（获取用户输入）
  • • [1. 基本输入：`fmt\.Scan\(\&变量\)`](#1. 基本输入：fmt\.Scan\(\&变量\))
    • [2. 同时输入多个值](#2. 同时输入多个值)
  • [五、综合小案例（输入 \+ 运算 \+ 输出）](#五、综合小案例（输入 + 运算 + 输出）)
  • 六、新手常见错误
  • 七、本篇总结

Go 语言运算符与控制台输入输出详解

大家好～上一篇博客我们详细学习了 Go 语言的变量、常量与数据类型，掌握了存储数据的基本方式。本篇我们继续进阶，学习两个超实用的核心知识点：

1. Go 语言运算符（算术、关系、逻辑、位、赋值及其他运算符）

2. 控制台输入输出（程序与用户交互的基础）

每个知识点都搭配可直接运行的代码示例，零基础也能轻松学会，学完就能写出能交互、能计算的 Go 程序！

---

一、前置准备

继续使用之前的 GoStudy 项目，新建文件夹 operator，创建 main\.go 文件，所有代码都在此文件中测试运行。

基础结构：

package main

import "fmt"

func main() {
    // 测试代码写在这里
}

---

二、Go 语言运算符大全（按指定顺序）

运算符就是用来做运算、比较、逻辑判断、位操作等的符号，按功能分类如下，每个类别均搭配示例代码，新手可直接复制运行。

1. 算术运算符（做数学计算）

用于数字的加减乘除、取余等运算，仅适用于整型、浮点型等数值类型。

运算符	说明
\+	加法
\-	减法
\*	乘法
/	除法（整数除法取整，浮点除法取小数）
%	取余（模运算，仅适用于整型）

示例代码：

package main

import "fmt"

func main() {
	a := 10
	b := 3
	c := 10.5
	d := 2.5

	// 整型运算
	fmt.Println("加法：", a+b)    // 13
	fmt.Println("减法：", a-b)    // 7
	fmt.Println("乘法：", a*b)    // 30
	fmt.Println("整数除法：", a/b)    // 3（取整，不四舍五入）
	fmt.Println("取余：", a%b)    // 1

	// 浮点型运算
	fmt.Println("浮点加法：", c+d) // 13.0
	fmt.Println("浮点除法：", c/d) // 4.2（保留小数）
}

---

2. 关系运算符（判断大小、相等，又称比较运算符）

用于判断两个值的关系，结果一定是**布尔值 **true / false，常用于条件判断（后续if、for循环会高频使用）。

运算符	说明
==	等于（判断两个值是否相等）
\!=	不等于（判断两个值是否不相等）
\>	大于
\<	小于
\>=	大于等于
\<=	小于等于

示例代码：

package main

import "fmt"

func main() {
	x := 5
	y := 8
	z := 5.0

	// 整型与整型比较
	fmt.Println(x == y)   // false（5不等于8）
	fmt.Println(x != y)   // true（5不等于8）
	fmt.Println(x > y)    // false（5不大于8）
	fmt.Println(x < y)    // true（5小于8）
	fmt.Println(x >= y)   // false（5不大于等于8）
	fmt.Println(x <= y)   // true（5小于等于8）

	// 注意：不同类型不能直接比较（需手动转换）
	// fmt.Println(x == z) // 编译报错：int与float64不能直接比较
}

---

3. 逻辑运算符（多条件判断）

用于组合多个关系表达式（条件），判断多条件的真假，结果也是布尔值，核心用于复杂条件判断。

运算符	说明
\&	逻辑与（所有条件都为真，结果才为真；有一个为假，结果为假）
`
\!	逻辑非（取反，真变假，假变真）

示例代码：

package main

import "fmt"

func main() {
	age := 20
	isStudent := true
	score := 85

	// 逻辑与：年龄大于18 并且 是学生
	fmt.Println(age > 18 && isStudent) // true

	// 逻辑或：年龄大于30 或者 分数大于80
	fmt.Println(age > 30 || score > 80) // true（分数大于80为真）

	// 逻辑非：不是学生（取反isStudent的值）
	fmt.Println(!isStudent) // false

	// 复杂组合：年龄大于18 并且 （是学生 或者 分数大于80）
	fmt.Println(age > 18 && (isStudent || score > 80)) // true
}

---

4. 位运算符（操作二进制位，进阶常用）

位运算符直接操作变量的二进制位（0和1），常用于底层开发、权限控制等场景，零基础先掌握基础用法，后续进阶再深入。

运算符	说明	示例（a=10(1010)，b=3(0011)）
	按位与（对应位都为1，结果为1，否则为0）	a&b = 2(0010)
`	`	按位或（对应位有一个为1，结果为1）
^	按位异或（对应位不同为1，相同为0）	a^b = 9(1001)
\<\<	左移（二进制位向左移动n位，右边补0，等价于乘2^n）	a<<1 = 20(10100)
\>\>	右移（二进制位向右移动n位，左边补0，等价于除2^n取整）	a>>1 = 5(101)

示例代码：

package main

import "fmt"

func main() {
	a := 10 // 二进制：1010
	b := 3  // 二进制：0011

	fmt.Println("按位与 a&b：", a&b)   // 2（0010）
	fmt.Println("按位或 a|b：", a|b)    // 11（1011）
	fmt.Println("按位异或 a^b：", a^b)  // 9（1001）
	fmt.Println("左移 a<<1：", a<<1)   // 20（10100）
	fmt.Println("右移 a>>1：", a>>1)   // 5（101）
}

---

5. 赋值运算符（简化赋值操作）

用于给变量赋值，或结合算术、位运算符简化赋值操作，开发中高频使用，能减少代码冗余。

运算符	说明	等价写法
=	基本赋值（将右边的值赋给左边）	num = 10
\+=	加等于（左边 += 右边，等价于左边 = 左边 + 右边）	num += 5 → num = num + 5
\-=	减等于	num -= 5 → num = num - 5
\*=	乘等于	num *= 2 → num = num * 2
/=	除等于	num /= 2 → num = num / 2
%=	取余等于	num %= 3 → num = num % 3
\&=	按位与赋值	a &= b → a = a & b
`	=`	按位或赋值

示例代码：

package main

import "fmt"

func main() {
	num := 10

	num += 5  // 等价于 num = num + 5
	fmt.Println("加等于后：", num) // 15

	num *= 2  // 等价于 num = num * 2
	fmt.Println("乘等于后：", num) // 30

	num %= 4  // 等价于 num = num % 4
	fmt.Println("取余等于后：", num) // 2

	// 位运算赋值
	a := 10
	b := 3
	a &= b // 等价于 a = a & b
	fmt.Println("按位与赋值后：", a) // 2
}

---

6. 其他运算符（常用补充）

除上述5类运算符外，Go 语言还有2个常用的其他运算符，均为零基础高频使用，重点掌握。

运算符	说明	示例
&	取地址符（获取变量的内存地址）	&num（获取num的地址）
\*	指针运算符（通过地址获取变量的值）	*&num（通过地址获取num的值）

示例代码：

package main

import "fmt"

func main() {
	num := 100

	// 取地址符 &：获取num的内存地址（格式：0x开头）
	fmt.Println("num的地址：", &num)

	// 指针运算符 *：通过地址获取变量的值
	fmt.Println("通过地址获取num的值：", *&num) // 等价于num的值

	// 补充：后续控制台输入fmt.Scan(&num)，就是用&获取变量地址，才能修改变量值
}

小贴士：取地址符 & 是后续控制台输入、指针学习的基础，重点记住：fmt\.Scan\(\&变量\) 中必须加 &，否则无法修改变量的值。

---

三、控制台输出（打印内容）

Go 语言使用 fmt 包实现打印，最常用 2 个函数，结合运算符使用，能实现更灵活的输出效果。

1. fmt\.Println\(\)

自动换行，最常用，可直接打印变量、常量或表达式结果。

package main

import "fmt"

func main() {
	a := 10
	b := 3
	fmt.Println("Hello Go")          // 打印字符串
	fmt.Println(a + b)               // 打印算术运算结果
	fmt.Println(a > b)               // 打印关系运算结果
	fmt.Println(a > 5 && b < 5)     // 打印逻辑运算结果
}

2. fmt\.Printf\(\)

格式化输出（可控制格式、类型），搭配占位符使用，适合精准输出（如保留小数、指定类型）。

常用占位符（结合运算符场景补充）：

• %d：整型（打印算术运算、位运算的整型结果）

• %f：浮点型（打印浮点运算结果，可指定保留小数）

• %s：字符串

• %t：布尔型（打印关系、逻辑运算结果）

• %T：查看变量/运算结果的类型

• %c：打印字符（结合之前学的字符字面量）

• %p：打印内存地址（结合取地址符 &）

示例：

package main

import "fmt"

func main() {
	name := "小明"
	age := 18
	score := 95.5
	isPass := age > 16 && score > 60
	num := 10

	fmt.Printf("姓名：%s，年龄：%d\n", name, age)
	fmt.Printf("分数：%.1f（保留1位小数）\n", score)
	fmt.Printf("是否合格：%t\n", isPass)
	fmt.Printf("num的类型：%T，num的地址：%p\n", num, &num)
	fmt.Printf("5+3的结果：%d，类型：%T\n", 5+3, 5+3)
}

---

四、控制台输入（获取用户输入）

让程序接收用户从键盘输入的数据 ，是交互程序的基础，结合运算符，可实现"输入→运算→输出"的完整流程。Go 使用 fmt\.Scan\(\) 实现输入，核心依赖取地址符 \&。

1. 基本输入：fmt\.Scan\(\&变量\)

**必须加 **\&符号！（取变量地址，才能将输入的值赋值给变量）

示例代码：

package main

import "fmt"

func main() {
	var age int
	fmt.Print("请输入你的年龄：")
	fmt.Scan(&age) // 获取输入，必须加&
	fmt.Printf("你输入的年龄是：%d，年龄+5的结果是：%d\n", age, age+5)
}

2. 同时输入多个值

多个变量输入时，用空格或回车分隔，无需额外写多个 fmt.Scan()。

package main

import "fmt"

func main() {
	var name string
	var score int
	var height float64

	fmt.Print("请输入姓名、分数、身高（空格分隔）：")
	fmt.Scan(&name, &score, &height) // 同时获取多个输入

	// 结合运算符运算并输出
	fmt.Printf("姓名：%s\n", name)
	fmt.Printf("分数：%d，加分后：%d\n", score, score+10)
	fmt.Printf("身高：%.2f，身高的一半：%.2f\n", height, height/2)
}

---

五、综合小案例（输入 + 运算 + 输出）

结合本篇所有知识点，实现一个"用户输入两个数字，计算并输出所有算术运算结果"的交互程序。

package main

import "fmt"

func main() {
	var num1, num2 int

	fmt.Print("请输入第一个数字：")
	fmt.Scan(&num1)

	fmt.Print("请输入第二个数字：")
	fmt.Scan(&num2)

	// 结合算术运算符、输出函数，实现完整交互
	fmt.Println("------------------- 运算结果 -------------------")
	fmt.Printf("加法：%d + %d = %d\n", num1, num2, num1+num2)
	fmt.Printf("减法：%d - %d = %d\n", num1, num2, num1-num2)
	fmt.Printf("乘法：%d * %d = %d\n", num1, num2, num1*num2)
	fmt.Printf("除法：%d / %d = %d（整数取整）\n", num1, num2, num1/num2)
	fmt.Printf("取余：%d %% %d = %d\n", num1, num2, num1%num2)
	fmt.Printf("左移：%d << 1 = %d\n", num1, num1<<1)
	fmt.Printf("是否相等：%d == %d → %t\n", num1, num2, num1==num2)
}

运行效果：

请输入第一个数字：10
请输入第二个数字：3
------------------- 运算结果 -------------------
加法：10 + 3 = 13
减法：10 - 3 = 7
乘法：10 * 3 = 30
除法：10 / 3 = 3（整数取整）
取余：10 % 3 = 1
左移：10 << 1 = 20
是否相等：10 == 3 → false

---

六、新手常见错误

1. **输入不加 **& → fmt\.Scan\(age\) 报错，必须写 \&age（取地址才能赋值）

2. 整数除法误区 → 5/2 = 2 不是 2.5，想得到小数，需将变量定义为浮点型（如 var a float64 = 5）

3. **比较用 **= → 比较相等必须用 ==，= 是赋值（如 x == y 是判断，x = y 是赋值）

4. 输入类型不匹配 → 输入数字却存到字符串变量会报错（如 var name string，输入 123 会报错）

5. 位运算符使用错误 → 位运算符仅适用于整型，不能用于浮点型（如 10\.5 \<\< 1 会报错）

---

七、本篇总结

1. 算术运算符 ：\+ \- \* / %（做数学计算，适用于数值类型）

2. 关系运算符 ：== \!= \> \< \>= \<=（判断关系，结果为布尔值）

3. 逻辑运算符 ：\&\& \|\| \!（组合多条件，结果为布尔值）

4. 位运算符 ：\& \| ^ \<\< \>\>（操作二进制位，适用于整型）

5. 赋值运算符 ：= \+= \-= \*= /= %=等（简化赋值操作）

6. 其他运算符 ：&（取地址）、\*（指针运算符）

7. 输出 ：fmt\.Println\(\)（自动换行）、fmt\.Printf\(\)（格式化输出，需搭配占位符）

8. 输入 ：fmt\.Scan\(\&变量\)（必须加 &，获取用户输入）

本篇内容是后续学习 if 条件、for 循环 的核心基础，建议把所有示例代码手动敲一遍，重点掌握"输入→运算→输出"的流程，熟练使用各类运算符～

（注：文档部分内容可能由 AI 生成）