golang begin

1. install go

 

2. configure sublime
http://blog.csdn.net/cyxcw1/article/details/10329481

 

3.io package

1) io.Reader

// io.Reader 接口示例
package main

import (
    "fmt"
    "io"
    "os"
    "strings"
)

func main() {
FOREND:
    for {
        readerMenu()

        var ch string
        fmt.Scanln(&ch)
        var (
            data []byte
            err  error
        )
        switch strings.ToLower(ch) {
        case "1":
            fmt.Println("请输入不多于9个字符，以回车结束：")
            data, err = ReadFrom(os.Stdin, 11)
        case "2":
            file, err := os.Open("D:/src/read.go")
            if err != nil {
                fmt.Println("打开文件 read.go:", err)
                continue
            }
            data, err = ReadFrom(file, 9)
            file.Close()
        case "3":
            data, err = ReadFrom(strings.NewReader("from string"), 12)
        case "4":
            fmt.Println("暂未实现！")
        case "b":
            fmt.Println("返回上级菜单！")
            break FOREND
        case "q":
            fmt.Println("程序退出！")
            os.Exit(0)
        default:
            fmt.Println("输入错误！")
            continue
        }

        if err != nil {
            fmt.Println("数据读取失败，可以试试从其他输入源读取！")
        } else {
            fmt.Printf("读取到的数据是：%s\n", data)
        }
    }
}

func ReadFrom(reader io.Reader, num int) ([]byte, error) {
    p := make([]byte, num)
    n, err := reader.Read(p)
    if n > 0 {
        return p[:n], nil
    }
    return p, err
}

func readerMenu() {
    fmt.Println("")
    fmt.Println("*******从不同来源读取数据*********")
    fmt.Println("*******请选择数据源，请输入：*********")
    fmt.Println("1 表示 标准输入")
    fmt.Println("2 表示 普通文件")
    fmt.Println("3 表示 从字符串")
    fmt.Println("4 表示 从网络")
    fmt.Println("b 返回上级菜单")
    fmt.Println("q 退出")
    fmt.Println("***********************************")
}

 

interface:

C:\Go\src\pkg\io\io.go

// Reader is the interface that wraps the basic Read method.
//
// Read reads up to len(p) bytes into p.  It returns the number of bytes
// read (0 <= n <= len(p)) and any error encountered.  Even if Read
// returns n < len(p), it may use all of p as scratch space during the call.
// If some data is available but not len(p) bytes, Read conventionally
// returns what is available instead of waiting for more.
//
// When Read encounters an error or end-of-file condition after
// successfully reading n > 0 bytes, it returns the number of
// bytes read.  It may return the (non-nil) error from the same call
// or return the error (and n == 0) from a subsequent call.
// An instance of this general case is that a Reader returning
// a non-zero number of bytes at the end of the input stream may
// return either err == EOF or err == nil.  The next Read should
// return 0, EOF regardless.
//
// Callers should always process the n > 0 bytes returned before
// considering the error err.  Doing so correctly handles I/O errors
// that happen after reading some bytes and also both of the
// allowed EOF behaviors.
//
// Implementations of Read are discouraged from returning a
// zero byte count with a nil error, and callers should treat
// that situation as a no-op.
type Reader interface {
    Read(p []byte) (n int, err error)
}

 

implements:

C:\Go\src\pkg\os\file.go

// Stdin, Stdout, and Stderr are open Files pointing to the standard input,
// standard output, and standard error file descriptors.
var (
    Stdin  = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
    Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
    Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
)

// Read reads up to len(b) bytes from the File.
// It returns the number of bytes read and an error, if any.
// EOF is signaled by a zero count with err set to io.EOF.
func (f *File) Read(b []byte) (n int, err error) {
    if f == nil {
        return 0, ErrInvalid
    }
    n, e := f.read(b)
    if n < 0 {
        n = 0
    }
    if n == 0 && len(b) > 0 && e == nil {
        return 0, io.EOF
    }
    if e != nil {
        err = &PathError{"read", f.name, e}
    }
    return n, err
}

 

C:\Go\src\pkg\strings\reader.go

package strings

import (
    "errors"
    "io"
    "unicode/utf8"
)

// A Reader implements the io.Reader, io.ReaderAt, io.Seeker, io.WriterTo,
// io.ByteScanner, and io.RuneScanner interfaces by reading
// from a string.
type Reader struct {
    s        string
    i        int // current reading index
    prevRune int // index of previous rune; or < 0
}


func (r *Reader) Read(b []byte) (n int, err error) {
    if len(b) == 0 {
        return 0, nil
    }
    if r.i >= len(r.s) {
        return 0, io.EOF
    }
    n = copy(b, r.s[r.i:])
    r.i += n
    r.prevRune = -1
    return
}

 

2) io.Writer

interface

 C:\Go\src\pkg\io\io.go

// Writer is the interface that wraps the basic Write method.
//
// Write writes len(p) bytes from p to the underlying data stream.
// It returns the number of bytes written from p (0 <= n <= len(p))
// and any error encountered that caused the write to stop early.
// Write must return a non-nil error if it returns n < len(p).
type Writer interface {
    Write(p []byte) (n int, err error)
}

 

implements

C:\Go\src\pkg\os\file.go

// Write writes len(b) bytes to the File.
// It returns the number of bytes written and an error, if any.
// Write returns a non-nil error when n != len(b).
func (f *File) Write(b []byte) (n int, err error) {
    if f == nil {
        return 0, ErrInvalid
    }
    n, e := f.write(b)
    if n < 0 {
        n = 0
    }

    epipecheck(f, e)

    if e != nil {
        err = &PathError{"write", f.name, e}
    }
    return n, err
}

 

 3) test

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    inFile, err := os.Open("d:/src/read.go")
    if err != nil {
        fmt.Println("can't open file d:/src/read.go")
        os.Exit(1)               //???????
    }
    defer inFile.Close()

    outFile, err := os.Create("d:/src/output.txt")
    if err != nil {
        fmt.Println("can't create file d:/src/output.txt")
        os.Exit(1)
    }
    defer outFile.Close()

    for {
        buf := make([]byte, 20)
        n, err := inFile.Read(buf)
        if n == 0 && err == io.EOF {     //???????
28             fmt.Println("Done")
29             return
30         }
        if err != nil {
            fmt.Println("error occurs during reading")
            os.Exit(2)
        }

        _, err = outFile.Write(buf[:n])   //????????
        if err != nil {
            fmt.Println("error occurs during writing")
            os.Exit(3)
        }
    }

}

 

 

4. package os,log,  encoding/json

// Unmarshal parses the JSON-encoded data and stores the result
// in the value pointed to by v.
//
// Unmarshal uses the inverse of the encodings that
// Marshal uses, allocating maps, slices, and pointers as necessary,
// with the following additional rules:
//
// To unmarshal JSON into a pointer, Unmarshal first handles the case of
// the JSON being the JSON literal null.  In that case, Unmarshal sets
// the pointer to nil.  Otherwise, Unmarshal unmarshals the JSON into
// the value pointed at by the pointer.  If the pointer is nil, Unmarshal
// allocates a new value for it to point to.
//
// To unmarshal JSON into a struct, Unmarshal matches incoming object
// keys to the keys used by Marshal (either the struct field name or its tag),
// preferring an exact match but also accepting a case-insensitive match.
//
// To unmarshal JSON into an interface value,
// Unmarshal stores one of these in the interface value:
//
//    bool, for JSON booleans
//    float64, for JSON numbers
//    string, for JSON strings
//    []interface{}, for JSON arrays
//    map[string]interface{}, for JSON objects
//    nil for JSON null
//
// If a JSON value is not appropriate for a given target type,
// or if a JSON number overflows the target type, Unmarshal
// skips that field and completes the unmarshalling as best it can.
// If no more serious errors are encountered, Unmarshal returns
// an UnmarshalTypeError describing the earliest such error.
//
// When unmarshaling quoted strings, invalid UTF-8 or
// invalid UTF-16 surrogate pairs are not treated as an error.
// Instead, they are replaced by the Unicode replacement
// character U+FFFD.
//
func Unmarshal(data []byte, v interface{}) error {
    // Check for well-formedness.
    // Avoids filling out half a data structure
    // before discovering a JSON syntax error.
    var d decodeState
    err := checkValid(data, &d.scan)
    if err != nil {
        return err
    }

    d.init(data)
    return d.unmarshal(v)
}

// Unmarshaler is the interface implemented by objects
// that can unmarshal a JSON description of themselves.
// The input can be assumed to be a valid encoding of
// a JSON value. UnmarshalJSON must copy the JSON data
// if it wishes to retain the data after returning.
type Unmarshaler interface {
    UnmarshalJSON([]byte) error
}