Go基础–终端操作和文件操作详解编程语言

终端操作

操作终端相关的文件句柄常量
os.Stdin:标准输入
os.Stdout:标准输出
os.Stderr:标准错误输出

关于终端操作的代码例子：

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 enter your full name:") 
    //fmt.Scanln(&firstName,&lastName) 
    fmt.Scanf("%s %s",&firstName,&lastName) //这一句和上一句是相同的 
    fmt.Printf("Hi %s %s!/n",firstName,lastName) 
    fmt.Sscanf(input,format,&f,&i,&s) 
    fmt.Println("From the string we read:",f,i,s) 
 
}

关于带缓冲区的读写

这里需要用到一个包：bufio

下面是代码例子：

package main 
 
import ( 
    "bufio" 
    "os" 
    "fmt" 
) 
 
var inputReader *bufio.Reader 
var input string 
var err error 
 
 
func main(){ 
    inputReader = bufio.NewReader(os.Stdin) 
    fmt.Println("please enter some input:") 
    // 下面这个表示我们读取一行，最后是以/n 为分割的，/n表示换行 
    input,err = inputReader.ReadString('/n') 
    if err != nil{ 
        fmt.Println(err) 
        return 
    } 
    fmt.Printf("the input was:%s/n",input) 
}

练习终端操作

从终端读取一行字符串，统计英文，数字，空格以及其他字符的数量
代码实现：

package main 
 
import ( 
    "fmt" 
    "bufio" 
    "os" 
) 
 
func judgeCount(str string){ 
    var countNum, countLetter, countSpace, countOther int 
    for _, v := range str { 
        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) 
    // 关于其他字符这里进行减一是因为这里多算了一个换行符/n 
    fmt.Println("其他字符的个数：", countOther-1) 
 
} 
 
func main(){ 
    fmt.Println("请输入一行字符串:") 
    var inputReader *bufio.Reader 
    inputReader = bufio.NewReader(os.Stdin) 
    str,err := inputReader.ReadString('/n') 
    if err!=nil{ 
        fmt.Println("输入错误，错误为：",err) 
        return 
    } 
    judgeCount(str) 
}

关于文件读写

os.File封装所有文件相关的操作

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

关于文件操作的一个简单例子：

package main 
 
import ( 
    "os" 
    "fmt" 
    "bufio" 
    "io" 
) 
 
func main(){ 
    file,err:= os.Open("/Users/zhaofan/go_project/src/go_dev/07/ex13/main.go") 
    if err!= nil{ 
        fmt.Println("open file is err:",err) 
        return 
    } 
    //这里切记在打开文件的时候跟上defer 关闭这个文件，防止最后忘记关闭 
    defer file.Close() 
    inputReader := bufio.NewReader(file) 
    for { 
        inputString,readError:= inputReader.ReadString('/n') 
        // 这里readError == io.EOF表示已经读到文件末尾 
        if readError ==io.EOF{ 
            return 
        } 
        // 下面会把每行的内容进行打印 
        fmt.Printf("the input is:%s",inputString) 
    } 
 
}

上面例子中关于读文件是一行一行的读的，下面我们也可以一次性读完整的文件，但是切记如果文件过大，这种方法不适用，这里用到是io/ioutil包

package main 
 
import ( 
    "io/ioutil" 
    "fmt" 
) 
 
func main(){ 
    buf,err := ioutil.ReadFile("/Users/zhaofan/go_project/src/go_dev/07/ex13/main.go") 
    if err != nil{ 
        fmt.Println("read file is err:",err) 
        return 
    } 
    fmt.Printf("%s/n",string(buf)) 
 
}

关于读取压缩文件的例子，这里用到的是compress/gzip包

package main 
 
import ( 
    "os" 
    "fmt" 
    "compress/gzip" 
    "bufio" 
    "io" 
) 
 
func main(){ 
    file,err := os.Open("/Users/zhaofan/go_project/src/go_dev/07/ex6/ggg.gz") 
    if err != nil{ 
        fmt.Println("open file err:",err) 
        return 
    } 
    defer file.Close() 
 
    reader,err :=gzip.NewReader(file) 
    if err != nil{ 
        fmt.Println("gzip err:",err) 
        return 
    } 
    bufReader := bufio.NewReader(reader) 
    for{ 
        line,err := bufReader.ReadString('/n') 
        if err != nil{ 
            if err == io.EOF{ 
                break 
            } 
            fmt.Println("read file err",err) 
            break 
        } 
        fmt.Printf("%s",line) 
    } 
 
}

关于文件的写入

os.OpenFile(“filename”,os.O_WRONLY|os.O_CREATE,066)

第一个参数是文件名
第二个参数是文件的打开模式：
os.O_WRONLY:只写
os.O_CREATE:创建文件
os.O_RDONLY:只读
os.O_RDWR:读写
os.O_TRUNC:清空

第三个参数：权限控制
r–>4
w–>2
x–>1
这里和linux的是一样的

关于写入文件的一个例子，这里写了两种方法一种是直接writestring方法，一种是通过bufio的方式：

package main 
 
import ( 
    "os" 
    "fmt" 
    "bufio" 
) 
 
func testWriteFile(){ 
    file,err:= os.OpenFile("mylog.txt",os.O_WRONLY|os.O_CREATE,0666) 
    if err!= nil{ 
        fmt.Println("open file failed:",err) 
        return 
    } 
    defer file.Close() 
    for i:=0;i<10;i++{ 
        file.WriteString(fmt.Sprintf("go web 开发/n")) 
    } 
 
} 
 
func testWriteBuf(){ 
    file,err:= os.OpenFile("mylog.txt",os.O_WRONLY|os.O_CREATE,0666) 
    if err!= nil{ 
        fmt.Println("open file failed:",err) 
        return 
    } 
    defer file.Close() 
 
    bufioWrite := bufio.NewWriter(file) 
    for i:=0;i<10;i++{ 
        bufioWrite.WriteString("hello/n") 
    } 
    bufioWrite.Flush() 
} 
 
func main(){ 
    //testWriteFile() 
    testWriteBuf() 
}

关于拷贝文件的例子：

package main 
 
import ( 
    "os" 
    "io" 
) 
 
func CopyFile()(writen int64,err error){ 
    src,err:=os.Open("mylog.txt") 
    if err!= nil{ 
        return 
    } 
    defer src.Close() 
    dst,err := os.OpenFile("dst.txt",os.O_WRONLY|os.O_CREATE,0644) 
    if err!=nil{ 
        return 
    } 
    defer dst.Close() 
    return io.Copy(dst,src) 
} 
 
func main(){ 
    CopyFile() 
}

关于获取命令行参数

os.Args是一个string的切片，用来存储所有命令行的参数
但是通过这种方式获取参数有点笨拙，并且需要做很多的判断，我们可以通过go里面的flag包来做，代码例子如下:

package main 
 
import ( 
    "fmt" 
    "flag" 
) 
 
var( 
    conf string 
    level int 
) 
 
func init()  { 
    flag.StringVar(&conf,"c","/home/user/zhaofan","请指定配置文件路径") 
    flag.IntVar(&level,"l",8,"请指定日志级别") 
    flag.Parse() //这个非常重要不能忘记写 
} 
 
func main()  { 
    //for _,val := range os.Args{ 
    //  fmt.Println(val) 
    //} 
 
    fmt.Printf("conf is :%s/n",conf) 
    fmt.Printf("level is :%d/n",level) 
}

上面的例子设置了默认参数，如果我们想自定义参数在运行的时候添加 -c=内容 -l=内容，就可以用我们通过命令行参数传入的值进行处理

原创文章，作者：奋斗，如若转载，请注明出处：https://blog.ytso.com/12396.html