Go格式化输入输出、文件读写、命令行参数、错误处理

格式化输入输出

package main

import(
	"fmt"
)

type student struct{
	Name string
	Age int
	Score float32
}

func main()  {
	var str = "stu 18 89.92"
	var stu student
	fmt.Sscanf(str,"%s %s %f",&stu.Name,&stu.Age,&stu.Score)
	fmt.Println(stu)
}

文件读写

文本文件读写

• os.File封装所有文件相关操作， os.Stdin,os.Stdout, os.Stderr都是*os.File

    打开一个文件进行读操作： os.Open(name string) (*File, error)
    关闭一个文件：File.Close()
  

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main() {

	inputFile, err := os.Open("input.dat")
	if err != nil {
		fmt.Printf("open file err:%v\n", err)
		return
	}

	defer inputFile.Close()
	inputReader := bufio.NewReader(inputFile)
	for {
		inputString, readerError := inputReader.ReadString('\n')
		if readerError == io.EOF {
			return
		}
		fmt.Printf("The input was: %s", inputString)
	}
}

• 上面是打开文件再读，文件不大的时候，用下面语句可以直接把文件读进来
  buf, err := ioutil.ReadFile(inputFile)

• 文件读写

    os.OpenFile(“output.dat”,  os.O_WRONLY|os.O_CREATE, 0666)
    第二个参数：文件打开模式：
    1.  os.O_WRONLY：只写
    2.  os.O_CREATE：创建文件
    3.  os.O_RDONLY：只读
    4.  os.O_RDWR：读写
    5.  os.O_TRUNC ：清空
  
    第三个参数：权限控制：
    r ——> 004
    w——> 002
    x——> 001
  

• 实例

package main

import (
	"bufio"
	"fmt"
	"os"
)
	
// 文件写入
func main() {
	outputFile, outputError := os.OpenFile("D:/test.log", os.O_WRONLY|os.O_CREATE, 0666)
	if outputError != nil {
		fmt.Printf("An error occurred with file creation\n")
		return
	}
	defer outputFile.Close()

	outputWriter := bufio.NewWriter(outputFile)
	outputString := "hello world!\n"

	outputWriter.WriteString(outputString)
	outputWriter.Flush()
}

拷贝文件

package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	CopyFile("D:/test.log", "D:/test1.log")
	fmt.Println("Copy done!")
}

func CopyFile(dstName, srcName string) (written int64, err error) {
	src, err := os.Open(srcName)
	if err != nil {
		return
	}
	defer src.Close()

	dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
	if err != nil {
		return
	}
	defer dst.Close()

	// 核心语句
	return io.Copy(dst, src)
}

压缩文件读写

package main

import(
	"fmt"
	"bufio"
	"os"
	"compress/gzip"
)

// 打开一个压缩文件 并读取里面的内容
func testZip()  {
	fName := "D:/test.log.gz"
	
	// 打开文件
	file,err:=os.Open(fName)
	defer file.Close()
	if err!= nil{
		fmt.Println("Open file err:",err)
		return
	}

	// 压缩文件读取器
	fz,err:=gzip.NewReader(file)
	if err!=nil{
		fmt.Println("Open gzip err:",err)
		return
	}

	// 用缓存读取器读取内容
	var r *bufio.Reader
	r = bufio.NewReader(fz)
	for {
		line,err:=r.ReadString('\n')
		if err!=nil{
			fmt.Println("Read err:",err)
			return
		}
		fmt.Println(line)
	}
}

func main()  {
	testZip()
}

命令行参数

• os.Args是一个string的切片，用来存储所有的命令行参数

    第一个参数是程序自身所在的路径
  

package main

import(
	"fmt"
	"os"
)

// 命令行参数
 func testArgs()  {
	fmt.Printf("len of args:%d\n",len(os.Args))
	for index,value := range os.Args {
		fmt.Printf("Args[%d] is %s\n",index,value)
	}
}

func main()  {
	testArgs()
}

输出：
len of args:1
Args[0] is C:\Users\11712\AppData\Local\Temp\go-build064412046\b001\exe\main.exe

• flag包的使用，用来解析命令行参数：

    	flag.BoolVar(&test, "b", false, "print on newline")
    	flag.StringVar(&str, "s", "", "print on newline")
    	flag.IntVar(&count, "c", 1001, "print on newline")
  

// flag包的使用
func testFlag()  {
	var test bool
	var str string
	var count int
	flag.BoolVar(&test, "b", false, "print on newline")
	flag.StringVar(&str, "s", "", "print on newline")
	flag.IntVar(&count, "c", 1001, "print on newline")
	flag.Parse()

	fmt.Println(test)
	fmt.Println(str)
	fmt.Println(count)
}

错误处理

• 错误是一种接口

 type error interface { 
        Error() string 
} 

• 自定义错误

package main

import(
	"fmt"
)

type PathError struct{
	Name string
	Time string
}

// 自定义错误 也就是实现这个接口即可
func (p *PathError)Error()string  {
	return p.Name + p.Time
}

func testError1()error  {
	return &PathError{
		Name:"路径不对",
		Time:"未知",
	}
}

func main()  {

	err:= testError1()
	switch err := err.(type) {
	case *PathError:
			fmt.Println(err.Name)
	default: 
	} 
}

• 输出
  路径不对