Go

package main

import (
    "fmt"
)

//基類Base
type Base struct {
    FirstName, LastName string
    Age                 float32
}

//基類的成員方法
func (base *Base) HasFeet() {
    fmt.Println(base.FirstName + base.LastName + "has feet! Base")
}

func (base *Base) Flying() {
    fmt.Println("Base Can flying!")
}

//子類Sub
type Sub struct {
    Base
    Area string
}

//子類的成員方法
func (sub *Sub) Flying() {
    sub.Base.Flying()
    fmt.Println("Sub flying")
}

func (sub *Sub) HasFeet() {
    sub.Base.HasFeet()
    fmt.Println("Sub HasFeet")
}

func main() {
    /*chk := new(Sub)
    chk.Flying()
    chk2 := &Sub{Base{"Bob", "Steven", 2.0}, "China"}
    fmt.Println(chk2.Area)*/

    a := new(Sub) //初始化
    a.Flying()
    b := &Sub{Base{"Lin", "Zhi", 2.0}, "China"}
    b.HasFeet()
}

匿名組合

 

package main

import (
    "fmt"
)

/********************************************************/
//define an interface

type Usb interface {
    getName() string
    connect()
}

/********************************************************/

type Phone struct {
    name string
}

//Phone類型實現Usb接口

func (phone Phone) getName() string {
    return phone.name
}

func (phone Phone) connect() {
    fmt.Println(phone.name, "connect")
}

/********************************************************/

func main() {
    var p Usb //定義一個接口類型的變量 p
    p = Phone{name: "SunXing"}
    p.connect()

    //查詢接口
    if _, ok := p.(Usb); ok {
        fmt.Println("Yes")
    }

    // interface{} 是能夠指向任何對象的 Any 類型
    var a interface{} = Phone{"abc"}
    fmt.Println(a)

    var q1 *Phone
    q1 = &Phone{"def"}
    fmt.Println("gh+" + q1.name)
    q1.connect()

    q := &Phone{"Iphone"}
    p1 := q
    p1.connect()
}

接口

 

package main

import (
    "fmt"
    "time"
    //"time"
)

func Count(ch chan int, i int) {
    fmt.Println("i1:", i)
    ch <- i
    fmt.Println("i2:", i)
}
func main() {
    //    chs := make([]chan int, 5)
    //    for i := 0; i < 5; i++ {
    //        chs[i] = make(chan int)
    //        go Count(chs[i], i)
    //    }

    //    //time.Sleep(3 * time.Second)

    //    for _, ch := range chs {
    //        v := <-ch
    //        fmt.Println("v:", v)
    //    }
    //    //time.Sleep(3 * time.Second)

    chs := make(chan int, 5)
    for i := 0; i < 10; i++ {
        //chs[i] = make(chan int)
        go Count(chs, i)
    }

    //time.Sleep(3 * time.Second)

    for i := 0; i < 5; i++ {
        v := <-chs
        fmt.Println("v:", v)
        //time.Sleep(time.Second * 3)
    }
    fmt.Println("exit")

}

Channel

 

package main

import (
    //    "bytes"
    "fmt"
    "io"
    "net"
    "os"
)

func main() {
    /*if len(os.Args) != 2 {
        fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0])
        os.Exit(1)
    }
    */
    //service := os.Args[1]
    conn, err := net.Dial("tcp", "172.16.8.156:10086")
    checkError(err)
    fmt.Println("1")
    _, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n"))
    checkError(err)
    fmt.Println("1")
    result, err := readFully(conn)
    checkError(err)
    fmt.Println("1")
    fmt.Println((result))
    os.Exit(0)

}
func checkError(err error) {
    if err != nil {
        fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
        //os.Exit(1)
    }
}
func readFully(conn net.Conn) ([]byte, error) {
    //defer conn.Close()
    //result := bytes.NewBuffer(nil)

    //var buf [32]byte
    buf := make([]byte, 512)

    n, err := conn.Read(buf)
    fmt.Println(buf[0:n])
    //result.Write(buf[0:n])
    if err != nil {
        if err == io.EOF {

        }
        //return nil, err
    }

    return buf, nil
}

Socket

 

package main

import (
    //    "flag"
    //    "fmt"
    "net/http"
)

func main() {
    /*    host := flag.String("host", "127.0.0.1", "listen host")
          port := flag.String("port", "80", "listen port")  */

    http.HandleFunc("/hello", Hello)

    err := http.ListenAndServe(":8080", nil)

    if err != nil {
        panic(err)
    }
}

func Hello(w http.ResponseWriter, req *http.Request) {
    w.Write([]byte("Hello World"))
}

服務器

 

// Test project Test.go
package main

import (
    "fmt"
    "go/scanner"
    "go/token"
    "strings"
)

type OnIdent func(ident string, obj string) (float64, bool)

func main() {

    fmt.Println("hello world")

    m := map[string]interface{}{
        "a": 1.5,
        "b": map[string]float64{
            "c": 2,
        },
        "d": 1.2,
        "e": map[string]float64{
            "e1": 5,
        },
    }

    fn := func(ident string, obj string) (float64, bool) {
        val, ok := m[ident]
        var v float64
        switch val.(type) {
        case int:
            if obj != "" {
                return 0, false
            }
            v = float64(val.(int))
        case float64:
            if obj != "" {
                return 0, false
            }
            v = val.(float64)
        case map[string]float64:
            va := val.(map[string]float64)
            _, e := va[obj]
            if !e {
                return 0, e
            }
            v = va[obj]
        default:
        }
        return v, ok
    }

    val, ok := fn("b", "a")
    fmt.Println(val, ok)

    var s scanner.Scanner
    in := "`bg``gd`"
    str1 := strings.Split(in, ".")

    fmt.Println("lenin:", str1[0], len(str1[0]))

    fmt.Println("lenin:", len(in))
    fmt.Println(in)

    fmt.Println(in)

    src := []byte(in)
    fset := token.NewFileSet()
    file := fset.AddFile("", fset.Base(), len(src))
    s.Init(file, src, nil, 0)

    i := 1
    fmt.Println(in)

    //prev := token.ILLEGAL

    for {
        pos, tok, lit := s.Scan()
        if tok == token.EOF {
            break
        }
        fmt.Println("i:", i, "*****", "pos:", pos, "*****", "tok:", tok, "****", "lit=", lit, "*****", len(lit))
        i++
    }
    fmt.Println("dfd", getMax(1, 2, 3, 100, 50))
}

func getMax(num ...float64) (m float64) {
    fmt.Println(num)
    max := 0.0
    if num != nil && len(num) > 1 {
        max = num[0]
        for i := 1; i < len(num); i++ {
            if num[i] > max {
                max = num[i]
            }
        }
    }
    return max
}

Test