Golang 获取命令行携带的参数丶文件操作

一.获取命令行携带的参数

/* 获取命令执行携带的参数 */
func TestGetCMDParameter() {
    /*
        os.Args就是运行时携带的参数.
        os.Args是一个切片
        第一个是主程序的名称

        测试:
            1.编译  go buil main.go
            2.运行  ./main -h localhost -p 1234 -P 0000 -u root
    */
    for index, val := range os.Args {
        index++
        fmt.Printf("第%v个参数=%v  ", index, val)
    }

    // 进行过处理的args
    var user string
    var host string
    var passwd string
    var port int

    flag.IntVar(&port, "p", 6379, "提醒用户,默认端口为6379.")
    flag.StringVar(&host, "h", "", "提醒用户,默认主机名空.")
    flag.StringVar(&user, "u", "", "提醒用户,默认用户为空.")
    flag.StringVar(&passwd, "P", "", "提醒用户,默认密码为空.")

    // 必须调用该方法才会转换
    flag.Parse()

    fmt.Printf("\nhost=%v, port=%v, user=%v, passwd=%v \n", host, port, user, passwd)
}

二.文件操作

func TestFile() {
    /*
        使用细节:
            1.file变量是指针类型
            2.所有的文件读写操作都基于file结构体
            3.
    */
    // 文件的打开和关闭
    FileOpenClose := func(filename string) {
        file, err := os.Open(filename)
        if err != nil {
            fmt.Println("open file error ! ", err)
            return
        }
        err = file.Close()
        if err != nil {
            fmt.Println("close file error ! ", err)
            return
        }
    }
    // 读文件 *Reader  带缓冲的读数据.默认缓冲大小为4096个字节(NewReader)
    FileReadBuf := func(filename string) {
        file, err := os.Open(filename)
        if err != nil {
            fmt.Println("open file error ! ", err)
            return
        }
        defer file.Close()

        reader := bufio.NewReader(file)
        for {
            context, err := reader.ReadString('\n') // 读取到换行符就返回

            if err == io.EOF {
                fmt.Println("注意这里,带结尾符的内容:", context)
                break
            }
            fmt.Printf(context)

        }

    }
    // 一次性将文件内容读取出来.只适用文件不大的情况 ioutil.ReadFile (好象现在过时了)
    FileRead := func(filename string) {
        // 文件的打开和关闭都在ReadFile中处理了
        bytes, err := ioutil.ReadFile(filename)
        if err != nil {
            fmt.Println("open file error ! ", err)
            return
        }
        fmt.Println(string(bytes))
    }
    // 写文件.以具体模式打开文件
    FileWriteOpenFile := func(filename string, context []string) {
        /*
            const (
                // Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
                O_RDONLY int = syscall.O_RDONLY // open the file read-only.
                O_WRONLY int = syscall.O_WRONLY // open the file write-only.
                O_RDWR   int = syscall.O_RDWR   // open the file read-write.
                // The remaining values may be or'ed in to control behavior.
                O_APPEND int = syscall.O_APPEND // append data to the file when writing.
                O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
                O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
                O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
                O_TRUNC  int = syscall.O_TRUNC  // truncate regular writable file when opened.
            )
            linux下,第三个参数为文件权限,创建新文件的时候有关
        */
        file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.FileMode(666))
        if err != nil {
            fmt.Println("open file error ! ", err)
            return
        }
        defer file.Close()
        // 带缓冲写文件
        writer := bufio.NewWriter(file)
        for _, val := range context {
            fmt.Println(val)
            _, err := writer.WriteString(val)
            if err != nil {
                fmt.Println("write file error ! ", err)
                break
            }

        }
        // 带缓冲的writer是先将数据写入缓存的,所以需要调用Flush将缓冲的数据真正写入到文件中去
        writer.Flush()
    }
    // 判断文件是否存在
    FileExists := func(filename string) (bool, error) {
        /*
            os.Stat 返回的FileInfo变量包含了文件的详细信息
            type FileInfo interface {
                Name() string       // base name of the file
                Size() int64        // length in bytes for regular files; system-dependent for others
                Mode() FileMode     // file mode bits
                ModTime() time.Time // modification time
                IsDir() bool        // abbreviation for Mode().IsDir()
                Sys() any           // underlying data source (can return nil)
            }
        */
        finfo, err := os.Stat(filename)
        if err == nil {
            return true, nil
        }
        fmt.Println(finfo)
        if os.IsNotExist(err) {
            return false, nil
        }
        return false, err
    }
    // 复制文件
    FileCopy := func(desFileName string, srcFileName string) (written int64, err error) {
        // 1.先获取src的file对象
        srcFile, err := os.Open(srcFileName)
        if err != nil {
            fmt.Printf("Open '%v' error! %v\n", srcFileName, err)
            return
        }
        defer srcFile.Close() // 记得关闭文件
        // 2.用src的file对象获取带缓冲的Reader,好配合Writer实现Copy
        reader := bufio.NewReader(srcFile)

        // 3.des的file对象
        desFile, err := os.OpenFile(desFileName, os.O_CREATE|os.O_WRONLY, 0666)
        if err != nil {
            fmt.Printf("Open '%v' error! %v\n", desFileName, err)
            return
        }
        defer desFile.Close()
        // 4.用des的file对象获取带缓冲的Writer,好配合Reader实现Copy
        writer := bufio.NewWriter(desFile)

        // 5.最终调用Copy.  如果目标文件夹不存在的话会报错
        written, err = io.Copy(writer, reader)
        return
    }

    filename := "./data.json"
    FileOpenClose(filename)
    FileReadBuf(filename)
    FileRead(filename)
    FileWriteOpenFile(filename, []string{"1hell"})
    if ok, err := FileExists(filename); !ok {
        if err != nil {
            fmt.Println("获取文件信息异常!", err)
        } else {
            fmt.Println("文件不存在!")
        }
    }
    if _, err := FileCopy("./test.json", filename); err != nil {
        fmt.Println("文件Copy错误!", err)
    }
}