Golang中输出fmt包的输入输出方法

在fmt包中针对打印的方法有很多中，输入的方法也有很多种。我们先学习一下它们的使用方法，只有先知道如何使用，才能知道区别。在后期的学习过程中，我们才会知道根据需求使用不同的方法。

fmt输出

fmt.Print()

第一个fmt.Print()，在打印的时候fmt.Print()不支持换行，如果我们想打印多次需要自己添加"\n"参数，来代替换行符。先看下面的例子：

package main
import "fmt"
//个人技术博客http://www.wulaoer.org
func main() {
	fmt.Print("Hello")
	fmt.Print("Word")
}

打印结果：

HelloWord

上面打印的结果把两个字符都合并一起了，如果我想分开打印，就需要使用换行符"\n"，下面看一下加换行符"\n"之后的打印结果:

package main
import "fmt"
//个人技术博客http://www.wulaoer.org
func main() {
	fmt.Print("Hello","\n")
	fmt.Print("Word")
}

打印结果：

Hello
Word

这里注意，换行符"\n"必须是双引号，如果单引号会打印出byte类型或rune类型，只有双引号才会是字符串或者字符数组，如果换成反引号(Esc下面的那个键)表示字符串的字面量，你定义时是什么样，打印出来是什么样，支持换行、转义符。看下面的例子：

package main
import "fmt"
//个人技术博客http://www.wulaoer.org
func main() {
	fmt.Print("双引号字符:","w", "\n")  //Print原本不带换行符
	fmt.Print("单引号字符:",'w', "\n")
	fmt.Print("双引号字符加整数:","w", "1", "\n")
	fmt.Print("单引号字符加整数:",'w', '1', "\n")
	fmt.Print("不加引号打印整数:",27, "\n")
	fmt.Print("不加引号打印整数:",'w', 11, "\n")
	fmt.Print("反引号",`wulaoer`,`wolf`)
}

打印结果：

双引号字符:w
单引号字符:119
双引号字符加整数:w1
单引号字符加整数:119 49
不加引号打印整数:27
不加引号打印整数:119 11
反引号wulaoerwolf

注意fmt.Print()不支持字符串格式化，不支持自动换行，支持单引号，双引号，反引号操作。在单引号中的byte类型只能是一位，可以理解为字母，多个字母就是字符了。

fmt.Println()

fmt.Println()支持自动换行，一行一个fmt.Println()语句。和看fmt.Print()一样，也支持双引号，单引号，反引号等。看下面的例子：

package main
import "fmt"
//个人技术博客http://www.wulaoer.org
func main() {
	fmt.Println("双引号字符:","w")
	fmt.Println("单引号字符:",'w')
	fmt.Println("双引号字符加整数:","w","1")
	fmt.Println("单引号字符加整数:",'w', 'l')
	fmt.Println("不加引号打印整数:",27)
	fmt.Println("不加引号打印整数:",27, 11)
	fmt.Println("使用换行符打印整数:","\n", 27, 11)
}

打印结果：

双引号字符: w
单引号字符: 119
双引号字符加整数: w 1
单引号字符加整数: 119 108
不加引号打印整数: 27
不加引号打印整数: 27 11
使用换行符打印整数: 
 27 11

fmt.Println()支持自动换行，但是不支持字符串格式化。在Golang中，打印方法是分开的，不像python那样一个print()即支持换行也支持字符格式化。

fmt.Printf()

fmt.Printf()是支持字符格式化的，但是fmt.Printf()不支持换行和fmt.Print()一样，两者的区别就是字符格式化，看下面的例子：

package main
import "fmt"
//个人技术博客http://www.wulaoer.org

//定义的全局变量
const (
	wulaoer string = "\nmain {\nconsole.log(event)\nreturn ret\n};\n"
	wolf string = `
	main {
		console.log(event)
	};
`
)
const (
	name string = "wulaoer"
)
func main() {
	fmt.Printf("Hi my name is %s \n",name)
	fmt.Printf("wulaoer:%v\n", wulaoer[1])
	fmt.Printf("wolf:%s\n",wolf)
}

打印结果：

Hi my name is wulaoer 
wulaoer:109
wolf:
	main {
		console.log(event)
	};

我们先测试了前面的反引号，后面又根据字符格式化，使用了参数"%s"打印字符串，"%v"打印变量的值。

下面看看fmt.Printf()格式化的参数：

%v:以默认的方式打印变量的值
%T:打印变量的输出类型

整数

%d:格式化输出整数，%+d表示带符号的整型，fmt.Printf("%+d", 255)输出+255
%b:格式化输出整数的二进制
%x:格式化输出十六进制，使用小写的x是输出的小写，大写的输出大写
%q:打印双引号
%o:不带零的八进制,%#o表示带零的八进制
%x:小写的十六进制,%X表示大写的十六进制，%#x表示带0x的十六进制
%U:打印Unicode字符，%#U表示打印带字符的Unicode

浮点数

%f:格式化输出浮点数
%e:科学计数法e，%E和%e的区别不大

整数宽度

|%6d|%6d|：整数的最小宽度为6，如果更宽则扩大。右对齐|%-6d|%-6d|，不够用0补充。
|%6.2f|%6.2f|：浮点数的最小宽度为6.2，如果更宽则扩大

根据上面的参数，这里把所有参数的例子都写出来了，看下面的例子：

package main
import (
	"fmt"
	//"os"
)
//个人技术博客http://www.wulaoer.org
type wulaoer struct {
	x, y int
}
func main()  {
	p := wulaoer{27,11}
	fmt.Printf("打印值的结构体：%v\n", p)
	fmt.Printf("格式化输出结构体的字段名: %+v\n", p)
	fmt.Printf("输出值的go语法表示: %#v\n", p)
	fmt.Printf("输出值的类型: %T\n", p)
	fmt.Printf("格式化布尔值: %t\n",true)
	fmt.Printf("格式化整数，十进制格式化：%+d\n",277)
	fmt.Printf("格式化整数，二进制格式化：%b\n",27)
	fmt.Printf("输出整数对应的字符: %c\n",119)
	fmt.Printf("不带0的八进制:%o\n",22)
	fmt.Printf("带0的八进制:%#o\n",22)
	fmt.Printf("输出整数，十六进制格式化大写: %X\n",27)
	fmt.Printf("输出整数，带0x的十六进制: %#X\n",27)
	fmt.Printf("输出整数，十六进制格式化小写: %x\n",27)
	fmt.Printf("格式化浮点数,十进制格式化: %f\n",3.1415926)
	fmt.Printf("格式化浮点数，科学记数法: %e\n",234523452345.0)
	fmt.Printf("格式化浮点数，科学记数法: %E\n",234523452345.0)
	fmt.Printf("浮点数，所需的最小位数：%g\n",11111.2722222222)
	fmt.Printf("输出字符串: %s\n","www.wulwoer.org")
	fmt.Printf("给输出的字符串加双引号: %q\n","www.wulaoer.org")
	fmt.Printf("使用base-16编码输出字符串: %x\n","wulaoer.org")
	fmt.Printf("输出一个指针的值: %p\n",&p)
	fmt.Printf("整数的最小宽度为6，如果更宽则扩大: |%6d|%6d|\n",999999999999999999,22)
	fmt.Printf("浮点数的最小宽度为6.2，如果更宽则扩大: |%6.2f|%6.2f|\n", 1.2, 3.45)
	fmt.Printf("字符串的最小宽度为6.2，如果更宽则扩大: |%6s|%6s|\n", "foo", "b")
	fmt.Printf("字符串的最小宽度为6.2，如果更宽则扩大左对齐: |%-6s|%-6s|\n", "foo", "b")
	fmt.Printf("字符串的最小宽度为6.2，如果更宽则扩大，右对齐，用0填充: |%06s|%06s|\n", "foo", "b")
	val := 1234567
	fmt.Printf("从右边往左截取：%5d\n",val%1000)
	fmt.Printf("从右边往左截取，左对齐：%-5d\n",val%100)
	fmt.Printf("打印Unicode字符: %U\n",2)
	fmt.Printf("打印带字符的Unicode: %#U",3)
}

打印结果：

打印值的结构体：{27 11}
格式化输出结构体的字段名: {x:27 y:11}
输出值的go语法表示: main.wulaoer{x:27, y:11}
输出值的类型: main.wulaoer
格式化布尔值: true
格式化整数，十进制格式化：+277
格式化整数，二进制格式化：11011
输出整数对应的字符: w
不带0的八进制:26
带0的八进制:026
输出整数，十六进制格式化大写: 1B
输出整数，带0x的十六进制: 0X1B
输出整数，十六进制格式化小写: 1b
格式化浮点数,十进制格式化: 3.141593
格式化浮点数，科学记数法: 2.345235e+11
格式化浮点数，科学记数法: 2.345235E+11
浮点数，所需的最小位数：11111.2722222222
输出字符串: www.wulwoer.org
给输出的字符串加双引号: "www.wulaoer.org"
使用base-16编码输出字符串: 77756c616f65722e6f7267
输出一个指针的值: 0xc000116060
整数的最小宽度为6，如果更宽则扩大: |999999999999999999|    22|
浮点数的最小宽度为6.2，如果更宽则扩大: |  1.20|  3.45|
字符串的最小宽度为6.2，如果更宽则扩大: |   foo|     b|
字符串的最小宽度为6.2，如果更宽则扩大左对齐: |foo   |b     |
字符串的最小宽度为6.2，如果更宽则扩大，右对齐，用0填充: |000foo|00000b|
从右边往左截取：  567
从右边往左截取，左对齐：67   
打印Unicode字符: U+0002
打印带字符的Unicode: U+0003

以上是针对fmt.Printf()的所有用法，可能有些用法没有写到，后期发现及时补充。也可以不使用fmt包直接使用print,println打印，看下面的例子：

package main
//个人技术博客http://www.wulaoer.org
func main()  {
	print("this is learn www.wulaoer.org\n")
	println("Golang python3")
}

输出结果：

this is learn www.wulaoer.org
Golang python3

这是针对Golang中变量的输出，以及字符串的输出格式化方法，下面看输出方法：

fmt输入

Golang的输入有很多种方法，有的是获取终端的输入，有的是把输入的值赋值给变量，然后打印变量。先看第一种方法：

package main
//个人技术博客http://www.wulaoer.org
import "fmt"
func main()  {
	var name string
	var age int
	fmt.Println("输入名字:")
	fmt.Scanln(&name)
	fmt.Println("输入年龄:")
	fmt.Scan(&age)
	fmt.Printf("我的名字叫 %s,今年%d岁",name,age)
}

输出结果：

输入名字:
wolf
输入年龄:
18
我的名字叫 wolf,今年18岁

这里使用Scanln和Scan是一样的，程序停止执行等待用户输入。下面看赋值给变量

package main
//个人技术博客http://www.wulaoer.org
import (
	"bufio"
	"fmt"
	"os"
)
func main()  {
	reader := bufio.NewReader(os.Stdin)
	result ,err := reader.ReadString('\n')
	if err != nil {
		fmt.Println("read error",err)
	}

	fmt.Println("you name :",result)
	fmt.Println("------------------------------------")
	var buffer [4096]byte
	n, errs := os.Stdin.Read(buffer[:])
	if errs != nil {
		fmt.Println("read error",errs)
	}
	fmt.Println("count:",n,"msg:",string(buffer[:]))
}

输出结果：

hello word
you name : hello word

------------------------------------
www.wulaoer.org
count: 16 msg: www.wulaoer.org

两者的区别是针对输入的字符，上面的方法在字符串中不能有空格，返回的字符串只能返回空格前的字符，后面的字符不返回。这里返回了所有的字符，不需要什么直接返回结果。不输入直接回车也不会报错，没有对输入的一个判断，而且输入的可以是任何类型。