func Sscanf

func Sscanf(str string, format string, a ...interface{}) (n int, err error)

package main

import "fmt"

//终端读写

type student struct {

    Name  string

    Age   int

    Score float32

}

func main() {

    var str = "stu01 18 89.92"

    var stu student

    fmt.Sscanf(str, "%s %d %f", &stu.Name, &stu.Age, &stu.Score)

    fmt.Println(stu)

}

func NewReader

func NewReader(rd io.Reader) *Reader

NewReader returns a new Reader whose buffer has the default size.

package main

import (

    "bufio"

    "fmt"

    "os"

)

func main() {

    reader := bufio.NewReader(os.Stdin)

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

    if err != nil {

        fmt.Println("read string,err:", err)

        return

    }

    fmt.Printf("read str succ,ret:%s\n", str)

}

package main

import (

    "bufio"

    "fmt"

    "os"

)

//读取文件

func main() {

    //打开一个文件

    file, err := os.Open("D:/project/src/go_dev/day7/example4/123.log")

    if err != nil {

        fmt.Println("read file err:", err)

        return

    }

    //重点，文件要关闭

    defer file.Close()

    /*

        func NewReaderSize

        func NewReaderSize(rd io.Reader, size int) *Reader

            NewReaderSize returns a new Reader whose buffer has at least the specified size.

            If the argument io.Reader is already a Reader with large enough size, it returns the underlying Reader.

    */

    reader := bufio.NewReader(file)
　　//文件若不是换行结尾，就算出错

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

    if err != nil {

        fmt.Println("read string failed,err:", err)

        return

    }

    fmt.Printf("read str success,result:%s\n", str)

}

    /*

    func (*Reader) ReadString ¶

func (b *Reader) ReadString(delim byte) (string, error)

ReadString reads until the first occurrence of delim in the input, returning a string containing the data up to and including the delimiter.

    If ReadString encounters an error before finding a delimiter, it returns the data read before the error and the error itself (often io.EOF).

    ReadString returns err != nil if and only if the returned data does not end in delim. For simple uses, a Scanner may be more convenient.

     */

package main

import (

    "fmt"

    "os"

)

/*

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

*/

import (

    "bufio"

    "io"

)

type CharCount struct {

    ChCount    int

    NumCount   int

    SpaceCount int

    OtherCount int

}

func main() {

    file, err := os.Open("D:/project/src/go_dev/day7/example4/123.log")

    if err != nil {

        fmt.Println("read file err:", err)

        return

    }

    defer file.Close()

    var count CharCount

    reader := bufio.NewReader(file)

    for {

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

        if err == io.EOF {

            break

        }

        if err != nil {

            fmt.Printf("read file failed,err:%v", err)

            break

        }

        runeArr := []rune(str)

        for _, v := range runeArr {

            switch {

            case v >= 'a' && v <= 'z':

                fallthrough

            case v >= 'A' && v <= 'Z':

                count.ChCount++

            case v == ' ' || v == '\t':

                count.SpaceCount++

            case v >= '' && v <= '':

                count.NumCount++

            default:

                count.OtherCount++

            }

        }

    }

    fmt.Printf("char count:%d\n", count.ChCount)

    fmt.Printf("num count:%d\n", count.NumCount)

    fmt.Printf("space count:%d\n", count.SpaceCount)

    fmt.Printf("other count:%d\n", count.OtherCount)

}

字符统计

package main

import (

    "bufio"

    "fmt"

    "os"

)

func main(){

    outputFile,outputError:=os.OpenFile("output.dat",os.O_WRONLY|os.O_CREATE,)

    if outputError!=nil{

        fmt.Printf("An error occurred with file crea ion\n")

        return

    }

    //在函数执行结束前，一定要关闭，谨记

    defer outputFile.Close()

    outputWriter:=bufio.NewWriter(outputFile)

    outputString:="hello world!\n"

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

        outputWriter.WriteString(outputString)

    }

    outputWriter.Flush()//刷新落地

}

package main

import (

    "fmt"

    "io"

    "os"

)

func main() {

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

    w, err := CopyFile(os.Args[], os.Args[])

    if err != nil {

        fmt.Println(err.Error())

    }

    fmt.Println(w)

}

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, )

    if err != nil {

        return

    }

    defer dst.Close()

    //把src内容写进dst里面

    return io.Copy(dst, src)

}

package main

import (

    "fmt"

    "os"

)

func main() {

    fmt.Printf("len of args:%d\n", len(os.Args))

    for i, v := range os.Args {

        fmt.Printf("args[%d]=%s\n", i, v)

    }

}

package main

import (

    "flag"

    "fmt"

)

//flag包支持命令行参数

func main() {

    var confPath string

    var logLevel int

    flag.StringVar(&confPath, "c", "", "Please input conf path")

    flag.IntVar(&logLevel, "d", , "PLEASE INPUT LOG LEVEL")

    flag.Parse()

    fmt.Println("path：", confPath)

    fmt.Println("log leve：", logLevel)

}