Please enable JavaScript.

Coggle requires JavaScript to display documents.

go标准库：IO (io：基本的IO接口 ((实现了io.Reader、 io.Writer接口的类型 (os.File同时实现了io…

- - - - 定义：
        type Seeker interface { Seek(offset int64, whence int) (ret int64, err error) }
      - 说明：
        
        Seek用于设置偏移量
        
        第一个参数offset为偏移量值，whence用来指定偏移量的位置：
        
        0：表示偏移量相对于其起始处
        
        1：表示偏移量相对于当前的偏移
        
        2：表示相对于其结尾处
        
        Seek会返回新的偏移量(偏移后的)，并且返回任何遇到的错误
      - 示例代码：
        reader := strings.NewReader("golang") reader.Seek(-6, io.SeekEnd) r, _, _ := reader.ReadRune() fmt.Printf("%c\n", r)
        // 输出：
        g
        // 分析：
        这里Seek方法给reader设置了一个读取的偏移量：从数据流末尾开始，读取倒数第6个字符。
    - - ReaderFrom
        
        定义：
        type ReaderFrom interface{ ReadFrom(r Reader) (n int64, err error) }
        
        说明：
        
        ReadFrom从r中读取数据，一直到EOF或发生错误。
        
        返回读取的字节数n 。同时除了io.EOF外，读取过程中遇到的任何错误都会返回。
        
        ReadForm方法不会返回err == EOF
        
        示例代码：
        file, err := os.Open("writeAt.txt") if err != nil { panic(err) } defer file.Colse() writer := bufio.NewWriter(os.Stdout) writer.ReadFrom(file) writer.Flush()
        // 分析：
        使用ReadFrom从一个文件中读取内容，写入标准输出流(io.Stdout)中；
        可以使用ioutil包中的ReadFile函数获取文件的全部内容，其实ReadFile函数也是通过ReadForm实现的(用的是bytes.Buffer实现了ReaderFrom接口)。
      - WriterTo
        
        定义：
        type WriterTo interface { WriteTo(w Writer) (n int64, err error) }
        
        说明：
        
        WriteTo将数据写入w中，直到没有数据可写或者发生错误；
        
        返回写入的字节数n，遇到的任何错误也将同时被返回；
        
        代码示例：
        reader := bytes.NewReader([]byte("golang")) reader.WriteTo(os.Stdout)
        // 分析：
        将一段文本写入到标准输出。
    - - ReaderAt
        
        定义：
        type ReaderAt interface{ ReadAt(p []byte, off int64) (n int. err error) }
        
        说明：
        
        ReadAt方法可以从指定的偏移量off处开始读取len(p)个字节到p中；
        
        返回读取的字节数n( 0<=n<=len(p) )，并且同时返回遇到的任何错误；
        
        当ReadAt返回的字节数n小于len(p)时，就会同时返回一个非nil的错误解释为什么没有返回更多的字节。(比Read更严格)。
        
        若指定流中可读取的数据不到len(p)个字节，ReadAt就会阻塞，直到所有数据都可用或者一个错误发生。（这和Read不同）
        
        可对相同的输入源并行执行ReadAt调用。
        
        示例代码：
        reader := strings.NewReader("golang") p :=make([]byte, 4) n ,err := reader.ReadAt(p ,2) if err != nil{ panic(err) } fmt.Printf("%s, %d\n",p ,n)
        // 输出：
        lang, 4
      - WriterAt
        
        定义：
        type WriterAt interface{ WriteAt(p []byte, off int64) (n int, err error) }
        
        说明：
        
        WriteAt从p中将len(p)个字节从偏移量off处开始写入基本数据流中；
        
        返回写入到p中的字节数n( 0<=n<=len(p) )，同时返回任何引起写入(提前)停止的错误；
        
        若WriteAt返回的n<len(p)，它就必须返回一个非nil的错误，解释原因；
        
        若被写入的区域没有重叠(也就是多个写入同一数据流的区域不重叠)，可以并行执行WriteAt调用；
        
        示例代码：
        file, err := os.Create("writeAt.txt") if err != nil { panic(err) } defer file.Close() file.WriteString("golang-gogo") n, err := file.WriteAt([]byte("good"),7) if err != nil { panic(err) } fmt.Println(n) b, err := ioutil.ReadFile("writeAt.txt") if err != nil { panic(err) } str := string(b) fmt.Println(str)
        // 输出：
        4 golang-good
        // 分析：
        首先我们创建了一个文件，给文件写入了“golang-gogo”这个字符串，然后我们调用了WriteAt方法在偏移量7之后写入了一个字符串“good”，7这个位置就是“-”这个字符，写入的good是四个字符，正好将原字符的gogo覆盖掉了。
    - - os.File同时实现了io.Reader和io.Writer接口
        
        bytes.Buffer同时实现了io.Reader和io.Writer接口
        
        crypto/tls.Conn同时实现了io.Reader和io.Writer接口
      - strings.Reader实现了io.Reader接口
        
        bytes.Reader实现了io.Reader接口
        
        mime/multioart.Part实现了io.Reader接口
      - bufio.Reader/Writer分别实现了io.Reader和io.Writer接口
        
        compress/gzip.Reader/Writer分别实现了io.Reader和io.Writer接口
        
        crypto/cipher.StreamReader/StreamWriter分别实现了io.Reader和io.Writer接口
        
        encoding/csv.Reader/Writer分别实现了io.Reader和io.Writer接口
        
        net/conn分别实现了io.Reader和io.Writer接口
      - io包本身实现这两个接口的类型：
        
        LimitedReader、PipeReader、SectionReader实现了Reader接口
        
        PipeWriter实现了Writer接口
    - - 定义：
        type Writer interface{ Write(p []byte) (n int, err error) }
      - 说明：
        
        Write方法将len(p)个字节从p写入到基本数据流中；
        
        返回从p中写入到基本数据流的字节数n( 0<=n<=len(p) )
        
        如果Write方法返回的n<len(p) ，那么它必须返回一个非nil的错误；因为数据没有完全写完。
      - 举例：
        // 同样只要实现了Write方法的类型，默认都实现了io.Writer接口，可以将数据流写入实现该方法的类型中。
        func Println(a ...interface{}) (n int, err error){ return Fprintln(os.Stdout, a...) }
        io.Writer的扩展阅读
    - - 定义：
        type Reader interface{ Read(p []byte) (n int, err error) }
      - 说明：
        
        Read方法将len(p)个长度字节数据读取到字节数组p中；
        
        返回读取到的字节数n；
        
        如果读取的数据不到len(p)个字节(也就是byte数组容量有点大了)，Read方法会返回读取到的数据，不会等待更多数据将byte数组填满。
        
        Read方法成功读到了数据(n>0)后遇到了一个错误或者EOF(end-of-file)，它会把当前读取到的数据返回，同时返回一个错误，或者在下一次调用中直接返回这个错误(这时的n=0)。
      - 举例：
        // 任何实现了Read方法的类型，都可以使用io.Reader
        func ReadFrom(reader io.Reader, num int) ([]byte, error){ p := make([]byte, num) n, err := reader.Read(p) if n > 0 { return p[:n], nil } return p, err }
        // ReadFrom方法接收一个io.Reader参数，所以我们可以读取任何数据(前提是该数据类型实现了Read方法)：
        // 从标准输入读取 data, err = ReadForm(os.Stdin, 11) // 从普通文件读取(file是os.file的实例，也就是实现了Read方法) data, err = ReadFrom(file, 9) // 从字符串读取 data, err = ReadFrom(string.NewReader("from string"), 12)
      - 注意：
        io.EOF的定义为：var EOF = errors.New("EOF")
        在读取到数据(n>0)并且数据读取完的情况下，当次返回的error有可能是EOF也有可能是nil。
        所以读取末尾的数据使用EOF判断可能不准(有误需求证)
    - - 定义：
        type Closer interface { Close() error }
      - 说明：
        
        Close方法用于关闭数据流
        
        需要手动关闭资源的几个类型都实现了Closer接口：
        
        os.File (文件)
        
        gzip (压缩包)
        
        数据库连接
        
        Socket
        
        等等......