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

Posted 2020-10-20

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go(day7 [终端读写| 文件操作 | 命令行参数 | Json序列化])相关的知识，希望对你有一定的参考价值。

终端读写

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

os.Stdin:标准输入
os.Stdout:标准输出
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! \n",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\n",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.写文件操作

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

os.O_WRONLY：只写
os.O_CREATE：创建?件
os.O_RDONLY：只读
os.O_RDWR：读写
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\n",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<len(os.Args);i++{

cat(os.Args[i])

}

8.带缓冲区的终端读写

package main

import (

"bufio"

"fmt"

"os"

)

func main() {

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

buf := bufio.NewWriter(os.Stdout)

fmt.Fprintf(buf, "%s\n", "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\n",conf)

fmt.Printf("level is :%d\n",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{})

以上是关于Go(day7 [终端读写| 文件操作 | 命令行参数 | Json序列化])的主要内容，如果未能解决你的问题，请参考以下文章