go標準入出力とファイル読み書き

通常使用する入出力操作:

func main() {
    fmt.Println(" ")
    var a int
    var b string
    fmt.Scanln(&a, &b)	//　 ( )
    fmt.Scanf("%d %s", &a, &b)	 //  ( )
	
    fmt.Println(a)		//  
    fmt.Printf("a=%d, b=%s", a, b)	//  
}

実はfmt.Fprintf()こそ標準出力装置がコンソールにデータを書き込む標準関数である
上記fmt.Printf(data)はfmtをカプセル化する.Fprintf(io.Writer, data)
だから標準的な書き方はfmt.Fprinf(os.Stdout, data) -- os.Stdoutはコンソールを表し、ioに属する.Writerタイプ
fmt.Fprintf()はもちろんファイルにデータを書くために使用することができ、osを修正するだけでよい.Stdoutは*osです.ファイルタイプの変数でOK

func main() {
    //  
    file, err := os.OpenFile("c:/a.log", os.O_CREATE|os.O_WRONLY, 0)
    if err != nil {
        fmt.Println(" ")
        return
    }
    fmt.Fprintf(file, "abc123222")	//  file 
    file.Close()
    fmt.Fprintf(os.Stdout, "abc123222")  //  ( ) 
}

注:os.Fileはすべてのファイルに関する操作をカプセル化し、以下の操作端末に関する定数は*osである.File
os.stdin標準入力
os.stdout標準出力
os.stderr標準エラー出力
fmt.とFprintf()はfmtに対応する.Fscanf()

func main() {
    var s string 	
    fmt.Fscanf(os.Stdin, "%s", &s) 	//  
    fmt.Println(s)
	
    file, err := os.Open("c:/b.log")
    if err != nil {
        panic(err)
    }
    var a, b, c, d string 

    fmt.Fscanf(file, "%s", &a) 	
    fmt.Fscanf(file, "%s", &b)     //  
    fmt.Fscanf(file, "%s", &c)
    fmt.Fscanf(file, "%s", &d )
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
}

また、fmt.Sscanf(...) 関数は文字列からデータを読み取ることができます(splitよりも強力な分解文字列に相当します)
2番目のパラメータはターゲット文字列をフォーマットしますが、splitは単一の区切り文字に限定されます.

func main() {
    var (
        a, b int
        str, c string
    )
    str =  "10 20,abc"
    fmt.Sscanf(str, "%d %d,%s", &a, &b, &c) //  ,  ,  
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

 
最も基本的な読み取り操作:

func main() {
    file, err := os.Open("c:/a.log")        //  Open 
    if err != nil {
        //  
        return
	}
	defer file.Close()    //  
    var b []byte = make([]byte, 2*1024)    //  ,  
    byts , err := file.Read(b)             //  file b 
    fmt.Println(byts)
}

最も基本的な書き込み操作:

func main() {
    file, err := os.OpenFile("c:/b.log", os.O_CREATE|os.O_WRONLY, 0644)	//  OpenFile 
    if err != nil {
        //  
        return
    }
    defer file.Close()
    
    str := "my name is  , i am in China"
    var b = []byte(str)

    byts , err := file.Write(b)			//  b file 
    fmt.Println(byts)
}

 
バッファ付きファイルへのデータの書き込み:
3つのパラメータがあり、1つ目のパラメータはターゲットファイル、2つ目のパラメータの書き込み方法、3つ目は権限です.
NewWriterを使用して*Writerを作成し、WriterStringでファイルに書き込みます.
キャッシュ領域を操作しているので、ファイルを書き込むときはFlushが必要です.そうしないと書き込みに成功しません.

func main() {
    file, err := os.OpenFile("c:/a.log", os.O_CREATE|os.O_APPEND , 0666)
    defer file.Close()
    if err != nil {
        fmt.Println(" ", err)
    }
    writer := bufio.NewWriter(file)
    num, err2 := writer.WriteString("123")

    writer.Flush()	//  flush,  
    if err2 != nil {
        fmt.Println(" ", err2)
    }
    fmt.Println(" :", num)
}

 
バッファ付き読み取りファイル
ハードディスク(HDD)を直接操作すると、明らかに速度が遅い
バッファを使用すると、メモリバッファを先に操作してからハードディスク(HDDを直接操作するのではなく)にデータをブラシすることで、効率が大幅に向上します.

func main() {
    var reader *bufio.Reader = bufio.NewReader(os.Stdin)
    str, err := reader.ReadString('a')		//  ,  
    if err!= nil {
        fmt.Println("fail")
        return
    }
    fmt.Printf(str)
}

 
ローを読み込む場合は、パラメータを'''に変更します.
ファイルから1行のデータを読み込みます.

func main() {
    file, err := os.Open("c:/a.log")
    if err != nil {
        fmt.Println(" ", err)
        return
    }
    defer file.Close()            //  ,  
    var reader = bufio.NewReader(file)
    str, err2 := reader.ReadString('
')		//  
    if err != nil {
        fmt.Println(" ", err2)
        return
    }
    fmt.Printf(str)
}

例:1つのファイル内のすべての大文字と小文字の数、数値、スペース、その他の文字を統計します.

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

/* ,          */
type Count struct {
    zimu int
    number int
    space int 
    other int
}

func main() {
    file, err := os.Open("c:/a.log")	//  
    if err != nil {
        fmt.Println(" ", err)
        return
    }
    defer file.Close()					//  

    var reader = bufio.NewReader(file)	//   *Reader
    var count *Count = &Count{}
    for {
        str, err2 := reader.ReadString('
')	//  
		
        if err2 == io.EOF {		//  ,  io.EOF 
            fmt.Println(" ")
            break
        }
        if err2 != nil {
            fmt.Println(" ", err2)
            break
        }
				
        /* str  rune */
        array:= []rune(str)
        for _, v := range array {
            switch {
            case v >='a' && v <='z':
                fallthrough
            case v >='A' && v<='Z':
                count.zimu ++
            case v >= '0' && v <='9':
                count.number ++
            case v == ' ' || v=='\t':
                count.space ++
            default:
                count.other ++
            }
        }
    }
    fmt.Println(*count)
}

圧縮ファイルの読み込み:
圧縮ファイルを開き、圧縮ファイルの作成に基づいてReaderを作成します.
bufioを使用してReaderを作成すると、読み取りが可能になります.

func main() {
    gfile, err := os.Open("c:/a.log.gz")	//  
    defer gfile.Close()	
	
    if err != nil {
        fmt.Println(" ", err)
        return
    }

    greader, err := gzip.NewReader(gfile)	//  ,  greader
    var breader = bufio.NewReader(greader)	//  greader breader
	
    for {
        str, err2 := breader.ReadString('
')	//  
        if err2 == io.EOF {
            fmt.Println(" ")
            break
        }
        fmt.Println(str)
    }
}

ファイルコピー:
io.Copy(dest,source)--2つのパラメータWriter,Readerに入力

func main() {
    sourcefile, err := os.Open("c:/a.log")
    if err != nil {
        //  
        return
	}
    defer sourcefile.Close()
    destfile, err2 := os.OpenFile("c:/b.log", os.O_CREATE|os.O_WRONLY, 0644)
    if err2 != nil {
        //  
        return
    }
    defer destfile.Close()

    io.Copy(destfile, sourcefile)
}