GO FUNDAMENTALS

hello hacker

第一个go代码

package main
import (
    "fmt"
)
func main() {
    fmt.Println("hello blackhat-go")
}

go build -ldflags "-w -s" main.go  # 减小编译文件大小

windows交叉编译

基本语法

变量声名

var x = "Hello World"
z := int(42) //隐式推导类型

切片(slice)和hash表(map)

var s = make([]string, 0)//声名一个string类型切片
var m = make(map[string]string)//声名一个key,value都为string的map
s = append(s, "some string") // append添加元素
m["some key"] = "some value" // 直接赋值

指针

var count = int(42)
ptr := &count
fmt.Println(*ptr)
*ptr = 100
fmt.Println(count)

学习过C的，应该对指针不陌生

结构体

type Person struct {
    Name string
    Age int
   }
func (p *Person) SayHello() {
       fmt.Println("Hello,", p.Name)
   }
func main() {
    var guy =  new(Person)
    guy.Name = "Dave"
    guy.SayHello()
}

这里值得注意的是go语言变量使用大小写首字母来标注成员是否可导出，也就是是否外部可访问，如果首字母大写。则外部可访问，否则不可访问。

接口（interface）

 type Friend interface {
    SayHello()
 }

friend接口声名了一个方法SayHello(),如果实现了SayHello方法，那么他就是一个Friend。如

type Dog struct {}
   func (d *Dog) SayHello(){
       fmt.Println("Woof woof")
   }

func Greet (f Friend) {
    f.SayHello()
}

这里Greet方法要求传入一个Friend，并且会调用SayHello函数。在之前的Person结构体实现了SayHello函数，Dog也实现了SayHello,那么两者都可以传入Greet方法。执行结果

package main
import "fmt"
type Person struct {
    Name string
    Age int
}
func (p *Person) SayHello() {
    fmt.Println("Hello,", p.Name)
}
type Friend interface{
    SayHello()
}
type Dog struct {}
func (d *Dog) SayHello(){
fmt.Println("Woof woof")
}
func Greet (f Friend) {
    f.SayHello()
}
func main() {
    var guy = new(Person)
    guy.Name = "Dave"
    Greet(guy)
    var dog = new(Dog)
    Greet(dog)
}

怎么说呢，有点像多态。。

控制流程

没啥好说的

if x == 1 {
    fmt.Println("X is equal to 1")
} else {
    fmt.Println("X is not equal to 1")
}

这里的条件不需用括号包裹，但控制体必须要用大括号包裹。

switch x {
    case "foo":
        fmt.Println("Found foo")
    case "bar":
        fmt.Println("Found bar")
    default:
        fmt.Println("Default case")
}

for循环

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

另外一种形式

nums := []int{2,4,6,8}
   for idx, val := range nums {
       fmt.Println(idx, val)
   }

这里的idx和val分别为切片的index和值，需要注意的是原文为copy of the current value`` at that index,说明它只是一个拷贝，对其修改不会修改原值。

并发

func f() {
    fmt.Println("f function")
    time.Sleep(2 * time.Second)
    fmt.Println("f complete")
}
func main() {
    go f()
    fmt.Println("main function")
    time.Sleep(3 * time.Second)
}

chan

unc strlen(s string, c chan int)  {
    c <- len(s)
}
func main() {
    c := make(chan int)
    go strlen("hello hacker",c)
    go strlen("hacker",c)
    x,y:=<-c,<-c // 这里进行阻塞直到能够拿到数据再解除阻塞。
    fmt.Println(x,y,x+y)
}

错误处理

func foo() error {
    return errors.New("Some Error Occurred")
}
func main() {
    if err := foo();err != nil {
        fmt.Println(err)
    }else {
        fmt.Println("success")
    }
}

JSON&XML

type Foo struct {
    Bar string
    Baz string
}
func main() {
    f := Foo{"Joe Junior", "Hello Shabado"}
    b, _:= json.Marshal(f)
    fmt.Println(string(b))
    json.Unmarshal(b, &f)
    fmt.Println(f.Bar)
}

type Foo struct {
    Bar     string    `xml:"id,attr"`
    Baz     string    `xml:"parent>child"`
}
func main() {
    f := Foo{"Joe Junior", "Hello Shabado"}
    b, _:= xml.Marshal(f)
    fmt.Println(string(b))
    xml.Unmarshal(b, &f)
    fmt.Println(f.Bar)
}