作者： 一字马胡
转载标志 【2017-11-21】

更新日志

准备环境

在Mac下，可以使用下面的命令安装golang：

brew install go

完成安装之后，可以命令“go version”来查看安装的go的版本信息。安装go完成之后，就可以开始学习go语言了，为了提高开发效率，建议使用IDE进行开发，但是如果不喜欢IDE也可以不使用，我推荐使用IDEA + plug 的方式来准备开发环境，可以在plug里面搜索go，然后就可以点击安装插件，完成之后就可以进行go开发了。

hello world !

学习一门新语言，首先要写出“hello world”，下面的代码展示了如何使用golang来做这件简单的事情：

import "fmt"

func main() {
    helloWorld := "hello Word from golang!"
    fmt.Print(helloWorld)
}

var for golang

var在go语言中用于定义一个或者多个变量，下面是一些例子：

    var hello string = "hello"
    var id1, id2 int = 1, 2
    
    fmt.Print(hello, id1, id2)

一般可以使用“：=”来定义一个变量并且进行初始化，比如下面的例子：

    ok := "this is a word"
    number := 1024

    fmt.Printf("%s, %d", ok, number)

const for golang

在go中使用const来进行常量的声明，关于go中的常量可以参考：

A const statement can appear anywhere a var statement can.
Constant expressions perform arithmetic with arbitrary precision.
A numeric constant has no type until it’s given one, such as 
by an explicit cast.A number can be given a type by using it in 
a context that requires one, such as a variable assignment or
 function call. For example, here math.Sin expects a float64.

下面是go中使用常量的例子：

    const Kb  = 1024
    const Mb  = Kb * 1024
    const Gb  = Mb * 1024

    fmt.Printf("Kb:%d Mb:%d Gb:%d\n", Kb, Mb, Gb)

loop for golang

在go语言中，没有像其他语言中一样同时存在for、while等循环语法支持，go只支持for语句，下面是使用for循环的示例：

    for i:= 0;i < 10; i ++ {
        fmt.Printf("%d\t" , i)
    }
    fmt.Print("\nEnd of for loop.\n")
    
    for {
        fmt.Print("loop...")
    }

如果想要实现无限循环，可以使用for {}。

if-Else for golang

值得注意的是，在go语言中进行for循环或者if-else语句编写的时候，要和其他语言（比如Java）区分一下，go语言不能在条件上带上（），这一点和其他语言是有所区别的，需要特别注意。下面展示了使用go中的if-else语句的示例：

    size := 1024 * 0.8
    if size > Kb {
        fmt.Printf("%f > %d\n", size, Kb)
    } else {
        fmt.Printf("%f <= %d\n", size, Kb)
    }

    if size := 1024 * 1.1; size > Kb {
        if size > Mb {
            fmt.Printf("%f > %d\n", size, Mb)
        } else {
            fmt.Printf("%d <= %f <= %d", Kb, size, Mb)
        }
    }

可以在go的判断语句中进行变量赋值，这样写代码感觉行云流水，非常流畅，值得推荐。

switch for golang

go语言的switch看起来更加强大，下面是switch的使用示例：

    i := 2
    switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    }
    
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("It's before noon")
    default:
        fmt.Println("It's after noon")
    }

    whatAmI := func(i interface{}) {
        switch t := i.(type) {
        case bool:
            fmt.Println("I'm a bool")
        case int:
            fmt.Println("I'm an int")
        default:
            fmt.Printf("Don't know type %T\n", t)
        }
    }
    whatAmI(true)
    whatAmI(1)
    whatAmI("hey")    

运行上面的代码，输出如下：

two
It's after noon
I'm a bool
I'm an int
Don't know type string

array for golang

下面的代码展示了go语言中数组的使用示例：

    var array1 [10]int
    for i := 0; i < 10 ; i ++ {
        array1[i] = i * 10
    }

    array2 := [2]float64 {0.01, 0.02}
    array2[0] += 1.0
    array2[1] -= 0.002

    var array3 [3][4]int
    for i := 0; i < 3; i ++ {
        for j := 0; j < 4; j ++ {
            array3[i][j] = i * j
        }
    }

Slices for golang

和数组类似，但是和数组不一样，go支持Slices，下面是Slices的使用示例：

创建一个空的Slices并且赋值：

    s := make([]int, 2)
    s[0] = 1
    s[1] = 2

append操作：

    s := make([]int, 2)
    s[0] = 1
    s[1] = 2

    s = append(s, 3, 4, 5)

    for i := 0; i < len(s); i ++ {
        fmt.Printf("%d \t", s[i])
    }
    fmt.Print("\nEnd of prinf\n")

拷贝Slices操作：

    cs := make([]int, len(s))
    copy(cs, s)
    for i := 0; i < len(cs); i ++ {
        fmt.Printf("%d \t", cs[i])
    }
    fmt.Print("\nEnd of prinf\n")

slice操作：

    ss := make([]string, 0)
    ss = append(ss, "a", "b", "c", "d", "e", "f")

    ss1 := ss[1:2]
    ss2 := ss[:4]
    ss3 := ss[3:]

    fmt.Printf("%s ,%s , %s , %s\n", ss, ss1, ss2, ss3)
    
    output：
    
    [a b c d e f] ,[b] , [a b c d] , [d e f]

map for golang

map是一种特别重要的数据结构，平时使用也是比较频繁的，下面的代码展示了go语言中的map的使用方法：

    m := make(map[string]int)
    m["ok"] = 200
    m["error"] = 404

    //delete item from map
    delete(m, "ok")

    is, v:= m["error"]

    fmt.Print(v, is, "\n")

    mp := map[string]int {"a":10, "b": 20}
    fmt.Print(mp, "\n")

Range for golang

下面是使用Range的例子：

    num :=  make([]int, 0)
    num = append(num, 1, 2, 3, 4, 5)
    sum := 0
    for _, s := range num {
        sum += s
    }

    for k, v := range m {
        fmt.Printf("%s, %s\n" , k, v)
    }

    for i, v := range "golang" {
        fmt.Printf("%d->%c\n", i, v)
    }

range像是一个迭代器（和其他语言的迭代器非常类似）。

function for golang

下面的代码展示了go语言中方法的使用示例：

func total(a, b int) int  {
    return a + b
}

fmt.Print("sum:", total(1, 3), "\n")

在go语言的方法设计中，允许有多个返回值，下面是示例：

func multiReturn() (int, string, float32)  {
    return 1, "ok", 0.1
}

    a, b, c := multiReturn()

    fmt.Print("multiReturn:", a, b, c, "\n")

可变参数：

func multiParams(args ...int) int {
    sum := 0
    for _, v := range args {
        sum += v
    }
    
    return sum
}


    is = multiParams(1, 2, 3, 4, 5)
    fmt.Printf("sum: %d\n" , is)

匿名函数：

func getIntValue() func() int {
    i := 0
    return func() int {
        i += 1
        return i
    }
}

    nextInt := getIntValue()

    fmt.Printf("%d, %d, %d\n", nextInt(), nextInt(), nextInt())

pointer for golang

在go语言中，你可以使用指针进行一些操作了，是不是用惯了java就会不习惯呢？下面是示例代码：

    var point *int
    num := 10
    point = &num
    fmt.Print("point:", point, " value:", *point)

struct for golang

可以使用指针，又有struct，是不是和c语言越来越像了呢？下面是使用struct的示例：

    type info struct {
        id int
        name struct{
            firstName string
            lastName string
             }
    }

    var p *info
    p = new(info)
    p.id = 12
    p.name.firstName = "jian"
    p.name.lastName = "hu"

    infoo := new(info)
    infoo.id = 13
    infoo.name.firstName = "haha"
    infoo.name.lastName = "lulu"

    fmt.Print(infoo, "\n")