golang begin

 1 // io.Reader 接口示例
 2 package main
 3 
 4 import (
 5 "fmt"
 6 "io"
 7 "os"
 8 "strings"
 9 )
10 
11 func main() {
12 FOREND:
13 for {
14  readerMenu()
15 
16 var ch string
17 fmt.Scanln(&ch)
18 var (
19 data []byte
20  err error
21  )
22 switch strings.ToLower(ch) {
23 case "1":
24 fmt.Println("请输入不多于9个字符,以回车结束:")
25 data, err = ReadFrom(os.Stdin, 11)
26 case "2":
27 file, err := os.Open("D:/src/read.go")
28 if err != nil {
29 fmt.Println("打开文件 read.go:", err)
30 continue
31  }
32 data, err = ReadFrom(file, 9)
33  file.Close()
34 case "3":
35 data, err = ReadFrom(strings.NewReader("from string"), 12)
36 case "4":
37 fmt.Println("暂未实现!")
38 case "b":
39 fmt.Println("返回上级菜单!")
40 break FOREND
41 case "q":
42 fmt.Println("程序退出!")
43 os.Exit(0)
44 default:
45 fmt.Println("输入错误!")
46 continue
47  }
48 
49 if err != nil {
50 fmt.Println("数据读取失败,可以试试从其他输入源读取!")
51 } else {
52 fmt.Printf("读取到的数据是:%s\n", data)
53  }
54  }
55 }
56 
57 func ReadFrom(reader io.Reader, num int) ([]byte, error) {
58 p := make([]byte, num)
59 n, err := reader.Read(p)
60 if n > 0 {
61 return p[:n], nil
62  }
63 return p, err
64 }
65 
66 func readerMenu() {
67 fmt.Println("")
68 fmt.Println("*******从不同来源读取数据*********")
69 fmt.Println("*******请选择数据源,请输入:*********")
70 fmt.Println("1 表示 标准输入")
71 fmt.Println("2 表示 普通文件")
72 fmt.Println("3 表示 从字符串")
73 fmt.Println("4 表示 从网络")
74 fmt.Println("b 返回上级菜单")
75 fmt.Println("q 退出")
76 fmt.Println("***********************************")
77 }

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

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

 1 // Read reads up to len(b) bytes from the File.
 2 // It returns the number of bytes read and an error, if any.
 3 // EOF is signaled by a zero count with err set to io.EOF.
 4 func (f *File) Read(b []byte) (n int, err error) {
 5 if f == nil {
 6 return 0, ErrInvalid
 7  }
 8 n, e := f.read(b)
 9 if n < 0 {
10 n = 0
11  }
12 if n == 0 && len(b) > 0 && e == nil {
13 return 0, io.EOF
14  }
15 if e != nil {
16 err = &PathError{"read", f.name, e}
17  }
18 return n, err
19 }

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
}

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

 1 // Write writes len(b) bytes to the File.
 2 // It returns the number of bytes written and an error, if any.
 3 // Write returns a non-nil error when n != len(b).
 4 func (f *File) Write(b []byte) (n int, err error) {
 5 if f == nil {
 6 return 0, ErrInvalid
 7  }
 8 n, e := f.write(b)
 9 if n < 0 {
10 n = 0
11  }
12 
13  epipecheck(f, e)
14 
15 if e != nil {
16 err = &PathError{"write", f.name, e}
17  }
18 return n, err
19 }

 1 package main
 2 
 3 import (
 4 "fmt"
 5 "io"
 6 "os"
 7 )
 8 
 9 func main() {
10 inFile, err := os.Open("d:/src/read.go")
11 if err != nil {
12 fmt.Println("can't open file d:/src/read.go")
13 os.Exit(1) //???????
14  }
15  defer inFile.Close()
16 
17 outFile, err := os.Create("d:/src/output.txt")
18 if err != nil {
19 fmt.Println("can't create file d:/src/output.txt")
20 os.Exit(1)
21  }
22  defer outFile.Close()
23 
24 for {
25 buf := make([]byte, 20)
26 n, err := inFile.Read(buf)
27  if n == 0 && err == io.EOF { //???????
28 fmt.Println("Done")
29 return
30 }
31 if err != nil {
32 fmt.Println("error occurs during reading")
33 os.Exit(2)
34  }
35 
36 _, err = outFile.Write(buf[:n]) //????????
37 if err != nil {
38 fmt.Println("error occurs during writing")
39 os.Exit(3)
40  }
41  }
42 
43 }

 1 // Unmarshal parses the JSON-encoded data and stores the result
 2 // in the value pointed to by v.
 3 //
 4 // Unmarshal uses the inverse of the encodings that
 5 // Marshal uses, allocating maps, slices, and pointers as necessary,
 6 // with the following additional rules:
 7 //
 8 // To unmarshal JSON into a pointer, Unmarshal first handles the case of
 9 // the JSON being the JSON literal null. In that case, Unmarshal sets
10 // the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into
11 // the value pointed at by the pointer. If the pointer is nil, Unmarshal
12 // allocates a new value for it to point to.
13 //
14 // To unmarshal JSON into a struct, Unmarshal matches incoming object
15 // keys to the keys used by Marshal (either the struct field name or its tag),
16 // preferring an exact match but also accepting a case-insensitive match.
17 //
18 // To unmarshal JSON into an interface value,
19 // Unmarshal stores one of these in the interface value:
20 //
21 // bool, for JSON booleans
22 // float64, for JSON numbers
23 // string, for JSON strings
24 // []interface{}, for JSON arrays
25 // map[string]interface{}, for JSON objects
26 // nil for JSON null
27 //
28 // If a JSON value is not appropriate for a given target type,
29 // or if a JSON number overflows the target type, Unmarshal
30 // skips that field and completes the unmarshalling as best it can.
31 // If no more serious errors are encountered, Unmarshal returns
32 // an UnmarshalTypeError describing the earliest such error.
33 //
34 // When unmarshaling quoted strings, invalid UTF-8 or
35 // invalid UTF-16 surrogate pairs are not treated as an error.
36 // Instead, they are replaced by the Unicode replacement
37 // character U+FFFD.
38 //
39 func Unmarshal(data []byte, v interface{}) error {
40 // Check for well-formedness.
41 // Avoids filling out half a data structure
42 // before discovering a JSON syntax error.
43 var d decodeState
44 err := checkValid(data, &d.scan)
45 if err != nil {
46 return err
47  }
48 
49  d.init(data)
50 return d.unmarshal(v)
51 }
52 
53 // Unmarshaler is the interface implemented by objects
54 // that can unmarshal a JSON description of themselves.
55 // The input can be assumed to be a valid encoding of
56 // a JSON value. UnmarshalJSON must copy the JSON data
57 // if it wishes to retain the data after returning.
58 type Unmarshaler interface {
59 UnmarshalJSON([]byte) error
60 }

有疑问加站长微信联系(非本文作者)

• 请尽量让自己的回复能够对别人有帮助
• 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
• 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
• 图片支持拖拽、截图粘贴等方式上传