Golang基础(IO流、反射)

最新推荐文章于 2024-07-15 18:37:52 发布

qq_31387691

最新推荐文章于 2024-07-15 18:37:52 发布

阅读量1k

点赞数 1

分类专栏： Golang

本文链接：https://blog.csdn.net/qq_31387691/article/details/109194439

版权

Golang 专栏收录该内容

37 篇文章 3 订阅

订阅专栏

一.输入流

流(stream)是应用程序和外部资源进行数据交互的纽带
流分为输入流和输出流,输入和输出都是相对于程序,把外部数据传入到程序中叫做输入,反之叫做输出流
输入流(Input Stream),输入流(Output Stream) 平时所说的I/O流
在Go语言标准库中io包下是Reader接口表示输入流,只要实现这个接口就属于输入流

// Reader is the interface that wraps the basic Read method.
//
// Read reads up to len(p) bytes into p. It returns the number of bytes
// read (0 <= n <= len(p)) and any error encountered. Even if Read
// returns n < len(p), it may use all of p as scratch space during the call.
// If some data is available but not len(p) bytes, Read conventionally
// returns what is available instead of waiting for more.
//
// When Read encounters an error or end-of-file condition after
// successfully reading n > 0 bytes, it returns the number of
// bytes read. It may return the (non-nil) error from the same call
// or return the error (and n == 0) from a subsequent call.
// An instance of this general case is that a Reader returning
// a non-zero number of bytes at the end of the input stream may
// return either err == EOF or err == nil. The next Read should
// return 0, EOF.
//
// Callers should always process the n > 0 bytes returned before
// considering the error err. Doing so correctly handles I/O errors
// that happen after reading some bytes and also both of the
// allowed EOF behaviors.
//
// Implementations of Read are discouraged from returning a
// zero byte count with a nil error, except when len(p) == 0.
// Callers should treat a return of 0 and nil as indicating that
// nothing happened; in particular it does not indicate EOF.
//
// Implementations must not retain p.
type Reader interface {
    Read(p []byte) (n int, err error)
}

代码演示

可以使用strings包下的NewReader创建字符串流

    r := strings.NewReader("hello 世界")
    b := make([]byte, r.Size())//创建字节切片,根据流数据大小创建切片大小，这时创建的切片为大小            
                               //等于流数据大小的空切片，创建的目的是为了在r.Read（b）时，将 
                               //ReadAt值设置为切片大小，并将字节流中的数据copy到创建的空切片b 
                               //中达到存放流中数据的目的。
    n, err := r.Read(b)//把流中数据读取到切片中,实质是将r中的字节流数据copy到创建的空切片b中。
    if err != nil {
        fmt.Println("读取失败,", err)
        return
    }
    fmt.Println("读取数据长度,", n)

    fmt.Println("流中数据",string(b))//以字符串形式输入切片中数据

源码↑

// Size returns the original length of the underlying string.
// Size is the number of bytes available for reading via ReadAt.
// The returned value is always the same and is not affected by calls
// to any other method.
func (r *Reader) Size() int64 { return int64(len(r.s)) }

func (r *Reader) Read(b []byte) (n int, err error) {
	if r.i >= int64(len(r.s)) {
		return 0, io.EOF
	}
	r.prevRune = -1
	n = copy(b, r.s[r.i:])
	r.i += int64(n)
	return
}

最常用的是文件流,把外部文件中数据读取到程序中

    f, err := os.Open("D:/go.txt")//打开文件
    defer f.Close()
    if err != nil {
        fmt.Println("文件读取失败,", err)
        return
    }
    fileInfo, err := f.Stat()//获取文件信息
    if err != nil {
        fmt.Println("文件信息获取失败,", err)
        return
    }
    b := make([]byte, fileInfo.Size())//根据文件中数据大小创建切片
    _, err = f.Read(b)//读取数据到切片中
    if err != nil {
        fmt.Println("文件流读取失败:", err)
        return
    }
    fmt.Println("文件中内容为:", string(b))//以字符串形式输入切片中数据

二、输出流

输出流就是把程序中数据写出到外部资源
Go语言标准库中输出流是Writer接口

// Writer is the interface that wraps the basic Write method.
//
// Write writes len(p) bytes from p to the underlying data stream.
// It returns the number of bytes written from p (0 <= n <= len(p))
// and any error encountered that caused the write to stop early.
// Write must return a non-nil error if it returns n < len(p).
// Write must not modify the slice data, even temporarily.
//
// Implementations must not retain p.
type Writer interface {
    Write(p []byte) (n int, err error)
}

代码操作

注意:输入流时不要使用os.Open()因为这种方式获取的文件是只读的

 fp := "D:/go.txt"
    /*
    第三个参数表示文件权限
    第 1 位在权限中总是为 0
    第 2 位为 0 表示文件不可以被读， 为 1 表示可以被读
    第 3 位为 0 表示文件不可以被写， 为 1 表示可以被写
    第 4 位为 0 表示文件不可以被执行， 为 1 表示可以被执行
    整理如下:
       0(0000): 不可读写,不能被执行
       1(0001): 不可读写,能被执行
       2(0010): 可写不可读,不能被执行
       3(0011): 可写不可读,能被执行
       4(0100): 可读不可写,不能被执行
       5(0101): 可读不可写,能被执行
       6(0110): 可读写,不能执行
       7(0111): 可读写,可执行

    0666:
    第一个 0 表示这个数是 八进制
    第一个 6 表示文件拥有者有读写权限，但没有执行权限
    第二个 6 表示文件拥有者同组用户有读写权限，但没有执行权限
    第三个 6 表示其它用户有读写权限，但没有执行权限
     */
    //第二个参数表示文件内容追加
    //第三个参数表示创建文件时文件权限
    f, err := os.OpenFile(fp, os.O_APPEND, 0660)
    defer f.Close()
    if err != nil {
        fmt.Println("文件不存在,创建文件")
        f, _ = os.Create(fp)
    }
    /*
    内容中识别特殊字符
    \r\n 换行
    \t 缩进
     */
    /*
    使用文件对象重写的Writer接口,参数是[]byte
     */
    f.Write([]byte("使用Writer接口写数据\r\n"))

    /*
    使用stringWriter接口的方法,参数是字符串,使用更方便
     */
    f.WriteString("写了\t一段\r\n内容123")
    fmt.Println("程序执行结束")

三、ioutil包

ioutil包下提供了对文件读写的工具函数,通过这些函数快速实现文件的读写操作
ioutil包下提供的函数比较少,但是都是很方便使用的函数

func NopCloser(r io.Reader) io.ReadCloser
func ReadAll(r io.Reader) ([]byte, error)
func ReadFile(filename string) ([]byte, error)
func WriteFile(filename string, data []byte, perm os.FileMode) error
func ReadDir(dirname string) ([]os.FileInfo, error)
func TempDir(dir, prefix string) (name string, err error)
func TempFile(dir, prefix string) (f *os.File, err error)

代码演示

打开完文件后可以使用ReadAll把文件中所有内容都读取到

    f, err := os.Open("D:/go.txt")
    defer f.Close()
    if err != nil {
        fmt.Println(err)
        return
    }
    b, err := ioutil.ReadAll(f)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("文件中内容:\n", string(b))//也可以直接读取文件中内容

    b, err := ioutil.ReadFile("D:/go.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(b))

写文件也很简单,直接使用WriteFile函数即可,但是源码中已经规定此文件只能是可写状态,且不是尾加数据

    err := ioutil.WriteFile("D:/abc.txt", []byte("内容123123"), 0666)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("数据写入成功")

还提供了快速获取某个文件夹中所有文件信息的函数

    fs,_:=ioutil.ReadDir("D:/")
    for _,n := range fs {
        fmt.Println(n.Name())
    }

四、反射介绍

在Go语言标准库中reflect包提供了运行时反射,程序运行过程中动态操作结构体
当变量存储结构体属性名称,想要对结构体这个属性赋值或查看时,就可以使用反射.
反射还可以用作判断变量类型
整个reflect包中最重要的两个类型
- reflect.Type 类型
- reflect.Value 值
获取到Type和Value的函数
- reflect.TypeOf(interface{}) 返回Type
- reflect.ValueOf(interface{}) 返回值Value

二.代码示例

判断变量类型

   a:=1.5
   fmt.Println(reflect.TypeOf(a))

获取结构体属性的值

type People struct {
   Id   int
   Name string
}

func main() {
   fmt.Println("asdf")

   peo := People{1, "张三"}

   //获取peo的值
   v := reflect.ValueOf(peo)
   //获取属性个数,如果v不是结构体类型panic
   fmt.Println(v.NumField())

   //获取第0个属性,id,并转换为int64类型
   fmt.Println(v.Field(0).Int())
   //获取第1个属性,转换换为string类型
   fmt.Println(v.Field(1).String())

   //根据名字获取类型,并把类型名称转换为string类型
   idValue := v.FieldByName("Id")
   fmt.Println(idValue.Kind().String())

}

设置结构体属性的值时要传递结构体指针,否者无法获取设置的结构体对象
- 反射直射结构体属性时,要求属性名首字母必须大写,否则无法设置

package main

import (
   "fmt"
   "reflect"
)

type People struct {
   Id   int
   Name string
}

func main() {
   fmt.Println("asdf")
   peo := People{1, "张三"}

   /*
   反射时获取peo的地址.
   Elem()获取指针指向地址的封装.
   地址的值必须调用Elem()才可以继续操作
    */
   v := reflect.ValueOf(&peo).Elem()

   fmt.Println(v.FieldByName("Id").CanSet())
   v.FieldByName("Id").SetInt(123)
   v.FieldByName("Name").SetString("李四")
   fmt.Println(peo)
}

结构体支持标记(tag),标记通常都是通过反射技术获取到.结构体标记语法

type 结构体名称 struct{
  属性名 类型 `key:"Value"`
}

获取结构体标记(tag)

type People struct {
    Name    string `xml:"name"`
    Address string `xml:"address"`
}

func main() {
    t:=reflect.TypeOf(People{})
    name,_:=t.FieldByName("Name")
    fmt.Println(name.Tag)//获取完整标记
    fmt.Println(name.Tag.Get("xml"))//获取标记中xml对应内容
}