非常教程

Go参考手册

io

io

  • import "io"
  • 概况
  • 索引
  • 示例
  • 子目录

概况

Package io 为 I/O 原语提供基本接口。它的主要工作是将这些原语的现有实现(例如包 os 中的那些原语)包装到抽象功能的共享公共接口中,以及一些其他相关原语中。

因为这些接口和原语用各种实现包装较低级别的操作,除非另有通知的客户端不应该认为它们对于并行执行是安全的。

索引

  • 常量
  • 变量
  • func Copy(dst Writer, src Reader) (written int64, err error)
  • func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)
  • func CopyN(dst Writer, src Reader, n int64) (written int64, err error)
  • func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)
  • func ReadFull(r Reader, buf []byte) (n int, err error)
  • func WriteString(w Writer, s string) (n int, err error)
  • type ByteReader
  • type ByteScanner
  • type ByteWriter
  • type Closer
  • type LimitedReader
  • func (l *LimitedReader) Read(p []byte) (n int, err error)
  • type PipeReader
  • func Pipe() (*PipeReader, *PipeWriter)
  • func (r *PipeReader) Close() error
  • func (r *PipeReader) CloseWithError(err error) error
  • func (r *PipeReader) Read(data []byte) (n int, err error)
  • type PipeWriter
  • func (w *PipeWriter) Close() error
  • func (w *PipeWriter) CloseWithError(err error) error
  • func (w *PipeWriter) Write(data []byte) (n int, err error)
  • type ReadCloser
  • type ReadSeeker
  • type ReadWriteCloser
  • type ReadWriteSeeker
  • type ReadWriter
  • type Reader
  • func LimitReader(r Reader, n int64) Reader
  • func MultiReader(readers ...Reader) Reader
  • func TeeReader(r Reader, w Writer) Reader
  • type ReaderAt
  • type ReaderFrom
  • type RuneReader
  • type RuneScanner
  • type SectionReader
  • func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader
  • func (s *SectionReader) Read(p []byte) (n int, err error)
  • func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error)
  • func (s *SectionReader) Seek(offset int64, whence int) (int64, error)
  • func (s *SectionReader) Size() int64
  • type Seeker
  • type WriteCloser
  • type WriteSeeker
  • type Writer
  • func MultiWriter(writers ...Writer) Writer
  • type WriterAt
  • type WriterTo

示例

Copy

CopyBuffer

CopyN

LimitReader

MultiReader

MultiWriter

ReadAtLeast

ReadFull

SectionReader

SectionReader.ReadAt

SectionReader.Seek

TeeReader

WriteString

包文件

io.go multi.go pipe.go

常量

寻求哪些值。

const (
        SeekStart   = 0 // 寻找相对于文件的起源
        SeekCurrent = 1 // 寻找相对于当前的偏移量
        SeekEnd     = 2 // 寻求相对于目的
)

变量

当没有更多输入可用时,EOF 是由 Read 返回的错误。函数只能返回 EOF 来表示输入的正常结束。如果 EOF 在结构化数据流中意外发生,则适当的错误是 ErrUnexpectedEOF 或其他一些错误,以提供更多详细信息。

var EOF = errors.New("EOF")

ErrClosedPipe 是用于在关闭的管道上进行读取或写入操作的错误。

var ErrClosedPipe = errors.New("io: read/write on closed pipe")

ErrNoProgress 是由一些 io.Reader 的客户端在许多 Read 的调用未能返回任何数据或错误(通常是破坏的 io.Reader 实现的标志)失败时返回的。

var ErrNoProgress = errors.New("multiple Read calls return no data or error")

ErrShortBuffer 意味着读取需要比提供的更长的缓冲区。

var ErrShortBuffer = errors.New("short buffer")

ErrShortWrite 意味着写入接受的字节数少于请求的数量,但未能返回明确的错误。

var ErrShortWrite = errors.New("short write")

ErrUnexpectedEOF 表示在读取固定大小块或数据结构的过程中遇到 EOF 。

var ErrUnexpectedEOF = errors.New("unexpected EOF")

func Copy(显示源代码)

func Copy(dst Writer, src Reader) (written int64, err error)

将副本从 src 复制到 dst ,直到在 src 上达到 EOF 或发生错误。它返回复制的字节数和复制时遇到的第一个错误(如果有的话)。

成功的复制返回err == nil,而不是err == EOF。由于 Copy 定义为从 src 读取直到 EOF,因此它不会将 Read 中的 EOF 视为要报告的错误。

如果 src 实现 WriterTo 接口,则通过调用 src.WriteTo(dst)来实现副本。否则,如果 dst 实现 ReaderFrom 接口,则通过调用 dst.ReadFrom(src)来实现副本。

示例

package main

import (
	"io"
	"log"
	"os"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")

	if _, err := io.Copy(os.Stdout, r); err != nil {
		log.Fatal(err)
	}

}

func CopyBuffer(显示源代码)

func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)

CopyBuffer 与 Copy 相同,只是它通过提供的缓冲区(如果需要的话)进行分级,而不是分配临时的缓冲区。如果 buf 为零,则分配一个;否则如果它的长度为零,CopyBuffer 会发生混乱。

示例

package main

import (
	"io"
	"log"
	"os"
	"strings"
)

func main() {
	r1 := strings.NewReader("first reader\n")
	r2 := strings.NewReader("second reader\n")
	buf := make([]byte, 8)

	// 在这里使用buf ...
	if _, err := io.CopyBuffer(os.Stdout, r1, buf); err != nil {
		log.Fatal(err)
	}

	// ...也在这里重复使用。 无需分配额外的缓冲区。
	if _, err := io.CopyBuffer(os.Stdout, r2, buf); err != nil {
		log.Fatal(err)
	}

}

func CopyN(显示源代码)

func CopyN(dst Writer, src Reader, n int64) (written int64, err error)

CopyN 拷贝从 src 到 dst 的 n 个字节(或直出现一个错误)。它返回拷贝的字节数和复制时遇到的最早的错误。返回时,written == n 当且仅当 err == nil 。

如果 dst 实现 ReaderFrom 接口,则使用它实现副本。

示例

package main

import (
	"io"
	"log"
	"os"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read")

	if _, err := io.CopyN(os.Stdout, r, 5); err != nil {
		log.Fatal(err)
	}

}

func ReadAtLeast(显示源代码)

func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)

ReadAtLeast 从 r 读入 buf,直到它读取至少最小字节。它返回复制的字节数,如果读取的字节更少,则返回错误。只有在没有字节被读取的情况下,错误才是 EOF 。如果在读取少于最小字节数后发生 EOF,则 ReadAtLeast 返回 ErrUnexpectedEOF 。如果 min 大于 buf 的长度,则 ReadAtLeast 返回 ErrShortBuffer。返回时,n> = min 当且仅当 err == nil 。

示例

package main

import (
	"fmt"
	"io"
	"log"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")

	buf := make([]byte, 33)
	if _, err := io.ReadAtLeast(r, buf, 4); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s\n", buf)

	// 缓冲区小于最小读取大小。
	shortBuf := make([]byte, 3)
	if _, err := io.ReadAtLeast(r, shortBuf, 4); err != nil {
		fmt.Println("error:", err)
	}

	// 最小读取大小比io.Reader流大
	longBuf := make([]byte, 64)
	if _, err := io.ReadAtLeast(r, longBuf, 64); err != nil {
		fmt.Println("error:", err)
	}

}

func ReadFull(显示源代码)

func ReadFull(r Reader, buf []byte) (n int, err error)

ReadFull 完全读取从 r 到 buf 的 len(buf) 个字节。它返回复制的字节数,如果读取的字节更少,则返回错误。只有在没有字节被读取的情况下,错误才是 EOF 。如果在读取一些但不是全部字节后发生 EOF,则 ReadFull 将返回 ErrUnexpectedEOF 。返回时,n == len(buf) 当且仅当 err == nil 。

示例

package main

import (
	"fmt"
	"io"
	"log"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")

	buf := make([]byte, 4)
	if _, err := io.ReadFull(r, buf); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s\n", buf)

	// 最小读取大小比io.Reader流大
	longBuf := make([]byte, 64)
	if _, err := io.ReadFull(r, longBuf); err != nil {
		fmt.Println("error:", err)
	}

}

func WriteString(显示源代码)

func WriteString(w Writer, s string) (n int, err error)

WriteString 将字符串 s 的内容写入 w,它接受一个字节片段。如果 w 实现 WriteString 方法,则直接调用它。否则,w.Write 只会被调用一次。

示例

package main

import (
	"io"
	"os"
)

func main() {
	io.WriteString(os.Stdout, "Hello World")

}

type ByteReader(显示源代码)

ByteReader 是包装 ReadByte 方法的接口。

ReadByte 读取并返回输入中的下一个字节或遇到的任何错误。如果 ReadByte 返回错误,则不消耗输入字节,并且返回的字节值未定义。

type ByteReader interface {
        ReadByte() (byte, error)
}

type ByteScanner(显示源代码)

ByteScanner 是将 UnreadByte 方法添加到基本 ReadByte 方法的接口。

UnreadByte 导致下一次对 ReadByte 的调用返回与先前对 ReadByte 的调用相同的字节。在没有对 ReadByte 的中间调用的情况下调用 UnreadByte 两次可能是错误的。

type ByteScanner interface {
        ByteReader
        UnreadByte() error
}

type ByteWriter(显示源代码)

ByteWriter 是包装 WriteByte 方法的接口。

type ByteWriter interface {
        WriteByte(c byte) error
}

type Closer(显示源代码)

Closer 是包装基本 Close 方法的接口。

第一次调用后 Close 的行为是未定义的。具体实现可以记录他们自己的行为。

type Closer interface {
        Close() error
}

type LimitedReader(显示源代码)

LimitedReader 从 R 中读取数据,但将数据量限制为仅返回 N 个字节。每次读取更新 N 将反映新的剩余金额。当 N <= 0 或当基础 R 返回 EOF 时,读取返回 EOF 。

type LimitedReader struct {
        R Reader // 底层阅读器
        N int64  // 剩余最大字节数
}

func (*LimitedReader) Read(显示源代码)

func (l *LimitedReader) Read(p []byte) (n int, err error)

type PipeReader(显示源代码)

PipeReader 是pipe的二分之一read。

type PipeReader struct {
        // 包含已过滤或未导出的字段
}

func Pipe(显示源代码)

func Pipe() (*PipeReader, *PipeWriter)

Pipe 创建一个同步内存管道。它可以用来连接代码期望一个 io.Reader 与代码期待一个 io.Writer 。

读取和写入管道是一对一匹配的,除非需要多个读取消耗单个写入。也就是说,对 PipeWriter 的每次写入都会阻塞,直到它满足 PipeReader 中完全使用写入数据的一个或多个读取。数据直接从写入复制到相应的 Read(或 Reads); 没有内部缓冲。

相互并行或使用 Close 并行调用 Read 和 Write 是安全的。并行调用读取和并行调用写入也是安全的:个别调用将按顺序进行门控。

func (*PipeReader) Close(显示源代码)

func (r *PipeReader) Close() error

Close 关闭阅读器;随后写入管道的写入一半将返回错误 ErrClosedPipe 。

func (*PipeReader) CloseWithError(显示源代码)

func (r *PipeReader) CloseWithError(err error) error

CloseWithError 关闭阅读器;随后写入管道的写入一半将返回错误 err 。

func (*PipeReader) Read(显示源代码)

func (r *PipeReader) Read(data []byte) (n int, err error)

Read 实现标准的 Read 接口:它从管道读取数据,阻塞直到写入者到达或写入结束被关闭。如果写入结束时出现错误,则该错误返回为错误;否则 err 是 EOF 。

type PipeWriter(显示源代码)

PipeWriter 是写入一半的管道。

type PipeWriter struct {
        // 包含已过滤或未导出的字段
}

func (*PipeWriter) Close(显示源代码)

func (w *PipeWriter) Close() error

Close 关闭写入者;后续读取管道的一半将不返回字节和 EOF 。

func (*PipeWriter) CloseWithError(显示源代码)

func (w *PipeWriter) CloseWithError(err error) error

CloseWithError 关闭写入者;从管道的读取一半的后续读取将返回没有字节和 error 错误,或如果错误为零则为 EOF 。

CloseWithError 总是返回 nil 。

func (*PipeWriter) Write(显示源代码)

func (w *PipeWriter) Write(data []byte) (n int, err error)

Write 实现了标准的 Write 接口:它将数据写入管道,阻塞直到一个或多个读取器消耗完所有数据或读取端关闭。如果读取结束时出现错误,则该错误返回为 err ; 否则 err 是 ErrClosedPipe 。

type ReadCloser(显示源代码)

ReadCloser 是分组基本的 Read 和 Close 方法的接口。

type ReadCloser interface {
        Reader
        Closer
}

type ReadSeeker(显示源代码)

ReadSeeker 是将基本的 Read 和 Seek 方法分组的接口。

type ReadSeeker interface {
        Reader
        Seeker
}

type ReadWriteCloser(显示源代码)

ReadWriteCloser 是对基本的 Read,Write 和 Close 方法进行分组的接口。

type ReadWriteCloser interface {
        Reader
        Writer
        Closer
}

type ReadWriteSeeker(显示源代码)

ReadWriteSeeker 是将基本的 Read,Write 和 Seek 方法分组的接口。

type ReadWriteSeeker interface {
        Reader
        Writer
        Seeker
}

type ReadWriter(显示源代码)

ReadWriter 是分组基本读写方法的接口。

type ReadWriter interface {
        Reader
        Writer
}

type Reader(显示源代码)

Reader 是包装基本 Read 方法的接口。

Read 读取 len(p)个字节到 p 。它返回读取的字节数(0 <= n <= len(p))和遇到的任何错误。即使 Read 返回 n <len(p),它也可以在调用期间将全部 p 用作暂存空间。如果某些数据可用但不是 len(p) 字节,则 Read 通常返回可用的数据,而不是等待更多数据。

当 Read 在成功读取 n> 0 字节后遇到错误或文件结束条件时,它会返回读取的字节数。它可能会从相同的调用中返回(非零)错误,或者从后续调用中返回错误(和 n == 0)。这种一般情况的一个实例是,在输入流末尾返回非零字节数的 Reader 可能会返回 err == EOF 或 err == nil 。下一个 Read 应该返回 0,EOF 。

在考虑错误错误之前,Callers 应始终处理返回的 n> 0 个字节。这样做可以正确处理读取一些字节后发生的 I/O 错误以及两种允许的 EOF 行为。

除非 len(p)== 0,否则 Read 的实现不鼓励返回零字节的计数和零错误。调用者应该将返回值 0 和零作为表示什么都没有发生; 特别是它不表示 EOF 。

Implementations 不能保留 p 。

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

func LimitReader(显示源代码)

func LimitReader(r Reader, n int64) Reader

LimitReader 返回一个 Reader,它从 r 读取,但在 n 字节后用 EOF 停止。底层的实现是一个 *LimitedReader 。

示例

package main

import (
	"io"
	"log"
	"os"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")
	lr := io.LimitReader(r, 4)

	if _, err := io.Copy(os.Stdout, lr); err != nil {
		log.Fatal(err)
	}

}

func MultiReader(显示源代码)

func MultiReader(readers ...Reader) Reader

MultiReader 返回一个 Reader,它是提供的输入读取器的逻辑连接。他们顺序阅读。一旦所有输入都返回 EOF,Read 将返回 EOF 。如果任何阅读器返回非零非 EOF 错误,则 Read 将返回该错误。

示例

package main

import (
	"io"
	"log"
	"os"
	"strings"
)

func main() {
	r1 := strings.NewReader("first reader ")
	r2 := strings.NewReader("second reader ")
	r3 := strings.NewReader("third reader\n")
	r := io.MultiReader(r1, r2, r3)

	if _, err := io.Copy(os.Stdout, r); err != nil {
		log.Fatal(err)
	}

}

func TeeReader(显示源代码)

func TeeReader(r Reader, w Writer) Reader

TeeReader 返回一个读写器,它读写从 r 读取的内容。从 r 执行的所有读取操作都与 w 的相应写入相匹配。没有内部缓冲 - 写入必须在读取完成之前完成。写入时遇到的任何错误都会报告为读取错误。

示例

package main

import (
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")
	var buf bytes.Buffer
	tee := io.TeeReader(r, &buf)

	printall := func(r io.Reader) {
		b, err := ioutil.ReadAll(r)
		if err != nil {
			log.Fatal(err)
		}

		fmt.Printf("%s", b)
	}

	printall(tee)
	printall(&buf)

}

type ReaderAt(显示源代码)

ReaderAt 是包装基本 ReadAt 方法的接口。

ReadAt 将 len(p) 个字节读入底层输入源的偏移 off 开始的 p 。它返回读取的字节数 (0 <= n <= len(p)) 和遇到的任何错误。

当 ReadAt 返回 n <len(p) 时,它将返回一个非零错误,解释为什么不返回更多字节。在这方面,ReadAt 比 Read 更严格。

即使 ReadAt 返回 n <len(p),它也可能在调用期间将所有 p 用作临时空间。如果有些数据可用但不是 len(p) 字节,则 ReadAt 阻塞,直到所有数据都可用或发生错误。在这方面,ReadAt 与 Read 不同。

如果 ReadAt 返回的 n = len(p) 字节位于输入源的末尾,则 ReadAt 可能会返回 err == EOF 或 err == nil 。

如果 ReadAt 正在从具有查找偏移量的输入源读取,则 ReadAt 不应受影响,也不应受基础查找偏移量的影响。

ReadAt 的客户端可以在同一个输入源上执行并行 ReadAt 调用。

实现不能保留 p 。

type ReaderAt interface {
        ReadAt(p []byte, off int64) (n int, err error)
}

type ReaderFrom(显示源代码)

ReaderFrom 是包装 ReadFrom 方法的接口。

ReadFrom 从 r 读取数据直到出现 EOF 或错误。返回值 n 是读取的字节数。读取过程中遇到的除 io.EOF 外的任何错误也会返回。

复制功能使用 ReaderFrom(如果可用)。

type ReaderFrom interface {
        ReadFrom(r Reader) (n int64, err error)
}

type RuneReader(显示源代码)

RuneReader 是包装 ReadRune 方法的接口。

ReadRune 读取单个 UTF-8 编码的 Unicode 字符,并以字节为单位返回符文及其大小。如果没有可用的字符,则会设置 err 。

type RuneReader interface {
        ReadRune() (r rune, size int, err error)
}

type RuneScanner(显示源代码)

RuneScanner 是将 UnreadRune 方法添加到基本 ReadRune 方法的接口。

UnreadRune 会导致下一次对 ReadRune 的调用返回与先前对 ReadRune 的调用相同的符文。在没有对 ReadRune 的中间调用的情况下调用 UnreadRune 可能是错误的。

type RuneScanner interface {
        RuneReader
        UnreadRune() error
}

type SectionReader(显示源代码)

SectionReader 在基础 ReaderAt 的一部分上实现 Read,Seek 和 ReadAt 。

type SectionReader struct {
        // 包含已过滤或未导出的字段
}

示例

package main

import (
	"io"
	"log"
	"os"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")
	s := io.NewSectionReader(r, 5, 17)

	if _, err := io.Copy(os.Stdout, s); err != nil {
		log.Fatal(err)
	}

}

func NewSectionReader(显示源代码)

func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader

NewSectionReader 返回一个 SectionReader,它从 r 处开始读取 offset,并在 n 字节后用 EOF 停止。

func (*SectionReader) Read(显示源代码)

func (s *SectionReader) Read(p []byte) (n int, err error)

func (*SectionReader) ReadAt(显示源代码)

func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error)

示例

package main

import (
	"fmt"
	"io"
	"log"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")
	s := io.NewSectionReader(r, 5, 16)

	buf := make([]byte, 6)
	if _, err := s.ReadAt(buf, 10); err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%s\n", buf)

}

func (*SectionReader) Seek(显示源代码)

func (s *SectionReader) Seek(offset int64, whence int) (int64, error)

示例

package main

import (
	"fmt"
	"io"
	"log"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")
	s := io.NewSectionReader(r, 5, 16)

	if _, err := s.Seek(10, io.SeekStart); err != nil {
		log.Fatal(err)
	}

	buf := make([]byte, 6)
	if _, err := s.Read(buf); err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%s\n", buf)

}

func (*SectionReader) Size(显示源代码)

func (s *SectionReader) Size() int64

大小以字节为单位返回该部分的大小。

type Seeker(显示源代码)

Seeker 是包装基本 Seek 方法的接口。

Seek 设置下一个读取或写入偏移量的偏移量,根据此解释:SeekStart 表示相对于文件的开始,SeekCurrent 表示相对于当前偏移量,SeekEnd 表示相对于结束。Seek 返回相对于文件开始的新偏移量和一个错误(如果有的话)。

在文件开始之前寻找偏移量是一个错误。寻求任何正偏移量是合法的,但后续对基础对象的 I/O 操作的行为取决于实现。

type Seeker interface {
        Seek(offset int64, whence int) (int64, error)
}

type WriteCloser(显示源代码)

WriteCloser 是分组基本 Write 和 Close 方法的接口。

type WriteCloser interface {
        Writer
        Closer
}

type WriteSeeker(显示源代码)

WriteSeeker 是将基本写入和查找方法分组的接口。

type WriteSeeker interface {
        Writer
        Seeker
}

type Writer(显示源代码)

Writer 是包装基本 Write 方法的接口。

写从 p 写入 len(p) 个字节到底层数据流。它返回从p (0 <= n <= len(p)) 写入的字节数,以及遇到任何导致写入提前停止的错误。如果返回 n < len(p),则写入必须返回非零错误。写入不能修改片数据,即使是暂时的。

实现不能保留 p 。

type Writer interface {
        Write(p []byte) (n int, err error)
}

func MultiWriter(显示源代码)

func MultiWriter(writers ...Writer) Writer

MultiWriter 创建一个写入器,将其写入所有提供的写入器,类似于 Unix tee(1) 命令。

示例

package main

import (
	"bytes"
	"fmt"
	"io"
	"log"
	"strings"
)

func main() {
	r := strings.NewReader("some io.Reader stream to be read\n")

	var buf1, buf2 bytes.Buffer
	w := io.MultiWriter(&buf1, &buf2)

	if _, err := io.Copy(w, r); err != nil {
		log.Fatal(err)
	}

	fmt.Print(buf1.String())
	fmt.Print(buf2.String())

}

type WriterAt(显示源代码)

WriterAt 是包装基本 WriteAt 方法的接口。

WriteAt 将 p 的 len(p) 个字节写入偏移关闭的基础数据流。它返回从 p (0 <= n <= len(p))写入的字节数,以及遇到任何导致写入提前停止的错误。如果返回 n < len(p),WriteAt 必须返回非零错误。

如果 WriteAt 正在使用搜索偏移量写入目标,则 WriteAt 不应受影响,也不应受底层搜索偏移量的影响。

如果范围不重叠,则 WriteAt 的客户端可以在同一个目的地上执行并行 WriteAt 调用。

实现不能保留 p 。

type WriterAt interface {
        WriteAt(p []byte, off int64) (n int, err error)
}

type WriterTo(显示源代码)

WriterTo 是包装 WriteTo 方法的接口。

WriteTo 将数据写入 w,直到没有更多数据要写入或出现错误时为止。返回值 n 是写入的字节数。写入过程中遇到的任何错误也会返回。

复制功能使用 WriterTo(如果可用)。

type WriterTo interface {
        WriteTo(w Writer) (n int64, err error)
}

子目录

Name

Synopsis

ioutil

Package ioutil实现了一些 I/O 实用程序功能。

io
io 详细
io/ioutil 详细
Go

Go 是一种编译型语言,它结合了解释型语言的游刃有余,动态类型语言的开发效率,以及静态类型的安全性。它也打算成为现代的,支持网络与多核计算的语言。要满足这些目标,需要解决一些语言上的问题:一个富有表达能力但轻量级的类型系统,并发与垃圾回收机制,严格的依赖规范等等。这些无法通过库或工具解决好,因此Go也就应运而生了。

主页 https://golang.org/
源码 https://go.googlesource.com/go
发布版本 1.9.2

Go目录

1.档案 | archive
2.缓冲区 | bufio
3.内置 | builtin
4.字节 | bytes
5.压缩 | compress
6.容器 | container
7.上下文 | context
8.加密 | crypto
9.数据库 | database
10.调试 | debug
11.编码 | encoding
12.错误 | errors
13. expvar
14.flag
15. fmt
16. go
17.散列 | hash
18.html
19.图像 | image
20.索引 | index
21.io
22.日志 | log
23.数学 | math
24. math/big
25.math/bits
26.math/cmplx
27.math/rand
28.拟态 | mime
29.net
30.net/http
31. net/mail
32. net/rpc
33.net/smtp
34. net/textproto
35. net/url
36.os
37.路径 | path
38.插件 | plugin
39.反射 | reflect
40.正则表达式 | regexp
41.运行时 | runtime
42.排序算法 | sort
43.转换 | strconv
44.字符串 | strings
45.同步 | sync
46.系统调用 | syscall
47.测试 | testing
48.文本 | text
49.时间戳 | time
50.unicode
51.不安全性 | unsafe
52.Go 语言数据类型
53.Go 语言基础语法
54.Go 语言结构
55.Go 语言 select 语句
56.Go 语言 switch 语句
57.Go 语言 if 语句嵌套
58.Go 语言 if…else 语句
59.Go 语言 if 语句
60.Go 语言运算符
61.Go 语言常量
62.Go 语言函数闭包
63.Go 语言函数作为实参
64.Go 语言函数引用传递值
65.Go 语言函数值传递值
66.Go 语言函数
67.Go 语言 goto 语句
68.Go 语言 continue 语句
69.Go 语言 break 语句
70.Go 语言循环嵌套
71.Go 语言 for 循环
72.Go 语言结构体
73.Go 语言指针作为函数参数
74.Go 语言指向指针的指针
75.Go 语言指针数组
76.Go 语言指针
77.Go 语言向函数传递数组
78.Go 语言多维数组
79.Go 语言变量作用域
80.Go 语言函数方法
81.Go 错误处理
82.Go 语言接口
83.Go 语言类型转换
84.Go 语言递归函数
85.Go 语言Map(集合)
86.Go 语言范围(Range)
87.Go 语言切片(Slice)
88.Go 并发
89.Go fmt.Sprintf 格式化字符串