该包为IO操作原语提供了基本的接口，它包装了IO操作原语的实现（例如os包中的类型）。除非特别说明，调用者不能假设接口中的方法可以被并行调用。

const (
        SeekStart   = 0 // 相对于文件的起始位置进行Seek
        SeekCurrent = 1 // 相对于当前读取位置进行Seek
        SeekEnd     = 2 // 相对于尾部进行Seek
)

// 错误定义
// 由Read函数返回，表示没有更多可读的数据。用于优雅的结束文件读取（读到尾部了）
var EOF = errors.New("EOF")
// 在关闭的管道上进行读写
var ErrClosedPipe = errors.New("io: read/write on closed pipe")
var ErrNoProgress = errors.New("multiple Read calls return no data or error")、
// 当提供的缓冲区不够存放读取到的数据时
var ErrShortBuffer = errors.New("short buffer")
// 当写操作所要求的字节数不足时
var ErrShortWrite = errors.New("short write")
// 在读取固定长度的块或者数据结构时，没有到预期的结尾位置即发生EOF
var ErrUnexpectedEOF = errors.New("unexpected EOF")

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

sr := strings.NewReader("Read after me, please!\n")
n, err := io.Copy(os.Stderr, sr)
if err == nil {
    fmt.Printf("%v bytes read.\n", n)
}

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)

r := bytes.NewReader([]byte{0, 1, 2, 3, 4, 5, 7, 8, 9})
buf := make([]byte, 5)
io.ReadAtLeast(r, buf, 3)
fmt.Printf("%v", buf)  // [0 1 2 3 4] 读满了切片容量 

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

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

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

type ByteScanner interface {
    ByteReader
    // 导致下一次ReadByte返回和上一次ReadByte一样的内容
    UnreadByte() error
} 

type ByteWriter interface {
    WriteByte(c byte) error
} 

type Closer interface {
    // 此接口包装基本的Close方法
    Close() error
}

type LimitedReader struct {
    R Reader // 此结构使用的Reader
    N int64  // 最大读取字节数。每次调用R后等会更新N，来反应还可以读取多少字节
}

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

func Pipe() (*PipeReader, *PipeWriter)

type PipeReader struct {}

// 关闭管道的读端，后续写端的写操作会返回ErrClosedPipe
func (r *PipeReader) Close() error
// 关闭管道的读端，后续写端的写操作会返回该方法提供的err
func (r *PipeReader) CloseWithError(err error) error
// 读取数据
func (r *PipeReader) Read(data []byte) (n int, err error)

type PipeWriter struct {}

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

func MultiReader(readers ...Reader) Reader

r1 := strings.NewReader("Hello")             
r2 := strings.NewReader(" World")            
rm := io.MultiReader(r1, r2)                 
buf := make([]byte, 20)                      
io.ReadFull(rm, buf)                         
fmt.Printf("%v", string(buf)) // Hello World

func TeeReader(r Reader, w Writer) Reader

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

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

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

iotype SectionReader struct {
}
// 读取
func (s *SectionReader) Read(p []byte) (n int, err error)
// 从指定位置开始读取
func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error)
// Seek到指定位置
func (s *SectionReader) Seek(offset int64, whence int) (int64, error)
返回节段中包含的字节数
func (s *SectionReader) Size() int64

r := bytes.NewReader([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
s := io.NewSectionReader(r, 2, 3)
buf := make([]byte, 10)
s.Read(buf)
fmt.Printf("%v", buf) // [2 3 4 0 0 0 0 0 0 0] 最多读取3字节

s = io.NewSectionReader(r, 0, 10)
s.ReadAt(buf, 5)
fmt.Printf("%v", buf) // [5 6 7 8 9 0 0 0 0 0] 

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

该包实现带缓冲的IO功能。执行很多碎小的写操作会影响性能，因为每次写操作都对应了系统调用，过多的系统调用会加重CPU负担。类似磁盘这样的设备，处理块对齐的数据时性能更好，因此有必要为IO提供缓冲功能。

简单的示例： 

// 实现一个仿冒Writer，它能够打印写出的字节数量
type Writer int

func (*Writer) Write(p []byte) (n int, err error) {
    fmt.Printf("Bytes write: %v\n", len(p))
    return len(p), nil
}
func main() {
    w := new(Writer)
    w.Write([]byte{1}) // 一字节无缓冲写出
    w.Write([]byte{2})

    // 创建带缓冲的Writer，缓冲区大小5字节
    bw := bufio.NewWriterSize(w, 5)
    bw.Write([]byte{1, 2, 3}) // 不会写出，因为缓冲区没有满
    bw.Write([]byte{4, 5, 6}) // 写出，输出5
    fmt.Printf("Available size of buffer: %v", bw.Available())
    bw.Flush() // 写出，输出1
}

r := strings.NewReader("既然选择了远方，就应该风雨兼程")
br := bufio.NewReaderSize(r, 18)
rune, size, err := br.ReadRune()
if err == nil {
    fmt.Printf("Character: %c, Size: %v\n", rune, size) // Character: 既, Size: 3
}
buf := make([]byte, 18)
br.Read(buf)
fmt.Printf("String: %v", string(buf)) // String: 然选择了远
br.Discard(6)
rune, _, _ = br.ReadRune()
fmt.Printf("%c", rune) // 就

func main() {
    // 扫描器可以方便进行扫描，例如逐行读取、逐字符读取
    bs := bufio.NewScanner(strings.NewReader("既然选择了远方，就应该风雨兼程"))
    // 每读取一个字符即停止
    bs.Split(bufio.ScanRunes)
    for bs.Scan() {
        // 以字符串形式返回读取到的内容
        fmt.Print(bs.Text())
    }
}

包含一些工具函数

// 读取全部内容
bytes, err := ioutil.ReadAll(strings.NewReader("Hello darkness my old friend"))
if err == nil {
    fmt.Printf("%c", bytes)
}

// 读取目录的全部条目
infos, err := ioutil.ReadDir("/etc/mysql")
for _, info := range infos {
    // 打印目录中的内容
    fmt.Println(info.Name())
}

// 读取文件的内容并返回
const FNAME = "/etc/mysql/my.cnf"
content, _ := ioutil.ReadFile(FNAME)
// 写入文件内容
ioutil.WriteFile(FNAME, content, 0777)

// 创建临时文件和目录
dirName, _ := ioutil.TempDir("", "go")
fmt.Println(dirName) // 输出目录/tmp/go154074736，注意随机后缀

该包提供类似C语言风格的printf、scanf

fmt.Printf("%f",12.22) // 12.220000

// 打开并得到os.File对象
f, err := os.Open("/etc/rc.local")

// 关闭文件
defer f.Close()

# 读取最多5字节到缓冲
b1 := make([]byte, 5)
# 返回实际读取的字节数
n1, err := f.Read(b1)

// 寻道到第6字节处，第二参数：0相对于文件头，1 相对于当前位置，2相对于文件尾
o2, err := f.Seek(6, 0)
b2 := make([]byte, 2) 
n2, err := f.Read(b2)

// Rewind
f.Seek(0, 0)

r4 := bufio.NewReader(f)
// 向前偷窥
b4, err := r4.Peek(5)

The post Go语言IO编程 appeared first on 绿色记忆.

Linux系统中每个运行的进程，具有与之关联的文件描述符，通过这些描述符可以访问打开的文件或者设备。当一个进程打开时，一般会有三个已经打开的文件描述符：

下表是与文件访问有关的系统调用

size_t write( int fildes, const void *buf, size_t nbytes );

#include <unistd.h>
write( 1, "stdout", 6 );
write( 2, "stderr", 6 );

size_t read( int fildes, void *buf, size_t nbytes );

char buf[128];
int nread;
//阻塞的从标准输入中读取数据
nread = read( 0, buf, 16 );
write( 2, buf, nread );

#include <fcntl.h>
//严格的说， 在遵守POSIX规范的系统上，下面两个头文件不需要包含
#include <sys/types.h>
#include <sys/stat.h>
//oflags可以指定打开模式
//O_RDONLY   只读
//O_WRONLY   只写
//O_RDWR     读写
//oflags还可以按位或以下选项：
//O_APPEND   写入数据追加在文件结尾
//O_TRUNC    设置文件长度为0，丢弃已有内容
//O_CREAT    如果需要，根据mode中给出的模式创建文件
//O_EXCL     与O_CREAT联用，防止其它进程创建同一个文件
//           如果其它进程创建同一文件，该调用将失败
int open(const char *path, int oflags);
//mode在使用O_CREAT选项时有意义，代表文件的模式（权限）
//模式由S_开头的若干常量来表示，使用时按位或
// S_ISUID 04000 文件的 (set user-id on execution)位
// S_ISGID 02000 文件的 (set group-id on execution)位
// S_ISVTX 01000 文件的sticky 位
// S_IRUSR (S_IREAD) 00400 文件所有者具可读取权限
// S_IWUSR (S_IWRITE)00200 文件所有者具可写入权限
// S_IXUSR (S_IEXEC) 00100 文件所有者具可执行权限
// S_IRGRP 00040 用户组具可读取权限
// S_IWGRP 00020 用户组具可写入权限
// S_IXGRP 00010 用户组具可执行权限
// S_IROTH 00004 其他用户具可读取权限
// S_IWOTH 00002 其他用户具可写入权限
// S_IXOTH 00001 其他用户具可执行权限
int open(const char *path, int oflags, mode_t mode);

#include <unistd.h>
#include <sys/types.h>
//whence可以为：
// SEEK_SET: 表示偏移量为绝对位置
// SEEK_CUR: 表示偏移量是相对于当前位置的位置
// SEEK_END: 表示偏移量是相对于文件结尾的位置
off_t lseek( int fildes, off_t offset, int whence );

#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
//该函数通过描述符定位文件
int fstat( int fildes, struct stat *buf );
//下面两个函数通过文件路径定位
int stat( const char *path, struct stat *buf );
//该函数与stat类似，但是如果文件是符号链接，它会
//返回符号链接本身的信息，而stat返回链接目标的信息
int lstat( const char *path, struct stat *buf );

#include <unistd.h>
//复制并返回新的文件描述符
int dup( int fildes );
//复制文件描述符为fildes2
int dup2( int fildes, int fildes2 );

标准I/O库（stdio）及其头文件stdio.h为底层I/O系统提供通用的对外接口，现在这个库已经是ANSI C标准库的一部分。标准I/O库提供多种复杂的函数用于格式化输出、扫描输入，还负责设备缓冲的处理。

在标准I/O库中，操控文件的方式与系统调用类似，其中与底层文件描述符对应的是流（Stream），被实现为指向结构体FILE的指针。

在程序启动时，stdin、stdout、stderr这三个文件已经打开。

标准I/O库关于文件读写API的使用，参考Linux I/O编程

相关系统调用或函数：

#include <sys/stat.h>
int chmod(const char *path, mode_t mode);

#include <sys/types.h>
#include <unistd.h>
int chown(const char *path, uid_t owner, gid_t group);
//支持数字格式的uid、gid，这些ID可以通过getuid、getgid获得

#include <unistd.h>
int unlink(const char *path);
int link(const char *path1, const char *path2);
int symlink(const char *path1, const char *path2);

//创建临时文件的技巧，创建后立即unlink
open(...);
unlink(...);
//该文件会在当前进程退出后自动清理删除

#include <sys/types.h>
#include <sys/stat.h>
int mkdir(const char *path, mode_t mode);

#include <unistd.h>
int rmdir(const char *path);

#include <unistd.h>
int chdir(const char *path);

#include <unistd.h>
char *getcwd(char *buf, size_t size);

虽然可以将目录作为普通文件一样打开读写，但是这种方式不具有可移植性。Linux下用于目录访问的标准库函数定义在dirent.h头中，这些函数使用结构体DIR作为目录操作的基础，DIR*被称为目录流。这些函数中常用的包括：

函数	说明
opendir	opendir打开一个目录并建立目录流，如果失败，返回NULL，在底层，目录流打开目录的文件描述符 #include <sys/types.h> #include <dirent.h> DIR *opendir(const char *name);
readdir	返回一个包含了下一个目录项信息的dirent指针，每次调用返回下一个，遇到目录结尾则返回NULL。如果在迭代期间，其他进程创建/删除了文件，那么readdir不能保证所有文件被列出。 dirent指针包含两个数据项： ino_t d_ino;/*文件Inode节点号*/char d_name[];/*文件的名字*/   #include <sys/types.h> #include <dirent.h> struct dirent *readdir(DIR *dirp);
telldir	返回当前目录流迭代的位置，可以供后续seekdir调用进行重置 #include <sys/types.h> #include <dirent.h> long int telldir(DIR *dirp);
seekdir	设置目录流指针的位置 #include <sys/types.h> #include <dirent.h> void seekdir(DIR *dirp, long int loc);
closedir	关闭目录流，并释放与之相关的资源 #include <sys/types.h> #include <dirent.h> int closedir(DIR *dirp);

很多文件I/O函数在失败后会设置外部变量errno的值，以提示失败的原因，程序必须在函数报告出错后立即检查errno，因为它可能被下一个函数调用覆盖。常见的错误代码包括：

错误代码	说明
EPERM	操作不允许
ENOENT	文件或目录不存在
EINTR	系统调用被中断
EIO	I/O错误
EBUSY	设备或资源忙
EEXIST	文件存在
EINVAL	无效参数
EMFILE	打开的文件过多
ENODEV	设备不存在
EISDIR	是一个目录
ENOTDIR	不是一个目录

下面两个函数用于错误代码的处理：

#include <string.h>
char *strerror(int errnum);

#include <stdio.h>
void perror(const char *s);

该系统调用允许对底层的文件描述符进行更加细致的控制：

#include <fcntl.h>
int fcntl(int fildes, int cmd);
int fcntl(int fildes, int cmd, long arg);

//cmd表示需要执行的动作：
//F_DUPFD 复制并返回一个新的文件描述符
//F_GETFD 返回fcntl.h中定义的文件描述符标记
//F_SETFD 设置文件描述符标记
//F_GETFL 获取文件状态标记、访问模式

内存映射。该函数用于创建一段供多个程序共享的内存，其中一个程序对其的修改，另外一个程序会立即看到。

该函数创建了一个指向了一段内存区域的指针，该内存区域与文件描述符指向的文件的内容关联：

#include <sys/mman.h>
void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);
//addr 起始内存地址，如果设置为0，则自动分配
//len 共享内存的长度
//prot设置共享内存的访问权限，以下位或：
//PROT_READ 该内存段可读
//PROT_WRITE 该内存段可写
//PROT_EXEC 该内存段可执行
//PROT_NONE 该内存段不能被访问
//flags控制程序对内存段的改变造成的影响：
//MAP_PRIVATE 内存段是私有的，修改是本地的，仅对当前进程有效
//MAP_SHARED 对内存段的修改被保留到磁盘
//MAP_FIXED 该段必须位于addr指定的地址
//fildes 共享内存关联的文件描述符
//off 共享内存访问文件内容的偏移值

使用msync函数可以把内存段中的部分或者全部写回到被映射的文件中，或者从文件中读出：

#include <sys/mman.h>
int msync(void *addr, size_t len, int flags);
//addr 起始地址
//len 长度
//flags 标记位：
//MS_ASYNC 执行异步写
//MS_SYNC 执行同步写
//MS_INVALIDATE 把数据读回到内存段

使用munmap函数可以释放内存段：

#include <sys/mman.h>
int munmap(void *addr, size_t len);

该系统调用在Linux下不仅仅可以用于网络I/O，普通文件I/O也被支持：

#include <sys/types.h>
#include <sys/time.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    char buffer[128];
    int result, nread;
    fd_set inputs, testfds;
    struct timeval timeout;
    FD_ZERO( &inputs ); //初始化为空白文件描述符集
    FD_SET( 0, &inputs ); //设置标准输入
    while ( 1 )
    {
        testfds = inputs;
        timeout.tv_sec = 2;
        timeout.tv_usec = 500000;
        //等待标准输入上具有数据可读，超时2.5秒
        result = select( FD_SETSIZE, &testfds, ( fd_set * ) NULL, ( fd_set * ) NULL, &timeout );
        switch ( result )
        {
            case 0 :
                printf( "超时\n" );
                break;
            case -1 :
                perror( "出错" );
                exit( 1 );
            default :
                if ( FD_ISSET( 0, &testfds ) )
                {
                    //标准输入已经就绪，可以读取
                }
                break;
        }
    }
}

The post Linux IO编程 appeared first on 绿色记忆.