Go-输入输出总结及oj的输入输出

旧城等待， 2022-10-16 09:56 257阅读 0赞

**目录**

输入

无换行

接口

控制台

字符串

有换行

接口

控制台

字符串

有格式

接口

控制台

字符串

操作系统参数

输出

无换行

接口

控制台

字符串

有换行

控制台

接口

字符串

有格式

控制台

接口

字符串

返回错误对象

fmt部分输入输出函数调用图

oj的输入输出

全部代码

参考

--------------------

# 输入 #

## 无换行 ##

### 接口 ###

> func Fscan(r io.Reader, a ...interface\{\}) (n int, err error)

Fscan从r扫描文本，将成功读取的**空白分隔的值保存进**成功传递给本函数的**参数**。**换行视为空白**。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少，会返回一个错误报告原因。

接口

type Reader interface {
        Read(p []byte) (n int, err error)
    }

实现了Read方法即可，例如文件、标准输入，这里以标准输入为例。

测试代码

var number int
    	fmt.Println("请输入一个整数：")
    	_, err = fmt.Fscan(os.Stdin, &number)
    	if err != nil{
    		fmt.Println(err)
    	}
    	fmt.Println("整数：",number)

结果

> 请输入一个整数：  
> 9  
> 整数： 9

> 请输入一个整数：  
> sfes  
> expected integer  
> 整数： 0

由于篇幅所限，之后就**不再测试出错的情况**，读者可以看后面全部代码，自行测试。

### 控制台 ###

> func Scan(a ...interface\{\}) (n int, err error)

Scan从标准输入扫描文本，将成功读取的**空白分隔的值保存进**成功传递给本函数的**参数**。**换行视为空白**。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少，会返回一个错误报告原因。

Scan的源代码

func Scan(a ...interface{}) (n int, err error) {
    	return Fscan(os.Stdin, a...)
    }

使用

var err error
    	//---------Scan-------------
    	var num int
    	var f float64
    	var str string
    	fmt.Println("请输入一个整数、一个浮点数和一个字符串：")
    	_,err = fmt.Scan(&num)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("整数:",num)
    	}
    	_,err = fmt.Scan(&f)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("浮点数:",f)
    	}
    	_, err = fmt.Scan(&str)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("字符串:",str)
    	}

结果

> 请输入一个整数、一个浮点数和一个字符串：  
> 9 9.9 lady\_killer9  
> 整数: 9  
> 浮点数: 9.9  
> 字符串: lady\_killer9

### 字符串 ###

> func Sscan(str string, a ...interface\{\}) (n int, err error)

Sscan从字符串str扫描文本，将成功读取的**空白分隔的值保存进**成功传递给本函数的**参数**。**换行视为空白**。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少，会返回一个错误报告原因。

Sscan源代码

func Sscan(str string, a ...interface{}) (n int, err error) {
    	return Fscan((*stringReader)(&str), a...)
    }

测试代码

strInput := "3 4.4 hello"
    	_, _ = fmt.Sscan(strInput,&num,&f,&str)
    	fmt.Println(num,f,str)

结果：

> 3 4.4 hello

如果字符串是固定的，清楚空格分隔的是什么，使用此函数做一个字符串的分隔也可以。

**注意：输入部分不再展示源代码（Scanxx、Sscanxx的，都是调用的FScanxx），可看文章最后的调用图，在Goland中，可以选中函数，Ctrl+B来查看源代码。**

## 有换行 ##

### 接口 ###

> func Fscanln(r io.Reader, a ...interface\{\}) (n int, err error)

Fscanln类似Fscan，但会在换行时才停止扫描。最后一个条目后必须有换行或者到达结束位置。

测试代码

fmt.Println("请输入一个字符串：")
    	_, _ = fmt.Fscanln(os.Stdin, &strInput)
    	fmt.Println("字符串：",strInput)

结果

> 请输入一个字符串：  
> lady\_killer9  
> 字符串： lady\_killer9

### 控制台 ###

> func Scanln(a ...interface\{\}) (n int, err error)

Scanln类似Scan，但会在换行时才停止扫描。最后一个条目后**必须有换行或者到达结束位置**。

测试代码

var num2,num3 int
    	fmt.Println("请输入两个整数：")
    	_,_ = fmt.Scanln(&num2,&num3)
    	fmt.Println(num2,num3)

结果

> 请输入两个整数：  
> 8 9  
> 8 9
> 
>

### 字符串 ###

> func Sscanln(str string, a ...interface\{\}) (n int, err error)

Sscanln类似Sscan，但会在换行时才停止扫描。最后一个条目后必须有换行或者到达结束位置。

newStr := ""
    	_, _ = fmt.Sscanln(strInput, &newStr)
    	fmt.Println("新字符串",newStr)

结果

> 新字符串 lady\_killer9
> 
>

## 有格式 ##

在谈函数之前，我们先看一看有哪些格式。go借鉴了C的风格，使用%形式，浮点数可以指明保留位数。

通用

%v	值的默认格式表示
    %+v	类似%v，但输出结构体时会添加字段名
    %#v	值的Go语法表示
    %T	值的类型的Go语法表示
    %%	百分号

结构体一般会有String方法，%+v也可以接受。

布尔值

%t	单词true或false

整数

%b	表示为二进制
    %c	该值对应的unicode码值
    %d	表示为十进制
    %o	表示为八进制
    %q	该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
    %x	表示为十六进制，使用a-f
    %X	表示为十六进制，使用A-F
    %U	表示为Unicode格式：U+1234，等价于"U+%04X"

浮点数与复数的两个组分：

%b	无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat
    %e	科学计数法，如-1234.456e+78
    %E	科学计数法，如-1234.456E+78
    %f	有小数部分但无指数部分，如123.456
    %F	等价于%f
    %g	根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
    %G	根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）

宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。精度通过（可选的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。举例如下：

%f: 默认宽度，默认精度
    %9f 宽度9，默认精度
    %.2f 默认宽度，精度2
    %9.2f 宽度9，精度2
    %9.f 宽度9，精度0

字符串和\[\]byte

%s	直接输出字符串或者[]byte
    %q	该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
    %x	每个字节用两字符十六进制数表示（使用a-f）
    %X	每个字节用两字符十六进制数表示（使用A-F）

指针

%p	表示为十六进制，并加上前导的0x

下面的就不一一写例子了，举一个控制台的吧

### 接口 ###

> func Fscanf(r io.Reader, format string, a ...interface\{\}) (n int, err error)

Fscanf从r扫描文本，根据format 参数指定的格式将成功读取的空白分隔的值保存进成功传递给本函数的参数。返回成功扫描的条目个数和遇到的任何错误。

### 控制台 ###

> func Scanf(format string, a ...interface\{\}) (n int, err error)

Scanf从标准输入扫描文本，根据format 参数指定的格式将成功读取的空白分隔的值保存进成功传递给本函数的参数。返回成功扫描的条目个数和遇到的任何错误。

var f1 float64
    	var f2 float64
    	fmt.Println("请输入普通浮点数和科学计数法表示的浮点数：")
    	_,_ = fmt.Scanf("%f %e", &f1,&f2)
    	fmt.Println(f1,f2)

结果

> 请输入普通浮点数和科学计数法表示的浮点数：  
> 12.3 123e-1  
> 12.3 12.3

### 字符串 ###

> func Sscanf(str string, format string, a ...interface\{\}) (n int, err error)

Sscanf从字符串str扫描文本，根据format 参数指定的格式将成功读取的空白分隔的值保存进成功传递给本函数的参数。返回成功扫描的条目个数和遇到的任何错误。

## 操作系统参数 ##

os.Args\[\]

下标为0的是exe路径，之后是输入的参数

**测试代码**

fmt.Println("第一个参数(exe路径):",os.Args[0])
    	fmt.Println("第二个参数:",os.Args[1])
    	fmt.Printf("参数类型:%T",os.Args[1])

结果

> E:\\Workspace\\Go\_workspace\\learn\_go\\src\\learninouput\\main>go run inoutput.go lady\_killer9  
> 第一个参数(exe路径): C:\\Users\\DELL\\AppData\\Local\\Temp\\go-build631438137\\b001\\exe\\inoutput.exe  
> 第二个参数: lady\_killer9  
> 参数类型:string

# 输出 #

## 无换行 ##

### 接口 ###

> func Fprint(w io.Writer, a ...interface\{\}) (n int, err error)

Fprint采用默认格式将其参数格式化并写入w。如果两个相邻的参数都不是字符串，会在它们的输出之间添加空格。返回写入的字节数和遇到的任何错误。

### 控制台 ###

> func Print(a ...interface\{\}) (n int, err error)

Print采用默认格式将其参数格式化并写入标准输出。如果两个相邻的参数都不是字符串，会在它们的输出之间添加空格。返回写入的字节数和遇到的任何错误。

Print源代码

func Print(a ...interface{}) (n int, err error) {
    	return Fprint(os.Stdout, a...)
    }

测试代码

fmt.Print(1,2,3)

结果和下面的放一起了

### 字符串 ###

> func Sprint(a ...interface\{\}) string

Sprint采用默认格式将其参数格式化，串联所有输出生成并**返回一个字符串**。**如果两个相邻的参数都不是字符串，会在它们的输出之间添加空格。**

测试代码

s := fmt.Sprint(1, 2, 3, "hello", "world")
    	fmt.Print(s)

结果

> 1 2 31 2 3helloworld

可以看到没有换行，使用Sprint时，相连的非字符串会加空格

**注意：字符串的没有调用接口，后序的也是，不再黏贴源代码。**

## 有换行 ##

### 控制台 ###

> func Println(a ...interface\{\}) (n int, err error)

Println采用默认格式将其参数格式化并写入标准输出。总是会在**相邻参数的输出之间添加空格**并在输出结束后**添加换行符**。返回写入的字节数和遇到的任何错误。

测试代码

fmt.Println(1,2,3)

结果

> 1 2 3

### 接口 ###

> func Fprintln(w io.Writer, a ...interface\{\}) (n int, err error)

Fprintln采用默认格式将其参数格式化并写入w。总是会在**相邻参数的输出之间添加空格**并在输出结束后**添加换行符**。返回写入的字节数和遇到的任何错误。

### 字符串 ###

> func Sprintln(a ...interface\{\}) string

Sprintln采用默认格式将其参数格式化，串联所有输出生成并返回一个字符串。总是会在**相邻参数的输出之间添加空格**并在输出结束后**添加换行符**。

## 有格式 ##

### 控制台 ###

> func Printf(format string, a ...interface\{\}) (n int, err error)

Printf根据format参数生成格式化的字符串并写入标准输出。返回写入的字节数和遇到的任何错误。

测试代码

fmt.Printf("%02d %c %.2f",1,97,45.6344)

结果

> 01 a 45.63

### 接口 ###

> func Fprintf(w io.Writer, format string, a ...interface\{\}) (n int, err error)

Fprintf根据format参数生成格式化的字符串并写入w。返回写入的字节数和遇到的任何错误。

### 字符串 ###

> func Sprintf(format string, a ...interface\{\}) string

Sprintf根据format参数生成格式化的字符串并返回该字符串。

### 返回错误对象 ###

> func Errorf(format string, a ...interface\{\}) error

这个在文章[Go-错误、异常处理详解][Go-]中再讲解。

有关文件的输入输出（即读写），可查看：[Go-文件目录操作分类详解（创建、打开、关闭、读取、写入、判断等）][Go- 1]

# fmt部分输入输出函数调用图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70][]

为防止图片过大，函数参数写的不全，部分函数没有给出使用例子，读者可自行尝试，有问题下方评论。

# oj的输入输出 #

使用牛客网：[OJ在线编程常见输入输出练习][OJ]

不定长的使用的Scanner，大家可以试试前面的接口或Reader等。

package main
    
    import (
    	"bufio"
    	"fmt"
    	"os"
    	"sort"
    	"strconv"
    	"strings"
    )
    //----------多组a,b----------
    func aB1(){
    	var a,b int
    	for{
    		_,err := fmt.Scan(&a,&b)
    		if err!=nil{
    			break
    		}else{
    			fmt.Println(a+b)
    		}
    	}
    }
    //--------t组a,b-----------
    func aB2()  {
    	var t int
    	var a,b int
    	_,_ = fmt.Scan(&t)
    	for i:=0;i<t;i++{
    		_,_ = fmt.Scan(&a,&b)
    		fmt.Println(a+b)
    	}
    }
    //--------0,0结束--------
    func aB3()  {
    	var a,b int
    	for{
    		_,_ = fmt.Scan(&a,&b)
    		if a==0 && b==0{
    			break
    		}
    		fmt.Println(a+b)
    	}
    }
    //---------多组, 长度为0结束-------------
    func aB4()  {
    	var n int
    	var a,sum int
    	for{
    		_,_ = fmt.Scan(&n)
    		if n==0{
    			break
    		}
    		sum = 0
    		for ;n>0;n--{
    			_,_ = fmt.Scan(&a)
    			sum += a
    		}
    		fmt.Println(sum)
    	}
    }
    //--------------t组，每组n个-----------
    func aB5()  {
    	var t,a,n,sum int
    	_,_ = fmt.Scan(&t)
    	for ;t>0;t--{
    		_,_ = fmt.Scan(&n)
    		sum = 0
    		for ;n>0;n--{
    			_,_ = fmt.Scan(&a)
    			sum += a
    		}
    		fmt.Println(sum)
    	}
    }
    //--------------不定组，长度为0结束-------
    func aB6()  {
    	var n int
    	var a,sum int
    	for{
    		_,err := fmt.Scan(&n)
    		if err != nil{
    			break
    		}
    		sum = 0
    		for ;n>0;n--{
    			_,_ = fmt.Scan(&a)
    			sum += a
    		}
    		fmt.Println(sum)
    	}
    }
    //-----------不定组，不定长-------------
    func aB7()  {
    	input := bufio.NewScanner(os.Stdin)
    	var sum int
    	for input.Scan(){
    		strs := strings.Split(input.Text()," ")
    		sum = 0
    		for _,n := range strs{
    			num,_ := strconv.Atoi(n)
    			sum += num
    		}
    		fmt.Println(sum)
    	}
    }
    //---------t个长字符串------------
    func strSort1(){
    	var t int
    	_,_ =fmt.Scan(&t)
    	input := bufio.NewScanner(os.Stdin)
    	input.Scan()
    	strs := strings.Split(input.Text()," ")
    	sort.Strings(strs)
    	n:=len(strs)
    	for i:=0;i<n;i++{
    		if i==n-1{
    			fmt.Print(strs[i])
    		}else{
    			fmt.Print(strs[i]," ")
    		}
    	}
    }
    //------------多组，不定长字符串，使用" "分隔-----------
    func strSort2()  {
    	input := bufio.NewScanner(os.Stdin)
    	var strs []string
    	var n int
    	for input.Scan(){
    		strs = strings.Split(input.Text()," ")
    		sort.Strings(strs)
    		n = len(strs)
    		for i:=0;i<n;i++{
    			fmt.Print(strs[i]," ")
    		}
    		fmt.Println()
    	}
    }
    //------------多组，不定长字符串,使用","分隔-----------
    func strSort3()  {
    	input := bufio.NewScanner(os.Stdin)
    	var strs []string
    	var n int
    	for input.Scan(){
    		strs = strings.Split(input.Text(),",")
    		sort.Strings(strs)
    		n = len(strs)
    		for i:=0;i<n;i++{
    			if i==n-1{
    				fmt.Print(strs[i])
    			}else{
    				fmt.Print(strs[i],",")
    			}
    		}
    		fmt.Println()
    	}
    }
    
    
    func main() {
    	//-----A+B(1)--------
    	aB1()
    	//----A+B(2)---------
    	aB2()
    	//
    	aB3()
    	aB4()
    	aB5()
    	aB6()
    	aB7()
    	strSort1()
    	strSort2()
    	strSort3()
    }

# 全部代码 #

package main
    
    import (
    	"fmt"
    	"os"
    )
    
    func main() {
    	//---------------------输入-------------------------
    	var err error
    	//--------Fscan------------
    	var number int
    	fmt.Println("请输入一个整数：")
    	_, err = fmt.Fscan(os.Stdin, &number)
    	if err != nil{
    		fmt.Println(err)
    	}
    	fmt.Println("整数：",number)
    	---------Scan-------------
    	var num int
    	var f float64
    	var str string
    	fmt.Println("请输入一个整数、一个浮点数和一个字符串：")
    	_,err = fmt.Scan(&num)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("整数:",num)
    	}
    	_,err = fmt.Scan(&f)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("浮点数:",f)
    	}
    	_, err = fmt.Scan(&str)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("字符串:",str)
    	}
    	//----------Sscan----------
    	strInput := "3 4.4 hello"
    	_, _ = fmt.Sscan(strInput,&num,&f,&str)
    	fmt.Println(num,f,str)
    	//---------Fscanln----------
    	fmt.Println("请输入一个字符串：")
    	_, _ = fmt.Fscanln(os.Stdin, &strInput)
    	fmt.Println("字符串：",strInput)
    
    	//---------Scanln-----------
    	var num2,num3 int
    	fmt.Println("请输入两个整数：")
    	_,_ = fmt.Scanln(&num2,&num3)
    	fmt.Println(num2,num3)
    	// ----------Sscanln-------
    	newStr := ""
    	_, _ = fmt.Sscanln(strInput, &newStr)
    	fmt.Println("新字符串",newStr)
    	//---------Scanf------------
    	var f1 float64
    	var f2 float64
    	fmt.Println("请输入普通浮点数和科学计数法表示的浮点数：")
    	_,_ = fmt.Scanf("%f %e", &f1,&f2)
    	fmt.Println(f1,f2)
    	//----------os.Args------------
    	fmt.Println("第一个参数(exe路径):",os.Args[0])
    	fmt.Println("第二个参数:",os.Args[1])
    	fmt.Printf("参数类型:%T",os.Args[1])
    	//---------------------输出-------------------------
    	//---------Print--------------
    	fmt.Print(1,2,3)
    	//---------Sprint-------------
    	s := fmt.Sprint(1, 2, 3, "hello", "world")
    	fmt.Print(s)
    	//---------Println------------
    	fmt.Println(1,2,3)
    	//---------Printf-------------
    	fmt.Printf("%02d %c %.2f",1,97,45.6344)
    }

# 参考 #

[Go-标准库fmt][Go-_fmt]

[Go-标准库os][Go-_os]

[Go-标准库bufio][Go-_bufio]

更多Go相关内容：[Go-Golang学习总结笔记][Go-Golang]

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。如果您感觉有所收获，自愿打赏，可选择支付宝18833895206（小于），您的支持是我不断更新的动力。

[Go-]: https://blog.csdn.net/lady_killer9/article/details/115768077
[Go- 1]: https://blog.csdn.net/lady_killer9/article/details/116454527
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHlfa2lsbGVyOQ_size_16_color_FFFFFF_t_70]: /images/20221014/8f597bd47b8d453c848037bd8be61777.png
[OJ]: https://www.nowcoder.com/test/27976983/summary
[Go-_fmt]: https://studygolang.com/static/pkgdoc/pkg/fmt.htm
[Go-_os]: https://studygolang.com/static/pkgdoc/pkg/os.htm
[Go-_bufio]: https://studygolang.com/static/pkgdoc/pkg/bufio.htm
[Go-Golang]: https://blog.csdn.net/lady_killer9/article/details/115491317