書籍：The Way To Go，第二部分

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

Interface

type Shaper interface {     Area() float32}type Square struct {     side float32}func (sq *Square) Area() float32 {     return sq.side * sq.side}func main() {     sq1 := new(Square)     sq1.side = 5     areaIntf := Shaper(sq1)               // areaIntf := sq1     fmt.Printf(“%f\n”, areaIntf.Area())}

r := Rectangle{5, 3}q := &square{5}shapes := []Shaper{r, q}for n, _ := range shapes {     fmt.Println("Shape details: ", shapes[n])     fmt.Println("Area is: ", shapes[n].Area())}

type stockPosition struct {     ticker string     sharePrice float32     count float32}func (s stockPosition) getValue() float32 {     return s.sharePrice * s.count}type car struct {     make string     model string     price float32}func (c car) getValue() float32 {     return c.price}type valuable interface {     getValue() float32}func showValue(asset valuable) {     fmt.Printf(“%f\n”, asset.getValue())}func main() {     var o valuable = stockPosition("GOOG", 577.20, 4)     showValue(o)     o = car{"BMW", "M3", 66500}     showValue(o)}

type File interface {     ReadWrite     Lock     Close()}type ReadWrite interface {     Read(b Buffer) bool     Write(b Buffer) bool}type Lock interface {     Lock()     Unlock()}

switch t := areaIntf.(type) {     case *Square: ...     case *Circle: ...     case float32: ...}func classifier(items ...interface{}) {     for i, x := range items {         switch x.(type) {         case bool:    ...         case int: ...         case nil: ...         }     }}classifier(13, -14.3, “BELGIUM”, nil, false)

type List []intfunc (l List) Len() int { return len(l) }func (l *List) Append(val int) { *l = append(*l, val) }type Appender interface { Append(int) }type Lener interface { Len() int }func CountInto(a Appender, start, end int) {     for i := start; i <= end; i++ {          a.Append(i)     }}func LongEnough(l Lener) bool {     return l.Len()*10 > 42}func main() {     var lst List                // A bare value     // compiler error:     // cannot use lst (type List) as type Appender in function     // argument: List does not implement Appender (Append method      // requires pointer receiver)     // CountInto(lst, 1, 10)        if LongEnough(lst) {        // VALID: Identical receiver type          fmt.Printf(“- lst is long enough”)     }     plst := new(List)           // A pointer value     CountInto(plst, 1, 10)      // VALID: Identical receiver type     if LongEnough(plst) {          fmt.Printf(“- plst is long enough”)     }}

empty interfacetype specialString stringvar whatIsThis specialString = "hello"...testFunc := func(any interface{}) {     switch v := any.(type) {     case string: fmt.Prinf("any %v is a string type", v)     case specialString: fmt.Printf("a specialString type")     ...     }}...var ai AbsInterface              // declares method Abs()type SqrInterface interface { Sqr() float }var si SqrInterfacepp := new(Point)                 // implement AbsInterface & SqrInterfacevar empty interface{}empty = pp;ai = empty.(AbsInterface)si = ai.(SqrInterface)empty = si;

reflect

var x float64 = 3.4fmt.Println(“type:”, reflect.TypeOf(x))   // type: float64v := reflect.ValueOf(x)fmt.Println(“value:”, v)                  // value: <float64 Value>fmt.Println(“type:”, v.Type())            // type: float64fmt.Println(“kind:”, v.Kind())            // kind: float64fmt.Println(“value:”, v.Float())          // value: 3.4fmt.Println(v.Interface())                // 3.4y := v.Interface().(float64)fmt.Println(y)                            // 3.4

reflect.ValueOf(x)v = reflect.ValueOf(&x)v. CanSet()v.SetFloat(3.1415)...t := T{23, "skidoo"}s := reflect.ValueOf(&t).Elem()s.NumField()s.Field(0)

例子節選

for i:= 0; i < 10; i++ {     a := rand.Int()     fmt.Printf(“%d\n”, a)}for I := 0; i < 5; i++ {     r := rand.Int(8)     fmt.Printf(“%d\n”, r)}fmt.Println()timens := int64(time.Now().Nanosecond())rand.Seed(timens)fmt.Printf(“r2.2f\n”, 100*rand.Float32())

func typecheck(..., ..., values ... interface{}) {     for _, value := range values {         switch v := value.(type) {         case int: ...         case float: ...         case string: ...         case bool: ...         default: ...         }     }}

func Fibonacci(n int) (res int) {     if n <= 1 {         res = 1     } else {          res = fibonacci(n-1) + Fibonacci(n-2)     }     return}

// var r *bytes.Buffer = new(bytes.Buffer)var buffer bytes.Bufferfor {     if s; ok := getNextString(); ok {         buffer.WriteString(s)       // append     } else {         break     }}fmt.Print(buffer.String(), “\n”)

// var r *bytes.Buffer = new(bytes.Buffer)var buffer bytes.Bufferfor {     if s; ok := getNextString(); ok {         buffer.WriteString(s)       // append     } else {         break     }}fmt.Print(buffer.String(), "\n")

s1 := "hello"c := []byte(s1)c[0]= 'c's2 := string(c)

type Info struct {     mu sync.Mutex      // sync.RWMutex     Str string}func Update(info *Info) {     info.mu.Lock()     // info.mu.RLock()     //info.Str =  new value     info.mu.Unlock()   // info.mu.RUnlock()/Unlock()}

var once sync.OnceonceBody := func() {     fmt.Println(“Only once”)}done := make(chan bool)for i := 0; i < 10; i++ {    go func() {        once.Do(onceBody)        done <- true    }()}for i := 0; i < 10; i++ {    <-done}

Reading and Writing

fmt.Scanln(&input)fmt.Scanf("%s %s", &firstName, &lastName)fmt.Sscanf("56.12 / 5212 / Go", "%f / %d / %s", &f, &i, &s)

var inputReader *bufio.Readervar input stringvar err errorfunc main() {     inputReader = bufio.NewReader(os.Stdin)     fmt.Println("Please enter some input: ")     input, err = inputReader.ReadString('\n')    // '\n' is included!!!     if err == nil {         fmt.Printf("The input was: %s", input)     }}...switch input { case "Philip\r\n": ... }...buf := make([]byte, 1024)   n, err := inputReader.Read(buf)

// inputFile: *os.FileinputFile, inputError := os.Open("input.dat")defer inputFile.Close()inputReader := bufio.NewReader(inputFile)for {    inputString, readerError := inputReader.ReadString('\n')    ...}

import "io/ioutil"...inputFile, outputFile := "products.txt", "products_copy.txt"buf, err := ioutil.ReadFile(inputFile)if err != nil {     fmt.Fprintf(os.Stderr, "File Error: %s\n", err)}err = ioutil.WriteFile(outputFile, buf, 0x644)if err != nil {     panic(err.Error())}

file, err := os.Open("products2.txt")     // separated by space...var col1, col2, col3 []stringfor {     var v1, v2, v3 string     _, err := fmt.Fscanln(file, &v1, &v2, &v3)     ...}col1 = append(col1, v1)...

import "compress/gzip"...var r *bufio.Readerfi, err := os.Open("MyFile.gz")if err != nil {     fmt.Fprintf(...)     os.Exit(1)}fz, err := gzip.NewReader(fi)if err != nil {     r = bufio.NewReader(fi)} else {     r = bufio.NewReader(fz)}for  {     line, err := r.ReadString('\n')     ...}...import "io"...src, _ := os.Open(srcName)...dst, _ := os.OpenFile(...)io.Copy(dst, src)

outputFile, outputError := os.OpenFile("output.dat", os.O_WRONLY|os.O_CREATE, 0666)outputWriter := bufio.NewWriter(outputFile)outputWriter.WriteString(outputString)outputWriter.Flush()

os.Stdout.WriteString("hello, world\n")f, _ := os.OpenFile("test", os.O_CREATE|os.O_WRONLY, 0)f.WriteString("hello, world in a file\n")     // not buffered

reading arguments from the cmd-line

who := "Alice"if len(os.Args) > 1 {     who += strings.Join(os.Args[1:], " ")}fmt.Println("Good Morning", who)

import "flag"...var NewLine = flag.Bool(“n”, false, “print on newline”)...flag.PrintDefaults()flag.Parse()var s string = ""for i := 0; i < flag.NArg(); i++ {     s += flag.Arg(i)     if *NewLine {         s += "\n"     } else {         s += " "     }}        // a.out –n A B C

json dataformat

type Address struct {     Type string     City string     Country string}...pa := Address{"private", "Aartselaar", "Belgium"}js, _ := json.Marshal(pa)   // json.MarshalForHTML(pa)...file, _ := os.OpenFile("vcard.json", os.O_CREATE|os.O...)enc := json.NewEncoder(file)err := enc.Encode(vc)

b = []byte({"Name": "Wednesday", "Age": 6, "Parents": ["Gomez", "Morticia"]})var f interface{}err := json.Unmarshal(b, &f)map[string]interface{}{          // f     "Name": "Wednesday",     "Age": 6     "Parents": []interface{}{         "Gomez",         "Morticia",     },}

func Unmarshal(data []byte, v interface{})type FamilyMember struct {     Name string     Age int     Parents []string}var m FamilyMembererr := json.Unmarshal(b, &m)

func NewDecoder(r io.Reader) *Decoderfunc NewEncoder(w io.Writer) *Encoderfunc (dec *Decoder) Decode(v interface{}) error

xml dataformat

var t, token xml.Tokenvar err errorfunc main() {     input := "<Person><FirstName>Laura</FirstName>"     input += "<LastName>Lynn</LastName></Person>"     inputReader := strings.NewReader(input)     p := xml.NewParser(inputReader)     for t, err = p.Token(); err == nil; t, err = p.Token() {          switch token := t.(type) {          case xml.StartElement:               name := token.Name.Local               fmt.Printf("Token name: %s\n", name)               for _, attr := range token.Attr {                    attrName := attr.Name.Local                    attrValue := attr.Value                    fmt.Printf(“attribute: %s %s\n”, attrName, attrValue)                    // ...               }          case xml.EndElement:               fmt.Println("End of token")          case xml.CharData:               content := string([]byte(token))               fmt.Printf("The content: %v\n", content)               // ...          default: // ...          }     }}

Cryptography

• package hash:      adler32, crc32, crc64 and fnv

• package crypto:    md4, md5, sha1, aes, blowfish, rc4, rsa, xtea

hasher := sha1.New()io.WriteString(hasher, "test")b := []byte{}fmt.Printf("Result: %x\n", hasher.Sum(b))hasher.Reset()data := []byte("We shall overcome!")n, err := hasher.Write(data)if n != len(data) || err != nil {     log.Printf("Hash write error: %v / %v", n, err)}checksum := hasher.Sum(b)fmt.Printf("Result: %x\n", checksum)