go语言——输入输出
go语言——输入输出
输出
import "fmt"
fmt.Print() //输出没有换行
fmt.Println() //输出后换行
fmt.Printf() //格式化输出
格式化打印占位符
%v 原样输出
%T 打印类型
%t bool类型
%s 字符串
%f 浮点
%d 10进制
%o 8进制
%x 16进制 0-9 a-f
%X 16进制 0-9 A-F
%b 二进制数
%c 打印字符
%p 打印地址
输入
import "fmt"
var x int
var y float64
fmt.Scanln(&x) //阻塞式的输入，Scanln只会接受一个回车
fmt.Scanf("%d,%f",&x,&y) //格式化输入，中间需要输入""中的符号
fmt.Scan(&x) //从终端获取输入，存储在Scanln中的参数里，空格和换行符作为分隔符
import "bufio"
func main() {
fmt.Println("请输入一个字符串：")
reader := bufio.NewReader(os.Stdin)
s1, _ := reader.ReadString('\n')
fmt.Println("读到的数据：", s1)
}
bufio包
package main
import (
"bufio"
"fmt"
"strings"
"bytes"
"io"
)
// bufio 包实现了带缓存的 I/O 操作
/**
* 首先看reader和writer基本的结构
* // Reader implements buffering for an io.Reader object.
* type Reader struct {
* buf []byte
* rd io.Reader // reader provided by the client
* r, w int // buf read and write positions
* err error
* lastByte int
* lastRuneSize int
* }
*
*
* // Writer implements buffering for an io.Writer object.
* // If an error occurs writing to a Writer, no more data will be
* // accepted and all subsequent writes will return the error.
* // After all data has been written, the client should call the
* // Flush method to guarantee all data has been forwarded to
* // the underlying io.Writer.
* type Writer struct {
* err error
* buf []byte
* n int
* wr io.Writer
* }
*
*
*
* // ReadWriter 集成了 bufio.Reader 和 bufio.Writer, 实现了 io.ReadWriter 接口
* type ReadWriter struct {
* *Reader
* *Writer
* }
*/
func main() {
// 1: 使用bufio.NewReader构造一个reader
inputReadBuf := strings.NewReader("1234567890")
reader := bufio.NewReader(inputReadBuf)
// 2: 使用bufio.NewWriter构造一个writer
buf := bytes.NewBuffer(make([]byte, 0))
writer := bufio.NewWriter(buf)
// 3: 函数Peek函数: 返回缓存的一个Slice(引用,不是拷贝)，引用缓存中前n字节数据
// > 如果引用的数据长度小于 n，则返回一个错误信息
// > 如果 n 大于缓存的总大小，则返回 ErrBufferFull
// 通过Peek的返回值，可以修改缓存中的数据, 但不能修改底层io.Reader中的数据
b, err := reader.Peek(5)
if err != nil {
fmt.Printf("Read data error")
return
}
// 修改第一个字符
b[0] = 'A'
// 重新读取
b, _ = reader.Peek(5)
writer.Write(b)
writer.Flush()
fmt.Println("buf(Changed): ", buf, "\ninputReadBuf(Not Changed): ", inputReadBuf)
// 4: Read函数, 每次读取一定量的数据, 这个由buf大小觉得, 所以我们可以循环读取数据, 直到Read返回0说明读取数据结束
for {
b1 := make([]byte, 3)
n1, _ := reader.Read(b1)
if n1 <= 0 {
break
}
fmt.Println(n1, string(b1))
}
// 5: ReadByte和UnreadByte函数
// ReadByte 从 b 中读出一个字节并返回, 如果 b 中无可读数据，则返回一个错误
// UnreadByte 撤消最后一次读出的字节, 只有最后读出的字节可以被撤消, 无论任何操作，只要有内容被读出，就可以用 UnreadByte 撤消一个字节
inputReadBuf2 := strings.NewReader("1234567890")
reader2 := bufio.NewReader(inputReadBuf2)
// 读一个字节
b2, _ := reader2.ReadByte()
fmt.Println(string(b2))
// Unread一个字节
reader2.UnreadByte()
b2, _ = reader2.ReadByte()
fmt.Println(string(b2))
// 6: ReadRune和UnreadRune函数, 类似上面两个函数
// ReadRune读出一个 UTF8 编码的字符并返回编码长度, 如果UTF8序列无法解码出一个正确的Unicode字符, 则只读出b中的一个字节，size 返回 1
inputReadBuf3 := strings.NewReader("中文1234567890")
reader3 := bufio.NewReader(inputReadBuf3)
b3, size, _ := reader3.ReadRune()
fmt.Println(string(b3), size)
reader3.UnreadRune()
b3, size, _ = reader3.ReadRune()
fmt.Println(string(b3), size)
// 执行UnreadRune时候, 如果之前一步不是ReadRune, 那么会报错, 看下面
b33, _ := reader3.ReadByte()
fmt.Println(string(b33))
err3 := reader3.UnreadRune()
if err3 != nil {
fmt.Println("ERR")
}
// 7: 读取缓冲区中数据字节数(只有执行读才会使用到缓冲区, 否则是没有的)
inputReadBuf4 := strings.NewReader("中文1234567890")
reader4 := bufio.NewReader(inputReadBuf4)
// 下面返回0, 因为还没有开始读取, 缓冲区没有数据
fmt.Println(reader4.Buffered())
// 下面返回strings的整体长度16(一个人中文是3长度)
reader4.Peek(1)
fmt.Println(reader4.Buffered())
// 下面返回15, 因为readByte已经读取一个字节数据, 所以缓冲区还有15字节
reader4.ReadByte()
fmt.Println(reader4.Buffered())
// 下面的特别有意思: 上面已经读取了一个字节, 想当于是将"中"读取了1/3, 那么如果现在使用readRune读取, 那么
// 由于无法解析, 那么仅仅读取一个byte, 所以下面的结果很显然
// 第一次: 无法解析, 那么返回一个byte, 所以输出的是14
reader4.ReadRune()
fmt.Println(reader4.Buffered())
// 第二次读取, 还剩下"中"最后一个字节, 所以也会err, 所以输出13
reader4.ReadRune()
fmt.Println(reader4.Buffered())
// 现在"中"读完了, 那么开始完整读取"文", 这个OK的, 可以解析的, 所以可以读取三字节, 那么剩下10字节
reader4.ReadRune()
fmt.Println(reader4.Buffered())
// 8: ReadSlice查找 delim 并返回 delim 及其之前的所有数据的切片, 该操作会读出数据，返回的切片是已读出数据的"引用"
// 如果 ReadSlice 在找到 delim 之前遇到错误, 则读出缓存中的所有数据并返回，同时返回遇到error（通常是 io.EOF）
// 如果 在整个缓存中都找不到 delim，则返回 ErrBufferFull
// 如果 ReadSlice 能找到 delim，则返回 nil
// 注意: 因为返回的Slice数据有可能被下一次读写操作修改, 因此大多数操作应该使用 ReadBytes 或 ReadString，它们返回数据copy
// 不推荐!
inputReadBuf5 := strings.NewReader("中文123 4567 890")
reader5 := bufio.NewReader(inputReadBuf5)
for ; ; {
b5 , err := reader5.ReadSlice(' ')
fmt.Println(string(b5))
// 读到最后
if err == io.EOF {
break
}
}
// 9: ReadLine 是一个低级的原始的行读取操作, 一般应该使用 ReadBytes('\n') 或 ReadString('\n')
// ReadLine 通过调用 ReadSlice 方法实现，返回的也是"引用", 回一行数据，不包括行尾标记（\n 或 \r\n）
// 如果 在缓存中找不到行尾标记，设置 isPrefix 为 true，表示查找未完成
// 如果 在当前缓存中找到行尾标记，将 isPrefix 设置为 false，表示查找完成
// 如果 ReadLine 无法获取任何数据，则返回一个错误信息（通常是 io.EOF）
// 不推荐!
inputReadBuf6 := strings.NewReader("中文123\n4567\n890")
reader6 := bufio.NewReader(inputReadBuf6)
for ; ; {
l, p, err := reader6.ReadLine()
fmt.Println(string(l), p, err)
if err == io.EOF {
break
}
}
// 10: ReadBytes查找 delim 并读出 delim 及其之前的所有数据
// 如果 ReadBytes 在找到 delim 之前遇到错误, 则返回遇到错误之前的所有数据，同时返回遇到的错误（通常是 io.EOF）
// 如果 ReadBytes 找不到 delim 时，err != nil
// 返回的是数据的copy, 不是引用
inputReadBuf7 := strings.NewReader("中文123;4567;890")
reader7 := bufio.NewReader(inputReadBuf7)
for ; ; {
line, err := reader7.ReadBytes(';')
fmt.Println(string(line))
if err != nil {
break
}
}
// 11: ReadString返回的是字符串, 不是bytes
inputReadBuf8 := strings.NewReader("中文123;4567;890")
reader8 := bufio.NewReader(inputReadBuf8)
for ; ; {
line, err := reader8.ReadString(';')
fmt.Println(line)
if err != nil {
break
}
}
//12: Flush函数用于提交数据, 立即更新
// Available函数返回缓存中的可以空间
// b10是保存数据的数组, 不是writer的缓冲区, 别搞错了
b10 := bytes.NewBuffer(make([]byte, 30))
// 下面会分配4096字节空间缓冲区
writer10 := bufio.NewWriter(b10)
writer10.WriteString("1234567890")
// 此时没有flush, 那么输出的是"", 但是缓冲区使用了10个字节, 那么剩下4086, Buffered()返回的是缓冲区还没有提交的数据, 此处显然是10
fmt.Println(writer10.Available(), writer10.Buffered(), b10)
// 下面flush后, 将缓冲区的数据全部写入b10中, 缓冲区被清空, 所以缓冲区变成4096, Buffered()返回的是0, 说明数据被写入
writer10.Flush()
fmt.Println(writer10.Available(), writer10.Buffered(), b10)
// 13: WriteString(...), Write(...), WriteByte(...), WriteRune(...)函数
// 都是写数据函数
b11 := bytes.NewBuffer(make([]byte, 1024))
writer11 := bufio.NewWriter(b11)
writer11.WriteString("ABC")
writer11.WriteByte(byte('M'))
// Rune的意思是: 代表一个字符, 那么需要一次一个字符写入
writer11.WriteRune(rune('好'))
writer11.WriteRune(rune('么'))
writer11.Write([]byte("1234567890"))
writer11.Flush()
fmt.Println(b11)
// 14: WriteTo函数
inputReadBuf9 := strings.NewReader("中文1234567890")
reader9 := bufio.NewReader(inputReadBuf9)
b9 := bytes.NewBuffer(make([]byte, 0))
reader9.WriteTo(b9)
fmt.Println(b9)
// 15: ReadFrom函数
inputReadBuf15 := strings.NewReader("率哪来的顺丰内部了第三方吧")
b15 := bytes.NewBuffer(make([]byte, 0))
writer15 := bufio.NewWriter(b15)
writer15.ReadFrom(inputReadBuf15)
fmt.Println(b15)
}```
