Go语言的转译字符（escape char）
package main
import "fmt"
func main() {
//演示转义字符的使用 \t
fmt.Println("Hello:\tWorld!")
fmt.Println("Hello\nWorld!")
fmt.Println("C:\\Go\\bin")
fmt.Println("tom say\"i love you\"")
fmt.Println("疯狂星期四\r请v我50")
}
运行结果如下
#go run .\main.go
Hello: World!
Hello
World!
C:\Go\bin
tom say"i love you"
请v我50期四课堂练习
要求：请使用一句输出语句，达到输入以下效果
package main
import "fmt"
func main() {
fmt.Println("姓名\t年龄\t籍贯\t住址\n阿昆\t34\t北京\t没座")
}
编译命令
go build .\practice01.go
生成一个二进制的可执行文件practice01.exe
可直接运行可执行文件 .\practice01.exe
#如下PS L:\goproject\src\go_code\chapter02\escape char\practice01> ls
Directory: L:\goproject\src\go_code\chapter02\escape char\practice01
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a--- 2025/6/10 23:23 2303488 practice01.exe
-a--- 2025/6/10 23:19 424 practice01.go
PS L:\goproject\src\go_code\chapter02\escape char\practice01> .\practice01.exe
* *
* * I Love Golang * *
* *
* *
* *
* *
* *
* *
*Golang程序编写的规则
go文件的后缀.go
go程序区分大小写
go的语句后，不需要带分号
go定义的变量，或者import包，必须使用，如果没有使用就会报错
go中，不要把多条语句放在同一行。否则报错
go中的大括号成对出现，而且风格
占位符
常用
详细参考fmt库的内容
变量(var)
变量的定义
Go语言是静态累消类型的语言，就是所有的类型我们都需要明确的去定义。
在Go语言中，我们声明一个变量一般是使用var关键字：
var name type第一个 var 是声明变量的关键字，是固定的写法，你要声明一个变量，就需要一个 var。
第二个 name ，就是我们的变量名字，你可以按照自己的需求给它定一个名字。用来后续使用！
第三个 type ，就是用来代表变量的类型。
举个栗子：
// 定义一个字符串变量，name
var name string
// 定义一个数字类型变量 age
var age int如果你学过Java、C或者其他编程语言，第一次看到这样的操作肯定不舒服。Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后。这样做的好处就是可以避免像C语言中那样含糊不清的声明形式，例如：int* a, b；。其中只有a是指针而b不是。如果你想要这两个变量都是指针，则需要将它们分开书写。而在Go中，则可以和轻松地将它们都声明为指针类型：
var a, b *int变量的命名规则遵循驼峰命名法，即首个单词小写，每个新单词的首字母大写，例如：userFiles和systemInfo。
变量定义的标准格式为
var 变量名 变量类型变量声明以关键字var开头，后置变量类型，行尾无须分号。
我们有时候会批量定义变量，如果每次都单独定义比较麻烦，Go语言支持批量定义变量
使用关键字var和括号，可以将一组变量定义放在一起。
var (
addr string
phone string
)var形式的声明语句往往是用于需要显式指定变量类型地方，或者因为变量稍后会被重新赋值而初始值无关紧要的地方。
当一个变量被声明之后，如果没有显示的给他赋值，系统自动赋予它该类型的默认值：
整型和浮点型变量的默认值为 0 和 0.0。
字符串变量的默认值为空字符串。
布尔型变量默认为 false。
切片、函数、指针变量的默认为 nil。
go语言默认零值可用 -- 定义可以不用赋值但必须使用。
变量的初始化
变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量（值）。
变量的使用步骤
声明变量（也叫：定义变量）
非变量赋值
使用变量
快速入门案例
package main
import "fmt"
func main() {
//定义变量
var i int
//给i赋值
i = 10
//打印i的值
fmt.Println("i的值为:", i)
}
// 演示变量的声明和初始化变量使用注意事项
变量表示内存中的一个存储区域。
该区域有自己的名称（变量名）和类型（数据类型）。
Golang变量初始化的三种方式：
第一种：指定变量类型，声明后若不赋值，使用默认值。
package main
import "fmt"
func main() {
//int的默认值是0，其它数据类型的默认值上面有介绍
var i int
fmt.Println("i=", i)
}第二种：根据值自行判定变量类型（类型推导）。
var num = 10.11
fmt.Println("num=", num)第三种（短变量声明并初始化）：省略
var,注意
:=左侧的变量不应该是已经声明过的，否则会导致编译错误no nqw variables on left side of :=。//下面的方式等价var name string name ="tom"
//:= 的 :不能省略，否则错误
name := "tom"
fmt.Println("name=", name)//:= 自动推导 //以下演示:= 自动推导变量类型 package main import "fmt" func main() { name := "deadline" age := 18 fmt.Println(name, age) fmt.Printf("%T,%T", name, age) //%T表示type（类型） } // 以上代码演示了如何声明变量并输出其值和类型 // name 和 age 是变量，分别存储字符串和整数类型的值 // fmt.Println(name, age) 输出变量的值 // fmt.Printf("%T,%T", name, age) 输出变量的类型 // %T 是格式化动词，用于输出变量的类型
多变量声明
在编程中，有时我们需要一次性声明多个变量，Golang也提供这样的语法。
package main
import "fmt"
func main() {
//该案例演示golang如何一次性声明多个变量
var n1, n2, n3 int
fmt.Println("n1=", n1, "n2=", n2 ,"n3=", n3)
//一次性声明多个变量的方式2
var n4, name, n5 = 100, "tom", 888
fmt.Println("n4=", n4, "name=", name, "n5=", n5)
//一次性声明多个变量的方式3，同样可以使用类型推导
n6, name01, n7 := 100, "tom~", 888
fmt.Println("n6=", n6, "name01=", name01, "n7=", n7)
}
// 注意：在Go语言中，变量声明后如果没有赋值，则会使用默认值，int类型的默认值为0，string类型的默认值为" "
// 另外，Go语言支持多变量声明和类型推导，可以在一行中声明多个变量并赋值，使用:=语法。
//运行结果如下
PS L:\goproject\src\go_code\chapter03\variable02\main> go run .\variable_demo02.go
n1= 0 n2= 0 n3= 0
n4= 100 name= tom n5= 888
n6= 100 name01= tom~ n7= 888如何一次性声明多个全局变量【在go中函数外部定义变量就是全局变量】：
package main import "fmt" //定义全局变量 var n1 = 100 var n2 = 200 var name = "Batman" //上面的定义方式也可改为一次性声明 var ( n3 = 300 n4 = 400 name1 = "Joker" ) func main() { fmt.Println("n1=", n1, "name=", name, "n2=", n2) fmt.Println("n3=", n3, "name1=", name1, "n4=", n4) }
该区域的数据值可以在同一类型范围内不断变化。
变量在同一个作用域内不能重名。
变量=变量名+值+数据类型。
Golang的变量如果没有赋初值，编译器会使用默认值，比如int默认值为0、string默认值为空
理解变量（内存地址）
package main
import "fmt"
func main() {
var num int
num = 1000
fmt.Printf("num的值为: %d\n,内存地址为：%p\n", num, &num)
//取地址符 &变量名
num = 2000
fmt.Printf("num的值为: %d\n,内存地址为：%p\n", num, &num)
}变量交换
package main
import "fmt"
/*
在编程中，最简的算法就是变量的交换了，但是我们一般常见的方式就是定义中间变量
var a int = 100
var b int = 200
var t int
t = a
a = b
b = t
fmt.Println(a, b)
*/
func main(){
var a int = 100
var b int = 200
// 在 Go 语言中，可以直接这样来实现换值，不需要中间变量了。
b, a = a, b
fmt.Println(a, b)
}匿名变量
匿名变量的特点是一个下划线_，_本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋值给这个标识符的值都将被抛弃，因此这些值不能在后续代码中使用，也不可以使用这个标识符作为变量对其他变量进行赋值或运算。使用匿名变量时，只需要在变量声明的地方使用下划线_替换即可。例如：
package main
import "fmt"
/*
定义一个test函数，它会返回两个int类型的值，每次调用将会返回 100 和 200 两个数值。
这里我们先不用管 函数的定义，后面会讲解，
我们用这个函数来理解_这个匿名变量。
*/
func test() (int, int) {
return 100, 200
}
func main(){
a, _ := test()
_, b := test()
fmt.Println(a，b) // 输出的结果为 100,200。
//在第一行代码中，我们只需要获取第一个返回值，所以第二个返回值定义为匿名变量
//在第二行代码中，我们只需要获取第二个返回值，所以第一个返回值定义为匿名变量，
}在编码过程中，可能会遇到没有名称的变量、类型或方法。虽然这不是必须的。但有时这样做可以极大地增强代码的灵活性，这些变量被统称为匿名变量。
匿名变量不占用内存空间，不会分配内存。匿名变量之间也不会因为多次声明而无法使用。
变量的作用域
一个变量（常量、类型或函数）在程序中都有一定的作用范围，称之为作用域。
了解变量的作用域对我们学习Go语言来说是比较重要的，因为Go语言会在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误。如果不能理解变量的作用域，就有可能会带来一些不明所以的编译错误。
局部变量
在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。
package main
import "fmt"
func main() {
//声明局部变量 a 和 b 并赋值
var a int = 100
var b int = 200
//声明局部变量 c 并赋值为 a + b
c := a + b
//输出变量 a, b 和 c 的值
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}全局变量
在函数体外声明的变量称之为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，当然，不包含这个全局变量的源文件需要使用import关键字引入全局变量所在的源文件之后才能使用这个全局变量。
注：全局变量声明必须以var关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。
package main
import "fmt"
var c int // 声明全局变量 c
func main() {
// 声明局部变量 a 和 b
var a, b int
//初始化参数
a = 100
b = 200
c = a + b // 使用全局变量 c 存储 a 和 b 的和
// 在 Go 语言中，局部变量可以直接使用全局变量
// 这里的 c 是全局变量，a 和 b 是局部变量
// 声明局部变量 c 并赋值为 a + b
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的眉部变量会被优先考虑。
package main
import "fmt"
var a float32 = 3.14
func main() {
//声明局部变量
var a int = 3
fmt.Printf("a = %d\n", a)
}常量(const)
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数）和字符串型。
const identifier [type] = value你可以省略类型说明符[type]，因为编译器可以根据变量的值来推断其类型。
显式类型定义：
const b string = "abc"隐式类型定义：
const b = "abc"
多个相同类型的声明可以简写为：
const c_name1, C_name2 = value1, value2以下实例演示了常量的应用： 常量的定义：const
package main
import "fmt"
func main() {
const URL string = "https://www.haloyang.top/" //显式定义
const URL2 = "https://www.haloyang.top/" //隐式定义
const a, b, c = 3.14, false, "hello" //多重赋值
fmt.Println(URL, URL2, a, b, c)
fmt.Printf("%T, %T, %T, %T, %T\n", URL, URL2, a, b, c) // 输出变量的类型
}特殊常量(iota)
iota，特殊常量，可以认为是一个可以被编译器修改的常量。iota是go语言的常量计数器
iota 在 const 关键字出现时将被重置为0（const内部的第一行之前），const 中每新增一行常量声明将使 iota 计数一次（ iota 可理解为 const 语句块中的行索引）。
iota 可以被用作枚举值：
const (
a = iota
b = iota
c = iota
)第一个 iota 等0，每当iota在新的一行被使用时，它的值都会自动加 1；所以 a=0,b=1,c=2 可以简写为如下形式：
const (
//一组常量中，如果某个常量没有初始值，默认和上一行一致。
a = iota
b
c
)例子：
package main
import "fmt"
func main() {
const (
a = iota //0 iota 0
b //1 iota 1
c //2 iota 2
d = "kunkun" //kunkun iota 3
e //kunkun iota 4
f = 100 //100 iota 5
g //100 iota 6
h = iota //7 iota 7
i //8 iota 8
)
const (
j = iota //0 iota 0
k //1 iota 1
)
fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
fmt.Printf("%T, %T, %T, %T, %T, %T, %T, %T, %T, %T,%T\n", a, b, c, d, e, f, g, h, i, j, k)
// 输出变量的值和类型
}基本数据类型(type)
Go语言是一种静态类型的编程语言，在Go编程语言中，数据类型用于声明函数和变量。数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。编译器在进行编译的时候，就要知道每个值的类型，这样编译器就知道要为这个值分配多少内存，并且知道这段分配的内存表示什么。
布尔型(bool)
布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
package main
import "fmt"
func main() {
// var isFlag bool
// var isFlag2 bool
// isFlag = true
// isFlag2 = false
var isFlag bool = true //不赋值的则默认为false
var isFlag2 bool = false
fmt.Printf("%T,%t\n", isFlag, isFlag)
fmt.Printf("%T,%t\n", isFlag2, isFlag2)
}数字型（int、float）
整型 int 和浮点型 float32、float64，Go语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
Go也有基于架构的类型，例如：uint无符号、int有符号
func main(){
var i1 int8
var i2 uint8
i1 = 100
i2 = 200
fmt.Println(i1)
fmt.Println(i2)
}浮点型
func main(){
var f1 float32
f1 = 3.14
var f2 float64
f2 = 5.12
// %f默认保留小6位数，'．2f%'就是保留2位，'．3f%'就是保留3位
fmt.Printf("%T,%.3f\n",f1,f1)
fmt.Printf("%T,%f\n",f2, f2)
}1、关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位 2、尾数数部分可能丢失，造成精度损失。-123.0000901
package main
import "fmt"
func main() {
var num1 float32 = -123.0000901
//尽量使用float64来定义浮点类型的小数（golang默认也是float64）
var num2 float64 = -123.0000901
fmt.Println("numl = ", numl, "num2 =", num2)
}说明：float64的精度要比float32的要准确
说明：如果我们要保存一个精度高的数，则应该选择float64
3、浮点型的存储分为三部分：符号位+指数位+尾数位，在存储过程中，精度会有丢失 4、golang的浮点型默认为float64类型 5、通常情况下，应该使用float64,因为它比float32更精确
以下列出了其他更多的数字类型：
字符串类型（string）
字符串就是一串固定长度的字符连接起来的字符序列。
Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本。
func main() {
var str string
str = "Hello,World"
fmt.Printf("%T,%s\n",str, str)
//单引号和双引号区别，单引号字符，ascii字符码
v1 := 'A' //int32,65
v2 := "A" //string,A
fmt.Printf("%T,%d\n", V1, V1)
fmt.Printf("%T,%s \n", v2, v2)
//扩展知识：
//中国的编码表：GBK
//Unicode编码表：号称兼容了全世界的文字
v3 := '中' //int,20013
fmt.Printf("%T,%d\n", v3, v3)
}Go语言的字符串连接可以通过+实现：
fmt.Println("Kun" + "kun")转义字符（详见第一章）：
/转义双引号
fmt.Println("\"hello,world\"")
/*
\b backspace
\t tab
\n newline
*/数据类型转换
在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明：
valueOfTypeB = typeB(valueOfTypeA)类型B的值 = 类型B（类型A的值）
func main() {
a := 5.0 //float
b := int(a) //转为int
fmt.Printf("%T,%f\n", a, a)
fmt.Printf("%T,%d\n", b, b)
}类型转换只能在定义正确的情况下转换成功，例如从一个取值范围较小的类型转换到一个取值范围较大的类型（将 int16 转换为 int32 ）。当从一个取值范围较大的类型转换到取值范围较小的类型时（将 int32 转换为 int16 或将 float32 转换为 int ），会发生精度丢失（截断）的情况。
运算符(operators)
算术运算符
关系运算符
逻辑运算符
位算符
赋值运算符
其他运算符
算术运算符(Arithmetic)
下表列出了所有Go语言的算术运算符。假定 A 值为10，B 值为20。
package main
import "fmt"
func main() {
var a int = 10
var b int = 20
//var c int
fmt.Println(a + b)
fmt.Println(a - b)
fmt.Println(a * b)
fmt.Println(a / b) // 注意：在 Go 语言中，除法操作会进行整数除法
// 如果需要浮点数除法，需要将其中一个操作数转换为浮点数类型, 0
fmt.Println(float64(a) / float64(b)) // 浮点数除法, 0.5
fmt.Println(a % b) // 取余操作, 10
a++ //a = a + 1, 11
fmt.Println(a)
a-- //a = a - 1, 10
fmt.Println(a)
a-- //a = a - 1, 9
fmt.Println(a)
}关系运算符(Relationa)
下表列出了所有Go语言的关系运算符。假定A值为10，B值为20。
package main
import "fmt"
func main() {
var a int = 10
var b int = 20
// 关系运算符
fmt.Println(a == b) // 相等
fmt.Println(a != b) // 不相等
fmt.Println(a > b) // 大于
fmt.Println(a >= b) // 大于等于
fmt.Println(a < b) // 小于
fmt.Println(a <= b) // 小于等于
// 使用 if 语句结合关系运算符
// 相等
if a == b {
fmt.Printf("a 等于 b\n")
} else {
fmt.Printf("a 不等于 b\n")
}
// 不相等
if a != b {
fmt.Println("a 不等于 b\n")
} else {
fmt.Println("a 等于 b\n")
}
// 小于，不小于
if a < b {
fmt.Println("a 小于 b\n")
} else {
fmt.Println("a 不小于 b\n")
}
// 大于，不大于
if a > b {
fmt.Println("a 大于 b\n")
} else {
fmt.Println("a 不大于 b\n")
}
// 大于等于
if a >= b {
fmt.Println("a 大于等于 b\n")
} else {
fmt.Println("a 小于等于 b\n")
}
// 小于等于
if a <= b {
fmt.Println("a 小于等于 b\n")
} else {
fmt.Println("a 大于等于 b\n")
}
}逻辑运算符(Logical)
下表列出了所有Go语言的逻辑运算符。假定A值为True，B值为False。
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")
} else {
fmt.Printf("第四行 - 条件为 false\n")
}
}位运算符(Bitwise)
Go语言支持的位运算符如下表所示，假定A为60，B为13:
package main
import "fmt"
func main() {
var a uint = 60 // 0011 1100
var b uint = 13 // 0000 1101
var c uint = 0 // 0000 0000
c = a & b // 按位与:0000 1100
fmt.Printf("%d, 二进制为%b\n", c, c) // 输出: 12, 二进制为0000 1100
c = a | b // 按位或:0011 1101
fmt.Printf("%d, 二进制为%b\n", c, c) // 输出: 61, 二进制为0011 1101
c = a ^ b // 按位异或:0011 0001
fmt.Printf("%d, 二进制为%b\n", c, c) // 输出: 49, 二进制为0011 0001
c = a << 2 // 左移:1111 0000
fmt.Printf("%d, 二进制为%b\n", c, c) // 输出: 240, 二进制为1111 0000
a = 60 // 重置a为60
c = a >> 2 // 右移:0000 1111
fmt.Printf("%d, 二进制为%b\n", c, c) // 输出: 15, 二进制为0000 1111
}赋值运算符(Assignment)
下表列出了所有Go语言的赋值运算符。
package main
import "fmt"
func main() {
var a int = 10 // 声明并初始化变量a
var b int = 20 // 声明并初始化变量b
// 使用赋值运算符将b的值赋给a
a = b
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 20
// 使用加法赋值运算符将b的值加到a上
a += b // a = a + b
// 此时a的值为40，因为20 + 20 = 40
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 40
// 使用减法赋值运算符将b的值从a中减去
a -= b // a = a - b
// 此时a的值为20，因为40 - 20 = 20
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 20
// 使用乘法赋值运算符将a和b相乘
a *= b // a = a * b
// 此时a的值为400，因为20 * 20 = 400
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 400
// 使用除法赋值运算符将a除以b
a /= b // a = a / b
// 此时a的值为20，因为400 / 20 = 20
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 20
// 使用取模赋值运算符将a对b取模
a %= b // a = a % b
// 此时a的值为0，因为20 % 20 = 0
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 0
// 使用左移赋值运算符将a左移2位
a <<= 2 // a = a << 2
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 0，因为0左移任何位数仍然是0
// 使用右移赋值运算符将a右移2位
a >>= 2 // a = a >> 2
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 0，因为0右移任何位数仍然是0
// 使用按位与赋值运算符将a和b进行按位与操作
a &= b // a = a & b
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 0，因为0与任何数按位与仍然是0
// 使用按位或赋值运算符将a和b进行按位或操作
a |= b // a = a | b
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 20，因为0或20仍然是20
// 使用按位异或赋值运算符将a和b进行按位异或操作
a ^= b // a = a ^ b
fmt.Printf("a的值为: %d\n", a) // 输出: a的值为: 0，因为20异或20结果是0
fmt.Printf("所有赋值操作完成，最终a的值为: %d\n", a) // 输出: 所有赋值操作完成，最终a的值为: 0
}其他运算符（指针）
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 的值为 %p\n", ptr)
fmt.Printf("*ptr 的值为 %d\n", *ptr) /*使用*运算符访问ptr指向的值*/
}拓展：键盘输入输出（简易计算器）
package main
import (
"fmt"
)
func main() {
/**
* 计算器程序
* 该程序实现了基本的加、减、乘、除运算
* 用户可以输入两个数字和一个运算符，程序将输出计算结果
*/
var num1, num2 float64
var operator string
fmt.Println("欢迎使用计算器！")
fmt.Print("请输入第一个数字: ")
fmt.Scanln(&num1)
fmt.Print("请输入第二个数字: ")
fmt.Scanln(&num2)
fmt.Print("请输入运算符 (+, -, *, /): ")
fmt.Scanln(&operator)
switch operator {
case "+":
result := num1 + num2
fmt.Printf("结果: %.2f + %.2f = %.2f\n", num1, num2, result)
case "-":
result := num1 - num2
fmt.Printf("结果: %.2f - %.2f = %.2f\n", num1, num2, result)
case "*":
result := num1 * num2
fmt.Printf("结果: %.2f * %.2f = %.2f\n", num1, num2, result)
case "/":
if num2 != 0 {
result := num1 / num2
fmt.Printf("结果: %.2f / %.2f = %.2f\n", num1, num2, result)
} else {
fmt.Println("错误: 除数不能为零！")
}
default:
fmt.Println("错误: 无效的运算符！")
}
}
