Go(7[终端读写|文件操作|命令行参数|Json序列化])

终端读写

创新互联建站是专业的网站建设公司,提供网站建设,网站制作,网站设计等网站开发一体化解决方案;包括H5响应式网站,小程序设计,网站定制,企业网站建设,商城网站建设,响应式网站建设,建网站,PHP网站建设,软件开发，软文发布平台，网站营销。欢迎做网站的企业前来合作洽谈,创新互联建站将竭诚为您服务!

操作终端相关文件句柄常量

1. os.Stdin:标准输入

2. os.Stdout:标准输出

3. os.Stderr:标准错误输出

终端读写示例:

//Sscanf 是从变量中读取值

package main

import "fmt"

var (

    firstName,lastName ,s string

    i int

    f float32

    input = "56.12 / 5212 / Go"

    format  = "%f/%d/%s"

)

func main()  {

    fmt.Println("Please...input:")

    fmt.Scanln(&firstName,&lastName)

    fmt.Printf("Hi,%s,%s!",firstName,lastName)

    fmt.Sscanf(input,format,&f,&i,&s)

    fmt.Println("Form the string we read;",f,i,s)

}

牛逼的带缓冲的终端读写

//NewReader 接受的是 只要实现的read接口

//带缓冲区

//底层是代码Reader 这个接口

    type Reader interface {

        Read(p []byte) (n int, err error)

    }

带缓冲区的读写代码:

//NewReader需要接受实现Reader这个接口的实例

//os.Stidin底层实现了这个接口，所以能接受

    read := bufio.NewReader(os.Stdin)

    // 读取每一行的字符,以\n为分割

    line,err :=read.ReadString('\n')

    if err!=nil{

        fmt.Println("read eror",err)

        return

    }

    fmt.Println("input!",line)

使用缓冲区,把值输出到终端上:

接口的强大
**自定义一个struct,然后实现Read接口****

type RandStr struct {

}

func (r *RandStr) Read(p []byte) (n int, err error) {

    fmt.Printf("len(p)=%d",len(p))

    source := "abcdefaskljdajhkldaload121332"

    for i:=0;i<32;i++{

        index := rand.Intn(len(source))

        p[i] = source[index]

    }

    p[32] = '\n'

    return len(p),nil

}

栗子:统计终端输入字符,数字,出现次数

package main

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

func fusion_input(d string)  {
    //一个utf-8字符占3个字节
    var countNum, countLetter, countSpace, countOther int
    utf8arr := []rune(d)
    for _, v := range utf8arr {
        if v >= 'a' && v <= 'z' || v >= 'A' && v <= 'Z' {
            countLetter++
        } else if v >= '0' && v <= '9' {
            countNum++
        } else if v == ' ' {
            countSpace++
        } else {
            countOther++
        }
    }
    fmt.Println("英文字母的个数:", countLetter)
    fmt.Println("数字的个数：", countNum)
    fmt.Println("空格的个数：", countSpace)
    // 这里理解为多了一个换行符，所以进行了减一
    fmt.Println("其他字符的个数：", countOther)
}

func main()  {
    fmt.Println("Please...input:")
    read :=bufio.NewReader(os.Stdin)
    linebytes,_,_ := read.ReadLine()
    fusion_input(string(linebytes))

}

文件读写

可以定义一个const

const (

    name = "E:/pycharm快捷键及一些常用设置.txt"

    zipfilename ="C:/Users/Administrator/Documents/Tencent Files/1047738527/filenamepool.gz"

    testwritefilename = "D:/Log.txt"

    dstName = "E:/logger_helper.py"

    srcName ="E:/jquery-1.12.4.js"

)

1:文件打开

func fusion_error(err error) bool {

    var tag = true

    if err == io.EOF{

        fmt.Println("文件读完了")

        return false

    }

    if err!=nil{

        fmt.Printf("%s",err)

        tag = false

        return tag

    }

    return tag

}

//原生的打开文件

func testFile()  {

    file,err := os.Open("E:/pycharm快捷键及一些常用设置.txt")

    fusion_error(err)

    //文件打开,一定要defer 关闭,

    defer file.Close()

    var data [1024]byte

    for {

        //Read底层 接受的是一个bytes的切片

        n,err := file.Read(data[:])

        tag :=fusion_error(err)

        if tag == false{

            break

        }

        //获取数据0到n直接的数据, 这样可以防止越界访问,出现程序崩溃

        filestr := string(data[0:n])

        fmt.Println(filestr)

    }

}

2.带缓冲区的读文件

//带缓冲区的读文件

func buffio_readfile(name string)  {

    file,err := os.Open(name)

    fusion_error(err)

    defer file.Close()

    //bufio 更高级的功能, 可以按行读

    //bufio 封装了一层

    //带缓冲区,所以效率更高

    //bufio 是接受的具体实现的接口 :实现了Reader 接口

    reader := bufio.NewReader(file)

    for {

        line,err :=reader.ReadString('\n')

        tag := fusion_error(err)

        if tag == false{

            break

        }

        fmt.Println(line)

    }

}

3.一次性读取文件内容

//一次性读出来放到内存中！适合读取配置文件

//内部给你做了所有的操作,无需要关闭文件

func Ioutil(name string)  {

    data,error :=ioutil.ReadFile(name)

    fusion_error(error)

    fmt.Println(string(data))

}

4.读取压缩文件:

//读取解压文件

func zipfile( name string)  {

    file,error := os.Open(name)

    fusion_error(error)

    defer file.Close()

    reader,error := gzip.NewReader(file)

    fusion_error(error)

    bufread := bufio.NewReader(reader)

    for {

        line,error:=bufread.ReadString('\n')

        tag :=fusion_error(error)

        if tag == false{

            break

        }

        fmt.Printf("%s",line)

    }

}

5.写文件操作

文件打开模式,第二个参数

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

//写文件 :普通读写,缓存读写

func testWriteFile(name string)  {

    file,err := os.OpenFile(name,os.O_WRONLY|os.O_CREATE,066)

    fusion_error(err)

    defer file.Close()

    //普通的写文件操作,比较慢

    //for i:=0;i<10;i++{

    //  file.WriteString(fmt.Sprintf("hello %d\n",i))

    //  file.WriteString("ceshi!!")

    //}

    //bufio 写内容,快

    outputWriter :=bufio.NewWriter(file)

    for i:=0;i<10;i++{

        outputWriter.WriteString(fmt.Sprintf("hello %d",i))

    }

    //把内存中的数据刷新进去

    outputWriter.Flush()

}

6,文件内容的Copy

//copy文件内容

func Copyfile(dstName,srcName string) (written int64,err error)  {

    //dstName 目标文件

    //srcName 源文件

    src,err :=os.Open(srcName)

    fusion_error(err)

    defer src.Close()

    dst,err :=os.OpenFile(dstName,os.O_WRONLY|os.O_CREATE,0644)

    fusion_error(err)

    defer dst.Close()

    return io.Copy(dst,src)

}

7.把文件内容输出到屏幕上

package main

import (

    "os"

    "fmt"

    "io"

)

func cat(filename string)  {

    file,error :=os.Open(filename)

    defer  file.Close()

    if error != nil{

        fmt.Println("---")

        return

    }

    //把文件内容输出到屏幕上

    io.Copy(os.Stdout,file)

}

func main()  {

    if (len(os.Args) == 1 ){

        fmt.Println("请指定文件名")

    }

    for i :=1;i

        cat(os.Args[i])

    }

}

8.带缓冲区的终端读写

package main

import (

    "bufio"

    "fmt"

    "os"

)

func main() {

    fmt.Fprintf(os.Stdout, "%s", "hello world! - unbuffered")

    buf := bufio.NewWriter(os.Stdout)

    fmt.Fprintf(buf, "%s", "hello world! - buffered")

    buf.Flush()

}

命令行参数

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

package main

//命令行参数

import (

    //"os"

    "fmt"

    "flag"

)

var (

    conf string

    level int

)

func init()  {

    flag.StringVar(&conf,"C","D:/test.conf","请指定配置文件路径")

    flag.IntVar(&level,"L",8,"请指定日志级别")

    flag.Parse()

}

func main()  {

    //获取终端输入的值:os.Args 是一个数组

    //for index,val := range os.Args{

    //  fmt.Printf("arg:[%d] = %s\n",index,val)

    //

    //}

    fmt.Printf("conf is :%s",conf)

    fmt.Printf("level is :%d",level)

    //-h 会默认把init中你配置的项都列出来

    //终端操作:cmd_arg.exe -C "e:/DREAM/TEST" -L 5

}

Json序列化/反序列化

Json数据协议

1. 导入包： Import “encoding/json”
2. 序列化: json.Marshal(data interface{})
3. 反序列化: json.UnMarshal(data []byte, v interface{})

package main

import (
   "fmt"
   "math/rand"
   "encoding/json"
   "os"
   "io/ioutil"
)

type Student struct {
   //字段必须大写, 如果小写的话,其他包是读取不到
   Name string `json:"name"`
   Age int `json:"age"`
   Score float32 `json:"score"`
}

func wirtefilejson()  {
   var stus []*Student
   for i:=0;i<300;i++{
      stu :=&Student{
         Name:fmt.Sprintf("stu%d",i),
         Age:rand.Intn(100),
         Score:rand.Float32() * 100,
      }
      stus = append(stus,stu)
   }
   data,error := json.Marshal(stus)
   if error!=nil{
      fmt.Printf("json faile,err:%v\n",error)
      return
   }

   file,error := os.OpenFile("D:/stu.txt",os.O_CREATE|os.O_WRONLY,0664)
   if error!=nil{
      fmt.Printf("OpenFile error :%v\n",error)
      return
   }
   defer file.Close()
   n,error := file.Write(data)
   if error!=nil{
      fmt.Printf("OpenFile error :%v\n",error)
      return
   }
   fmt.Printf("wirte %d, success \n",n)
}

func readfilejson()  {
   file,err :=os.OpenFile("D:/stu.txt",os.O_RDONLY,0664)
   if err!=nil{
      fmt.Printf("file failed err %v",err)
   }
   defer file.Close()
   data,err :=ioutil.ReadAll(file)
   if err!=nil{
      fmt.Printf("read failed err %v",err)
   }
   var stus []*Student
   err = json.Unmarshal(data,&stus)
   if err!=nil{
      fmt.Printf("JSON unmarshal failed err %v",err)
   }
   for i:=0;i<10;i++{
      fmt.Printf("student:%#v\n",stus[i])
   }
}

func main(){
   //wirtefilejson()
    readfilejson()
}

Panic捕获

package main

import (
   "fmt"
   "time"
)

func set( p *int)  {
   *p = 123
}
func test()  {
   defer func() {
      err :=recover()
      if err != nil{
         fmt.Println("panic:%v\n",err)
      }
   }()
   var p *int
   //因为设置p为指针,还需要new来分配内存，,但是这里没有set的就会出错
   //p = new(int)
   set(p)
   fmt.Printf("*p=%d\n",*p)
}

func main()  {
   for {
      test()
      time.Sleep(time.Second)
   }
}