go学习笔记

未分类

GOROOT：Go 语言安装根目录的路径，也就是 GO 语言的安装路径。
GOPATH：若干工作区目录的路径。是我们自己定义的工作空间。
GOBIN：GO 程序生成的可执行文件（executable file）的路径。

可以把 GOPATH 简单理解成 Go 语言的工作目录，它的值是一个目录的路径，也可以是多个目录路径，每个目录都代表 Go 语言的一个工作区（workspace）。

GOPATH

GOPATH 环境变量指定了你的工作空间位置。它或许是你在开发Go代码时， 唯一需要设置的环境变量。

$ mkdir $HOME/work
$ export GOPATH=$HOME/work

export PATH=$PATH:$GOPATH/bin

语法

包变量和函数

package中的导出与未导出区别

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。

pizza 和 pi 并未以大写字母开头，所以它们是未导出的。

在导入一个包时，你只能引用其中已导出的名字。任何“未导出”的名字在该包外均无法访问。

函数声明

函数可以没有参数或接受多个参数。
注意类型在变量名 之后。

func add(x int, y int) int {
    return x + y
}
func main() {
    fmt.Println(add(42, 13))
}

函数可以返回任意数量的返回值。

func swap(x, y string) (string, string) {
    return y, x
}
func main() {
    a, b := swap("hello", "world")
    fmt.Println(a, b)
}

变量声明

var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。
变量声明也可以“分组”成一个语法块。

var c, python, java bool
var i, j int = 1, 2
const Pi = 3.14
var (
    ToBe   bool       = false
    MaxInt uint64     = 1<<64 - 1
    z      complex128 = cmplx.Sqrt(-5 + 12i)
)
#当右值声明了类型时，新变量的类型与其相同：
var i int
j := i // j 也是一个 int

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。

    var i, j int = 1, 2
    k := 3
    c, python, java := true, false, "no!"

备注：
当slice时， 不采用var声明，直接 s := []int{2,3,5,7} 则是正确的。 采用var 在 s 之前反而是错误的。

流程控制

for

Go 只有一种循环结构：for 循环。

基本的 for 循环由三部分组成，它们用分号隔开：
初始化语句：在第一次迭代前执行
条件表达式：在每次迭代前求值
后置语句：在每次迭代的结尾执行

和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号， 大括号 { } 则是必须的。

如果省略循环条件，该循环就不会结束，因此无限循环可以写得很紧凑。

    sum := 0
    for i := 0; i < 10; i++ {
        sum += i
    }
    sum := 1
    for ; sum < 1000; {
        sum += sum
    }
func main() {
    for {
    }
}

if

Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在 if 之内。

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        return v
    }
    return lim
}

switch

switch 是编写一连串 if - else 语句的简便方法。它运行第一个值等于条件表达式的 case 语句。
Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。 除非以 fallthrough 语句结束，否则分支会自动终止。
switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。

Go 只运行选定的 case，而非之后所有的 case。
Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

    switch os := runtime.GOOS; os {
    case "darwin":
        fmt.Println("OS X.")
    case "linux":
        fmt.Println("Linux.")
    default:
        // freebsd, openbsd,
        // plan9, windows...
        fmt.Printf("%s.\n", os)
    }
##没有条件的 switch 同 switch true 一样.这种形式能将一长串 if-then-else 写得更加清晰。  
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("Good morning!")
    case t.Hour() < 17:
        fmt.Println("Good afternoon.")
    default:
        fmt.Println("Good evening.")
    }   

defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

func main() {
    defer fmt.Println("world")
    fmt.Println("hello")
}

推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

更多类型

指针

类型 *T 是指向 T 类型值的指针。其零值为 nil。

类型 *T 是指向 T 类型值的指针。其零值为 nil。

var p *int
& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i
* 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21 // 通过指针 p 设置 i

struct

一个结构体（struct）就是一组字段（field）
结构体字段使用点号来访问。

type Vertex struct {
    X int
    Y int
}
    v := Vertex{1, 2}
    v.X = 4
    fmt.Println(v.X)
var (
    v1 = Vertex{1, 2}  // 创建一个 Vertex 类型的结构体
    v2 = Vertex{X: 1}  // Y:0 被隐式地赋予
    v3 = Vertex{}      // X:0 Y:0
    p  = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体（指针）
)

结构体字段可以通过结构体指针来访问。

如果我们有一个指向结构体的指针 p，那么可以通过 (*p).X 来访问其字段 X。不过这么写太啰嗦了，所以语言也允许我们使用隐式间接引用，直接写 p.X 就可以。

    v := Vertex{1, 2}
    p := &v
    p.X = 1e9
    fmt.Println(v)

数组

类型 [n]T 表示拥有 n 个 T 类型的值的数组。

var a [10]int
会将变量 a 声明为拥有 10 个整数的数组。

数组的长度是其类型的一部分，因此数组不能改变大小。

    var a [2]string
    a[0] = "Hello"
    a[1] = "World"
    fmt.Println(a[0], a[1])
    fmt.Println(a)
    primes := [6]int{2, 3, 5, 7, 11, 13}
    fmt.Println(primes)

package main
import (  
    "fmt"
)
func modify(arr *[3]int) {  
    arr[0] = 90                //   (*arr)[0] = 90
}
func main() {  
    a := [3]int{89, 90, 91}
    modify(&a)
    fmt.Println(a)
}

a[x] 是 (*a)[x] 的简写形式，因此上面代码中的 (*arr)[0] 可以替换为 arr[0]。

切片 slice

切片则为数组元素提供动态大小的、灵活的视角。在实践中，切片比数组更常用。
切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。

类型 []T 表示一个元素类型为 T 的切片。

切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔：
a[low : high]

以下表达式创建了一个切片，它包含 a 中下标从 1 到 3 的元素：
a[1:4]

备注：下标从0开始计算。

切片就像数组的引用

    names := [4]string{
        "John",
        "Paul",
        "George",
        "Ringo",
    }
    fmt.Println(names)
    a := names[0:2]
    b := names[1:3]
    fmt.Println(a, b)
    b[0] = "XXX"
    fmt.Println(a, b)
    fmt.Println(names)   // [John XXX George Ringo]

切片文法类似于没有长度的数组文法。

这是一个数组文法：

[3]bool{true, true, false}
下面这样则会创建一个和上面相同的数组，然后构建一个引用了它的切片：

[]bool{true, true, false}

在进行切片时，你可以利用它的默认行为来忽略上下界。

切片下界的默认值为 0，上界则是该切片的长度。

对于数组

var a [10]int
来说，以下切片是等价的：

a[0:10]
a[:10]
a[0:]
a[:]

切片的零值是 nil。

nil 切片的长度和容量为 0 且没有底层数组。

切片可以用内建函数 make 来创建，这也是你创建动态数组的方式。

make 函数会分配一个元素为零值的数组并返回一个引用了它的切片：

追加切片元素

    // 这个切片会按需增长
    s = append(s, 1)
    printSlice(s)
    // 可以一次性添加多个元素
    s = append(s, 2, 3, 4)

range

for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

    for i, v := range pow {
        fmt.Printf("2**%d = %d\n", i, v)
    }

可以将下标或值赋予 _ 来忽略它。

for i, _ := range pow
for _, value := range pow
若你只需要索引，忽略第二个变量即可。
for i := range pow

映射

映射将键映射到值。

映射的零值为 nil 。nil 映射既没有键，也不能添加键。

make 函数会返回给定类型的映射，并将其初始化备用。
var abc map[string]int
abc = make(map[string]int)

#键为string,值为int的map
var timeZone = map[string]int{
    "UTC":  0*60*60,
    "EST": -5*60*60,
    "CST": -6*60*60,
    "MST": -7*60*60,
    "PST": -8*60*60,
}

type Vertex struct {
    Lat, Long float64
}
var m = map[string]Vertex{
    "Bell Labs": Vertex{
        40.68433, -74.39967,
    },
    "Google": Vertex{
        37.42202, -122.08408,
    },
}

在映射 m 中插入或修改元素：
m[key] = elem

获取元素：
elem = m[key]

删除元素：
delete(m, key)

通过双赋值检测某个键是否存在：
elem, ok = m[key]

若 key 在 m 中，ok 为 true ；否则，ok 为 false。

若 key 不在映射中，那么 elem 是该映射元素类型的零值。

同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。( 0 ）

    delete(m, "Answer")
    fmt.Println("The value:", m["Answer"])
    v, ok := m["Answer"]   // 0, false

嵌套的带结构的map

package main
import (
    "fmt"
)
type ssinfo struct {
    sha1sum string
    size    int
}
func main() {
    // 不带struct和带struct的生命
    var data = map[string]map[string]string{}
    var data2 = map[string]map[string]ssinfo{}
    // 初始化
    data["a"] = map[string]string{}
    data["a"] = make(map[string]string)
    data["c"] = make(map[string]string)
    // 初始化nested struct map
    data2["a"] = make(map[string]ssinfo) 
    data2["b"] = map[string]ssinfo{} 
    // 赋值
    data["a"]["a"] = "x"
    data["a"]["b"] = "x"
    data["c"]["w"] = "x"
    data2["a"]["aa"] = ssinfo{"123",35}
    data2["a"]["ab"] = ssinfo{"312",45}
    data2["b"]["ab"] = ssinfo{"312",45}
    fmt.Println(data)
    fmt.Println(data["a"])
    fmt.Println(data2)
    // a中的map, 遍历struct的map
    for k,v := range data2["a"]{
      fmt.Println(k," ",v.sha1sum," ",v.size)
    }
    // ok 表示存在此key, ！ok表示不存在此key.
    elem,ok := data["a"]
    if ok {
      fmt.Println(elem)
    }
}

https://play.golang.org/p/yu8AimIOhei

wordcount的开发测试

https://tour.go-zh.org/moretypes/23
练习：映射
实现 WordCount。它应当返回一个映射，其中包含字符串 s 中每个“单词”的个数。函数 wc.Test 会对此函数执行一系列测试用例，并输出成功还是失败。

你会发现 strings.Fields 很有帮助。

package main
import (
    "golang.org/x/tour/wc"
    "strings"
)
func WordCount(s string) map[string]int {
   ss := strings.Fields(s)
   var abc map[string]int
   abc = make(map[string]int)
    for _,v := range ss{
        abc[v] += 1
    }
    return abc
}
func main() {
    wc.Test(WordCount)
}

函数

函数值
函数也是值。它们可以像其它值一样传递。

函数值可以用作函数的参数或返回值。
https://tour.go-zh.org/moretypes/24

Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值，换句话说，该函数被这些变量“绑定”在一起。
例如，函数 adder 返回一个闭包。每个闭包都被绑定在其各自的 sum 变量上。
https://tour.go-zh.org/moretypes/25

方法和接口

方法

Go 没有类。不过你可以为结构体类型定义方法。
方法就是一类带特殊的 接收者 参数的函数。

方法接收者receivers在它自己的参数列表内，位于 func 关键字和方法名之间。

func (v Vertex) Abs() float64 {
 ...
}

方法即函数 记住：方法只是个带接收者参数的函数。

type Vertex struct {
    X, Y float64
}
func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func main() {
    v := Vertex{3, 4}
    fmt.Println(v.Abs())
}
##### 上下两类的效果相同，一个是v.Abs(), 一个是函数的调用Abs(v)
func Abs(v Vertex) float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
    v := Vertex{3, 4}
    fmt.Println(Abs(v))

你也可以为非结构体类型声明方法。
接收者的类型定义和方法声明必须在同一包内；不能为内建类型声明方法。

https://tour.go-zh.org/methods/3

指针接收者

你可以为指针接收者声明方法。

这意味着对于某类型 T，接收者的类型可以用 *T 的文法。（此外，T 不能是像 *int 这样的指针。）
由于方法经常需要修改它的接收者，指针接收者比值接收者更常用。

https://tour.go-zh.org/methods/4

func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}
func main() {
    v := Vertex{3, 4}
    v.Scale(10) // 由于 Scale 方法有一个指针接收者，为方便起见，Go 会将语句 v.Scale(5) 解释为 (&v).Scale(5)。
    fmt.Println(v.Abs())
}

若使用值接收者，那么 Scale 方法会对原始 Vertex 值的副本进行操作。（对于函数的其它参数也是如此。）Scale 方法必须用指针接受者来更改 main 函数中声明的 Vertex 的值。

上面代码等同于下面：

func Abs(v Vertex) float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func Scale(v *Vertex, f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}
func main() {
    v := Vertex{3, 4}
    Scale(&v, 10)
    fmt.Println(Abs(v))
}

以指针为接收者的方法被调用时，接收者既能为值又能为指针：

var v Vertex
v.Scale(5) // OK
p := &v
p.Scale(10) // OK
对于语句 v.Scale(5)，即便 v 是个值而非指针，带指针接收者的方法也能被直接调用。 也就是说，由于 Scale 方法有一个指针接收者，为方便起见，Go 会将语句 v.Scale(5) 解释为 (&v).Scale(5)。

以值为接收者的方法被调用时，接收者既能为值又能为指针
方法调用 p.Abs() 会被解释为 (*p).Abs()。

选择值或指针作为接收者
使用指针接收者的原因有二：
首先，方法能够修改其接收者指向的值。
其次，这样可以避免在每次调用方法时复制该值。若值的类型为大型结构体时，这样做会更加高效。

接口1

接口指定了一个类型应该具有的方法，并由该类型决定如何实现这些方法。
在 Go 中，并不需要这样。如果一个类型包含了接口中声明的所有方法，那么它就隐式地实现了 Go 接口。

package main
import "oop/employee"
func main() {  
    e := employee.Employee {
        FirstName: "Sam",
        LastName: "Adolf",
        TotalLeaves: 30,
        LeavesTaken: 20,
    }
    e.LeavesRemaining()
}

package employee
import (  
    "fmt"
)
type Employee struct {  
    FirstName   string
    LastName    string
    TotalLeaves int
    LeavesTaken int
}
func (e Employee) LeavesRemaining() {  
    fmt.Printf("%s %s has %d leaves remaining", e.FirstName, e.LastName, (e.TotalLeaves - e.LeavesTaken))
}

workspacepath -> oop -> employee -> employee.go
workspacepath -> oop -> main.go

接口2

接口类型 是由一组方法签名定义的集合。

接口类型的变量可以保存任何实现了这些方法的值。

type Abser interface {
    Abs() float64
}

接口与隐式实现

类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明，也就没有“implements”关键字。

隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。
https://tour.go-zh.org/methods/10

type I interface {
    M()
}
type T struct {
    S string
}
// 此方法表示类型 T 实现了接口 I，但我们无需显式声明此事。
func (t T) M() {
    fmt.Println(t.S)
}

接口值
接口也是值。它们可以像其它值一样传递。
接口值可以用作函数的参数或返回值。

https://tour.go-zh.org/methods/11

空接口
指定了零个方法的接口值被称为 空接口：

interface{}

Empty interfaces are used by code that handles values of unknown type.
可以用来处理任意未知类型的值.
https://tour.go-zh.org/methods/14

func main() {
    var i interface{}
    describe(i)
    i = 42
    describe(i)
    i = "hello"
    describe(i)
}
func describe(i interface{}) {
    fmt.Printf("(%v, %T)\n", i, i)
}

实现接口的练习

Stringer
fmt 包中定义的 Stringer 是最普遍的接口之一。

type Stringer interface {
String() string
}
Stringer 是一个可以用字符串描述自己的类型。fmt 包（还有很多包）都通过此接口来打印值。

import "fmt"
type IPAddr [4]byte
// TODO: 给 IPAddr 添加一个 "String() string" 方法
func (ip IPAddr)String() string{
    return fmt.Sprintf("%v.%v.%v.%v",ip[0],ip[1],ip[2],ip[3])
}
func main() {
    hosts := map[string]IPAddr{
        "loopback":  {127, 0, 0, 1},
        "googleDNS": {8, 8, 8, 8},
    }
    for name, ip := range hosts {
        fmt.Printf("%v: %v\n", name, ip)
    }
}

Type assertions 类型断言

类型断言 提供了访问接口值底层具体值的方式。

t := i.(T)
该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。

若 i 并未保存 T 类型的值，该语句就会触发一个恐慌。

为了 判断 一个接口值是否保存了一个特定的类型，类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值。

t, ok := i.(T)

错误

与 fmt.Stringer 类似，error 类型是一个内建接口：

type error interface {
Error() string
}

通常函数会返回一个 error 值，调用的它的代码应当判断这个错误是否等于 nil 来进行错误处理。

i, err := strconv.Atoi("42")
if err != nil {
fmt.Printf("couldn't convert number: %v\n", err)
return
}
fmt.Println("Converted integer:", i)
error 为 nil 时表示成功；非 nil 的 error 表示失败。

有疑问的错误实现

package main
import (
    "fmt"
    "time"
)
type MyError struct {
    When time.Time
    What string
}
func (e *MyError) Error() string {
    return fmt.Sprintf("at %v, %s",
        e.When, e.What)
}
// e MyError 和 & 可以都去掉，保持原样运行正常。
func run() error {
    return &MyError{   // 为何此处要采用 & ？  指针接受者？
        time.Now(),
        "it didn't work",
    }
}
func main() {
    if err := run(); err != nil {
        fmt.Println(err)
    }
}

Reader 看不懂，下次学习

io 包指定了 io.Reader 接口，它表示从数据流的末尾进行读取。
https://tour.go-zh.org/methods/21

并发

goroutine

Go 程（goroutine）是由 Go 运行时管理的轻量级线程。

go f(x, y, z)
会启动一个新的 Go 程并执行

Channels 信道

信道是带有类型的管道，你可以通过它用信道操作符 <- 来发送或者接收值。

ch <- v // 将 v 发送至信道 ch。
v := <-ch // 从 ch 接收值并赋予 v。
（“箭头”就是数据流的方向。）

和映射与切片一样，信道在使用前必须创建：

ch := make(chan int)

默认情况下，发送和接收操作在另一端准备好之前都会阻塞。这使得 Go 程可以在没有显式的锁或竞态变量的情况下进行同步。

https://tour.go-zh.org/concurrency/2

range 和 close
发送者可通过 close 关闭一个信道来表示没有需要发送的值了。接收者可以通过为接收表达式分配第二个参数来测试信道是否被关闭：若没有值可以接收且信道已被关闭，那么在执行完

v, ok := <-ch
之后 ok 会被设置为 false。

循环 for i := range c 会不断从信道接收值，直到它被关闭。

注意： 只有发送者才能关闭信道，而接收者不能。向一个已经关闭的信道发送数据会引发程序恐慌（panic）。

还要注意： 信道与文件不同，通常情况下无需关闭它们。只有在必须告诉接收者不再有需要发送的值时才有必要关闭，例如终止一个 range 循环。

接下来如何开始实践？

https://tour.go-zh.org/concurrency/11

你可以从安装 Go 开始。

一旦安装了 Go，Go 文档是一个极好的 应当继续阅读的内容。 它包含了参考、指南、视频等等更多资料。

了解如何组织 Go 代码并在其上工作，参阅此视频，或者阅读如何编写 Go 代码。

如果你需要标准库方面的帮助，请参考包手册。如果是语言本身的帮助，阅读语言规范是件令人愉快的事情。

进一步探索 Go 的并发模型，参阅 Go 并发模型(幻灯片)以及深入 Go 并发模型(幻灯片)并阅读通过通信共享内存的代码之旅。

想要开始编写 Web 应用，请参阅一个简单的编程环境(幻灯片)并阅读编写 Web 应用的指南。

函数：Go 中的一等公民展示了有趣的函数类型。

Go 博客有着众多关于 Go 的文章和信息。

开发注意事项

GOPATH 环境变量指定了你的工作空间位置。它或许是你在开发Go代码时， 唯一需要设置的环境变量。

可执行命令必须使用 package main。

实效Go编程
https://go-zh.org/doc/effective_go.html

安装

ubuntu 新版本及旧版本go自动安装

https://github.com/golang/go/wiki/Ubuntu

sudo add-apt-repository ppa:longsleep/golang-backports
sudo apt-get update
sudo apt-get install golang-go

旧版本可以看链接

official

https://golang.org/doc/install#install

Download the archive and extract it into /usr/local, creating a Go tree in /usr/local/go. For example:

tar -C /usr/local -xzf go$VERSION.$OS-$ARCH.tar.gz

export PATH=$PATH:/usr/local/go/bin

可以参考 下面 ubuntu的脚本

ubuntu

用于解决：
package context: unrecognized import path "context" (import path does not begin with hostname)

https://github.com/golang/dep/issues/1985

ubuntu 16.04 && go1.11

sudo apt-get purge golang*
sudo rm -rf /usr/lib/go-1.6/ /usr/lib/go-1.6/src/ /usr/lib/go-1.6/src/runtime/ /usr/lib/go-1.6/src/runtime/race
curl -O https://storage.googleapis.com/golang/go1.11.1.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.11.1.linux-amd64.tar.gz
mkdir -p ~/go; echo "export GOPATH=$HOME/go" >> ~/.bashrc
echo "export PATH=$PATH:$HOME/go/bin:/usr/local/go/bin" >> ~/.bashrc
source ~/.bashrc

go1.13

sudo apt-get purge golang*
sudo rm -rf /usr/lib/go-1.6/ /usr/lib/go-1.6/src/ /usr/lib/go-1.6/src/runtime/ /usr/lib/go-1.6/src/runtime/race
curl -O https://dl.google.com/go/go1.13.6.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.13.6.linux-amd64.tar.gz
mkdir -p ~/go; echo "export GOPATH=$HOME/go" >> ~/.bashrc
echo "export PATH=$PATH:$HOME/go/bin:/usr/local/go/bin" >> ~/.bashrc
source ~/.bashrc

go1.15

wget https://golang.org/dl/go1.15.linux-386.tar.gz   
tar -C /usr/local -xzf go1.15.linux-386.tar.gz
mkdir -p ~/go; echo "export GOPATH=$HOME/go" >> ~/.bashrc
echo "export PATH=$PATH:$HOME/go/bin:/usr/local/go/bin" >> ~/.bashrc
source ~/.bashrc