1、条件语句
Go 编程语言中 if 条件语句的语法如下：
1、基本形式
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
}
If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果false 则不执行。
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* 使用 if 语句判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n" )
}
fmt.Printf("a 的值为 : %d\n", a)
} 以上代码执行结果为：
a 小于 20
a 的值为 : 10
2、if...else 语句的语法如下：
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
} else {
/* 在布尔表达式为 false 时执行 */
}
If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果false 则执行else 语句块。
注意：else前面和后面都要紧跟{}
package main
import "fmt"
func main() {
/* 局部变量定义 */
var a int = 100
/* 判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n" )
} else {
/* 如果条件为 false 则执行以下语句 */
fmt.Printf("a 不小于 20\n" )
}
fmt.Printf("a 的值为 : %d\n", a)
} 以上代码执行结果为：
a 不小于 20
a 的值为 : 100
3、 Go的if语句嵌套形式如下：
阶梯嵌套形式
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
} else if 布尔表达式2 {
/* 在布尔表达式2为 true 时执行该位置可以多层嵌套*/
} else {
/* 在布尔表达式2为 false 时执行 */
}
if ...else... 的多层嵌套，建议嵌套的深度不要超过四层。
练习题：
1、使用if...else 分支语句判断用户输入的数字是否相等，以及大小情况输出。
Go 语言 switch 多分支语句
switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试， 直到匹配为止。
switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break 语法
Go 编程语言中 switch 语句的语法如下：
switch var1 {
case val1:
...
case val2:
...
default:
...
}
变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数， 但必须是相同的类型；或者最终结果为相同类型的表达式。
您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。
实例：
package main
import "fmt"
func main() {
/* 定义局部变量 */
var grade string = "B"
var marks int = 90
switch marks {
case 90: grade = "A"
case 80: grade = "B"
case 70 : grade = "C"
case 60: grade = “D”
case 50: grade ="E"
default: grade = "F"
}
switch {
case grade == "A" :
fmt.Printf("优秀!\n" )
case grade == "B", grade == "C" :
fmt.Printf("良好\n" )
case grade == "D" :
fmt.Printf("及格\n" )
case grade == "E":
fmt.Printf("不及格\n" )
default:
fmt.Printf("差\n" )
}
fmt.Printf("你的等级是 %s\n", grade )
} 以上代码执行结果为：
优秀!
你的等级是 A
switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。
Type Switch 语法格式如下：
switch x.(type){
case type:
statement(s)
case type:
statement(s)
/* 你可以定义任意个数的case */
default: /* 可选 */
statement(s)
}
实例
package main
import "fmt"
func main() {
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" x 的类型 :%T",i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型" )
default:
fmt.Printf("未知型")
}
} 以上代码执行结果为：
x 的类型 :<nil>
补充：
fallthrough是配合switch使用的，golang里面每个case默认都有一个break，
fallthrough可以取消这个默认的break,并且执行下一个case而不用判断下个case，
如果没有case会执行default的内容。
比如：
package main
import (
"fmt"
)
func main() {
a := 2
switch a {
case 1:
fmt.Println("a=1")
case 2:
fmt.Println("a=2")
fallthrough
case 3:
fmt.Println("a=3")
fallthrough
case 4:
fmt.Println("a=4")
fallthrough
default:
fmt.Println("default")
}
} 执行结果：
a=2
a=3
a=4
default
2、循环语句
Go 语言循环语句只有 for循环
golang里面没有while关键字，可以用for+break实现。
for循环是一个循环控制结构，可以执行指定次数的循环。
语法
Go语言的For循环有3种形式，只有其中的一种使用分号。
和 C 语言的 for 一样：
for循环 注意：不能在for之后带（）会有语法错误。
for init; condition; post {
//循环体语句
}
• init： 一般为赋值表达式，给控制变量赋初值；
• condition： 关系表达式或逻辑表达式，循环控制条件；
• post： 一般为赋值表达式，给控制变量增量或减量。
和 C 的 while 一样： while循环
for condition {
//循环体语句
}
和 C 的 for(;;) 一样： 死循环
for {
//循环体语句
}
for语句执行过程如下：
◇ ①先对表达式1赋初值；
◇ ②判别赋值表达式 condition 是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句， 然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。
实例
package main
import "fmt"
func main() {
var b int = 15
var a int
/* for 循环 */
for a := 0; a < 10; a++ {
fmt.Printf("a 的值为: %d\n", a)
}
for a < b {
a++
fmt.Printf("a 的值为: %d\n", a)
}
} 尝试一下以上实例运行输出结果为:
练习题：
根据以上for循环的语法规则，编写程序完成 1+2+3+..+100的所有整数求和。
Go 语言循环嵌套
Go 语言允许用户在循环内使用循环。接下来我们将为大家介绍嵌套循环的使用。
Go语言中的循环语句只支持 for 关键字，而不支持 while 和 do-while 结构， 关键字 for 的基本使用方法与C语言和 C++ 中非常接近：
语法
以下为 Go 语言嵌套循环的格式：
for [condition | ( init; condition; increment ) | Range]{
for [condition | ( init; condition; increment ) | Range]{
statement(s)
}
statement(s)
}
注意： for 后面的条件表达式不需要用圆括号()括起来
实例
以下实例使用循环嵌套来输出 2 到 100 间的素数：
package main
import "fmt"
func main() {
/* 定义局部变量 */
var i, j int
for i=2; i < 100; i++ { //左花括号{必须与 for 处于同一行
for j=2; j <= (i/j); j++ {
if(i%j==0) {
break // 想·如果发现因子，则不是素数
}
}
if(j > (i/j)) {
fmt.Printf("%d 是素数\n", i)
}
}
} 以上实例运行输出结果为:
2 是素数
3 是素数
5 是素数
7 是素数
。。。。
73 是素数
79 是素数
83 是素数
89 是素数
97 是素数
Go 语言中 range 关键字
用于for循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引值，在集合中返回 key-value 对的 key 值。对于映射，它返回下一个键值对的键。Range返回一个值或两个值。如果在 Range表达式的左侧只使用了一个值，则该值是下表中的第一个值。
实例
package main
import "fmt"
func main() {
//这是我们使用range去求一个slice的和。使用数组跟这个很类似
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
}
fmt.Println("sum:", sum) //在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，
//所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
//range也可以用在map的键值对上。
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
}
//range也可以用来枚举Unicode字符串。第一个参数是字符的索引，
//第二个是字符（Unicode的值）本身。
for i, c := range "go" {
fmt.Println(i, c)
}
}以上实例运行输出结果为：
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111
3、跳转语句
跳转语句
1、break用法，跳出当前层的循环
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* for 循环 */
for a < 20 {
fmt.Printf("a 的值为 : %d\n", a)
a++
if a > 15 {
/* 使用 break 语句跳出循环 */
break
}
}
} 以上实例执行结果为：
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 15
2、continue用法, 跳过当前循环，继续执行下一轮循环
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* for 循环 */
for a < 20 {
if a == 15 {
/* 跳过此次循环 */
a = a + 1
continue
}
fmt.Printf("a 的值为 : %d\n", a)
a++;
}
} 以上实例执行结果为：
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19
3、goto 跳转用法
package main
import "fmt"
func main() {
for x := 0; x < 10; x++ {
for y := 0; y < 10; y++ {
if y == 2 {
// 跳转到标签
goto breakHere
}
}
}
// 手动返回, 避免执行进入标签
return
// 标签主要用于错误处理
breakHere:
fmt.Println("done")
} 练习题：
根据以上代码，编写一个测试用例，将10以内的所有偶数打印输出。
将这些偶数求和再输出。
4、输入输出语句
1、输入语句
Go语言的标准输出流在打印到屏幕时有些参数跟别的语言（比如C#和Java）不同，
fmt包实现了类似C语言printf和scanf的格式化I/O。
I : input 输入操作格式化输入 scanf
O：output 输出操作格式化输出 printf
Go语言fmt包下有
//终端获取
func Scan(a ...interface{}) (n int, err error)
func Scanln(a ...interface{}) (n int, err error)
func Scanf(format string, a ...interface{}) (n int, err error)
//基于字符串
func Sscan(str string, a ...interface{}) (n int, err error)
func Sscanln(str string, a ...interface{}) (n int, err error)
func Sscanf(str string, format string, a ...interface{}) (n int, err error)
//基于文件
func Fscan(r io.Reader, a ...interface{}) (n int, err error)
func Fscanln(r io.Reader, a ...interface{}) (n int, err error)
func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)
标准输入 ==》键盘设备 ==》Stdin
标准输出 ==》显示器终端 ==》Stdout
异常输出 ==》显示器终端 ==》Stderr
其中 fmt.Scan、fmt.Scanf、fmt.Scanln三个函数，可以在程序运行过程中从标准输入获取用户的输入。
func Scan(a ...interface{}) (n int, err error)
//输入数据数量达标即可提交
举例如下：
func main() {
var (
name string
age int
married bool
)
fmt.Scan(&name, &age, &married)
fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age,
married)
}
func Scanf(format string, a ...interface{}) (n int, err error)
//输入多次达到要求格式数据数量即可提交。 不区别换行和空格
举例如下：
func main() {
var (
name string
age int
married bool
)
ag1, err := fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &married)
// 这个函数中参数前必须填入标识格式如1: 2: ...
fmt.Println(ag1) //成功的数量
fmt.Println(err) //错误状态
fmt.Printf("扫描结果 name:%s age:%d married:%t", name, age, married)
}另一种方法
func Scanln(a ...interface{}) (n int, err error)
//回车换行提交数据，数据输入一行。 中间不能有空白符空格，TAB键 。。。
举例如下：
func main() {
var (
name string
age int
married bool
)
fmt.Scanln(&name, &age, &married)
fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age,
married)
}建议读取控制台数据
调用fmt.Scan等方法
var j string
fmt.Scanln(&j) // Scanln读取一行
fmt.Println("j = ", j)
或者指定输入格式
var j string
var m float32
var n bool
fmt.Scanf("%d%f%s%t", &i, &m, &j, &n)
fmt.Println("i = ", i, "j = ", j, "m = ", m, "n = ", n)
输入时按空格或回车区分即可
注意一个问题：
func main(){
var input byte
fmt.Println("请输入一个字母")
scan, err := fmt.Scan(&input)
if err != nil {
fmt.Println("err:", err)
}
fmt.Println(scan)
fmt.Printf("the anser is %c", input)
} 
这里面定义一个变量接受byte 但是却无法接收到。
这是因为byte类型本质是uint8类型的，所以应该传入整数的，字母对应的
ASCII码值
但是还是要想传入字符类型 可以使用scanf进行，代码如下。
func main(){
var input byte
fmt.Println("请输入一个字母")
_, err := fmt.Scanf("%c", &input)
if err != nil {
fmt.Println("err:", err)
}
fmt.Printf("the anser is %c", input)
}另一种
第二个问题：%c的空格也会识别到比如下面代码
其他：
func Sscan(str string, a ...interface{}) (n int, err error)
按空格拆分
参数：此函数接受两个参数，如下所示：
str string:此参数包含将要扫描的指定文本。
a …interface{}:此参数接收每个文本。
返回值：它返回成功扫描的项目数。
eg：
package main
import (
"fmt"
)
func main() {
var name string
var alphabet_count int
n, err:= fmt.Sscan("GFG 3", &name, &alphabet_count)
if err != nil {
panic(err)
}
fmt.Printf("%d:%s, %d\n", n, name, alphabet_count)
} 结果：
2:GFG, 3
func Sscanf(str string, format string, a ...interface{}) (n int, err error)
按格式拆分
参数：此函数接受三个参数，如下所示：
str string:此参数包含将要扫描的指定文本。
format string:对于指定字符串的每个元素，此参数是不同的格式类型。
a …interface{}:此参数接收字符串的每个元素。
返回值：它返回成功解析的项目数。
eg：
package main
import (
"fmt"
)
func main() {
var name string
var alphabet_count int
n, err:= fmt.Sscanf("GFG is having 3 alphabets.",
"%s is having %d alphabets.", &name, &alphabet_count)
if err != nil {
panic(err)
}
fmt.Printf("%d:%s, %d\n", n, name, alphabet_count)
} 结果：
2:GFG, 3
func Sscanln(str string, a ...interface{}) (n int, err error)
参数：此函数接受两个参数，如下所示：
str string:此参数包含将要扫描的指定文本。
a …interface{}:此参数接收字符串的每个元素。
返回值：它返回成功扫描的项目数。
eg：
package main
import (
"fmt"
)
func main() {
var name string
var alphabet_count int
n, err:= fmt.Sscanln("GFG 3", &name, &alphabet_count)
if err != nil {
panic(err)
}
fmt.Printf("n:%d, name:%s, alphabet_count:%d \n",
n, name, alphabet_count)
} 结果：
n:2, name:GFG, alphabet_count:3
与Sscan几乎一样
总结：
scan为核心关键字
Scan, Fscan, Sscan, 在读取内容的时候不会关注换行
Scanln, Fscanln, Sscanln, 在读取内容的时候, 到换行结束
Scanf, Fscanf, Sscanf, 以格式化的方式读取内容
Scan, Scanln, Scanf, 从控制台读取内容
Sscan, Scanln, Sscanf, 从指定字符串中读取内容
Fscan, Fscanln, Fscanf, 从文中中读取内容
前缀为空, 前缀为S, 前缀为F, 代表了读取内容的位置
后缀为空, 后缀为ln, 后缀为F, 代表了是读取内容时是否关注换行, 是否可
以格式化字符串
重点掌握的内容：
格式输入： fmt.Scanf()
格式输出： fmt.Printf()
其他都是了解即可。
补充：
如果读取不带空格的数据可以使用fmt.Scan或fmt.Scanln读取一个或多个值，但是不能读取带空格的数据，可以使用bufio和os两个包结合
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
// os.Stdin将终端中输入的数据写入到Stdin这个文件中去
reader := bufio.NewReader(os.Stdin)
fmt.Print("请输入一行数据，带空格也行：")
// line 从Stdin中读取一行的数据，（字节的切片）可以转换成字符串
// reader默认一次能读4096个字节，一个汉字是三个字节
// 一次性读完：isPrefix就等于false
// 先读一部分：isPrefix等于true
line, isPrefix, err := reader.ReadLine()
// 将字节的切片转换成字符串
data := string(line)
fmt.Println(line, isPrefix, err)
fmt.Println(data)
} or 更简单
package main
import (
"bufio"
"fmt"
"os"
"strings"
)
func main() {
var msg string
reader := bufio.NewReader(os.Stdin) // 标准输入输出
msg, _ = reader.ReadString('\n') // 回车结束
msg = strings.TrimSpace(msg) // 去除最后一个空格
fmt.Printf("input=%s\n", msg) //结果输出
} 2、输出语句
Print系列函数会将内容输出到系统的标准输出，
func Print(a ...interface{}) (n int, err error) //一般输出，不带格式
func Printf(format string, a ...interface{}) (n int, err error) //格式化输出
func Println(a ...interface{}) (n int, err error) //换行输出
区别在于
Print函数直接输出内容，
Printf函数支持格式化输出字符串，
Println函数会在输出内容的结尾添加一个换行符。
//基于字符串操作
func Sprint(a ...interface{}) string
func Sprintf(format string, a ...interface{}) string
func Sprintln(a ...interface{}) string
//基于文件操作
func Fprint(w io.Writer, a ...interface{}) (n int, err error)
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err
error)
func Fprintln(w io.Writer, a ...interface{}) (n int, err error)
注意：不需要引用任何的包或者库，语言自带的：
第一个：print
注意：不需要引用任何的包或者库，语言自带的：
print——最基础，只输出，而且什么都不加
第二个：Println()
需要包含 fmt 包，并默认在每次输出结尾加入一个换行符。
package main
import "fmt"
func main() {
//print("hello word")
fmt.Println("go","python","c++","java")
}所有内容都是以 print 为核心关键字
print, Sprint, Fprint, 输出内容不会换行, 不能格式化字符串
Println, Sprintln, Fprintln, 输出内容换行, 不能格式化字符串
Printf, Sprintf, Fprintf, 输出内容不会换行, 可以格式化字符串
print, Println, Printf, 输出内容到控制台（终端输出）
Sprint, Sprintln, Sprintf, 输出内容为字符串
Fprint, Fprintln, Fprintf, 输出内容到文件
前缀为空, 前缀为S, 前缀为F, 代表了输出内容的位置
后缀为空, 后缀为ln, 后缀为F, 代表了是否有换行, 是否可以格式化字
符串
第三个：Printf输出的各种占位符号：
General
%v 以默认的方式打印变量的值
%T 打印变量的类型
%t是bool类型输出
Integer
%+d 带符号的整型，
fmt.Printf("%+d", 255)输出+255
%q 由单引号围绕的字符字面值 a := "aaa"
fmt.Printf("%q", a) // 输出 "aaa"
%o 不带零的八进制
fmt.Printf("%o\n", 65) //101
%#o 带零的八进制
fmt.Printf("%#o\n", 65) // 0101
%x 小写的十六进制
fmt.Printf("%x\n", 31) //1f
%X 大写的十六进制
fmt.Printf("%X\n", 31) //1F
%#x 带0x的十六进制
fmt.Printf("%#x\n", 31) //0x1f
%b 打印整型的二进制
fmt.Printf("%b\n", 65) //100 0001
String Width (以5做例子）（改变宽度）
%5s 最小宽度为5（右对齐），不足5的时候左补空格，超过5的时候原样输出
%-5s 最小宽度为5（左对齐）不足5的时候右补空格，超过5的时候原样输出
%.5s 最大宽度为5 多的部分裁掉，不够原样输出
%5.7s 最小宽度为5，最大宽度为7
%-5.7s 最小宽度为5，最大宽度为7（左对齐）
%5.3s 如果宽度大于3，则截断
%05s 如果宽度小于5，就会在字符串前面补零
注意：golang没有 '%u' 点位符，若整数为无符号类型，默认就会被打印成无符号的。 宽度与精度的控制格式以Unicode码点为单位。宽度为该数值占用区域的最 小宽度； 精度为小数点之后的位数。操作数的类型为int时，宽度与精度都可用字符 '*' 表示。 对于 %g/%G 而言，精度为所有数字的总数，例如：123.45，%.4g 会打印123.5， （而 %6.2f 会打印123.45）。 %e 和 %f 的默认精度为6 对大多数的数值类型而言，宽度为输出的最小字符数，如果必要的话会为已格式化的形式填充空格。而以字符串类型，精度为输出的最大字符数，如果必要的话会直接截断。
应用案例：
package main
import "fmt"
func main() {
var str string
var person struct {
name string
age int
}
person.name = "老王"
person.age = 50
str = "hello world"
fmt.Println("====一般占位符====")
fmt.Printf("%v\n", str) //hello world
fmt.Printf("%v\n", person) //{老王 50}
fmt.Printf("%+v\n", person) //{name:老王 age:50}
fmt.Printf("%#v\n", str) //"hello world"
fmt.Printf("%#v\n", true) //true
fmt.Printf("%T\n", str) //string
fmt.Printf("%T\n", true) //bool
fmt.Printf("%%\n") //%
fmt.Println("====布尔====")
fmt.Printf("%t\n", true)
fmt.Println("====整数====")
fmt.Printf("%b\n", 65) //1000001
fmt.Printf("%c\n", 65) //A
fmt.Printf("%d\n", 65) //65
fmt.Printf("%o\n", 65) //101
fmt.Printf("%q\n", 65) //'A'
fmt.Printf("%x\n", 31) //1f
fmt.Printf("%X\n", 31) //1F
fmt.Printf("%U\n", 31) //U+001F
fmt.Println("====浮点数及其复合构成====")
fmt.Printf("%b\n", 10.5) //5910974510923776p-49
fmt.Printf("%e\n", 10.5) //1.050000e+01
fmt.Printf("%E\n", 10.5) //1.050000E+01
fmt.Printf("%f\n", 10.5) //10.500000
fmt.Printf("%g\n", 10.5) //10.5
fmt.Printf("%G\n", 10.5) //10.5
fmt.Println("====字符串与字节切片====")
fmt.Printf("%s\n", "abc") //abc
fmt.Printf("%q\n", "abc") //"abc"
fmt.Printf("%x\n", "abc") //616263
fmt.Printf("%X\n", "abc") //616263
fmt.Println("====指针====")
fmt.Printf("%p\n", &str) //0xc0000441f0
} 其他：
func Sprint(a ...interface{}) string
参数：“ a…interface {}”包含一些字符串，其中包括指定的常量变量。
返回值：它返回结果字符串。
eg:
package main
import (
"fmt"
"io"
"os"
)
func main() {
const name, dept = "Openlab", "CS"
s := fmt.Sprint(name, " is a ", dept, " Portal.\n")
io.WriteString(os.Stdout, s)
}结果：
Openlab is a CS Portal.
func Sprintf(format string, a ...interface{}) string
参数：此函数接受两个参数，如下所示：
format string:其中包括一些varb和一些字符串。
a …interface{}:这是指定的常量变量。
返回值：它返回结果字符串。
eg：
package main
import (
"fmt"
"io"
"os"
)
func main() {
const name, dept = "Openlab", "CS"
s := fmt.Sprintf("%s is a %s Portal.\n", name, dept)
io.WriteString(os.Stdout, s)
}结果：
Openlab is a CS Portal.
func Sprintln(a ...interface{}) string
参数：“…interface {}”包含一些字符串以及指定的常量变量。
返回值：它返回结果字符串。
eg：
package main
import (
"fmt"
"io"
"os"
)
19/20func main() {
const num1, num2, num3, num4 = 5, 10, 15, 50
s1 := fmt.Sprintln(num1, "+", num2, "=", num3)
s2 := fmt.Sprintln(num1, "*", num2, "=", num4)
io.WriteString(os.Stdout, s1)
io.WriteString(os.Stdout, s2)
}结果：
5 + 10 = 15
5 * 10 = 50