export GOPATH=/Users/yuan/go
export GOBIN=$GOPATH/bin
export PATH=$PATH:$GOBIN

import urllib.request,os; pf = ‘Package Control.sublime-package‘; ipp = sublime.installed_packages_path(); urllib.request.install_opener( urllib.request.build_opener( urllib.request.ProxyHandler()) ); open(os.path.join(ipp, pf), ‘wb‘).write(urllib.request.urlopen( ‘http://sublime.wbond.net/‘ + pf.replace(‘ ‘,‘%20‘)).read()) 2

package main
import (
	"fmt"
)
func main() {
	fmt.Println("hello gopher~")
}

package main
import "fmt"

func main() {
	var hello string = "Hello"
	who := "gopher"
	var s = hello+"," + who
	fmt.Println(s)
}

var name1 string //声明变量
name1 = "tom" //给变量赋值
var name2 string = "tom" //声明变量+赋值
var name3 = "tom" // 声明时同时赋值，可以省略变量类型
name4 := "tom" //短赋值语句
// 多个变量
var x, y, z int
var c, python, java bool
var x, y, z int = 1, 2, 3
var c, python, java = true, false, "no!"
c, python, java := true, false, "no!"

func swap(x, y string) (string, string) {
	return y, x
}

func split(sum int) (x, y int) {
	x = sum * 4/9
	y = sum - x
	return
}

bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的别名
rune // int32 的别名
// 代表一个Unicode码位

float32 float64
complex64 complex128

const Pi = 3.14
const World = "世界"
const Truth = true

for i := 0; i < 10; i++ {
	//do something
}
i := 0
for ; i < 1000; {
	//do something
}
for i < 1000 {
	//do something
} 
for {
	//死循环
}

if x < 0 {
	return x
}
if v := 0; v < 5 {
	return v
}
return 9

	x := 2
	switch x {
	case 1:
		fmt.Println(1)
	case 2:
		fmt.Println(2)
		fallthrough
	case 3:
		fmt.Println(x > 1)
	default:
		fmt.Println("default")
	}

// 结果
// 2
// true

package main
import "fmt"
import "os"
func main() {
	f := createFile("defer-test.txt")
	defer closeFile(f)
	writeFile(f)
}
func createFile(p string) *os.File {
	fmt.Println("creating")
	f, err := os.Create(p)
	if err != nil {
		panic(err)
	}
	return f
}
func writeFile(f *os.File) {
	fmt.Println("writing")
	fmt.Fprintln(f, "data")
}
func closeFile(f *os.File) {
	fmt.Println("closing")
	f.Close()
}

// output
creating
writing
closing

type person struct {
	name string
	age int
}

package main
import "fmt"
type person struct {
	name string
	age  int
}
func main() {
	fmt.Println(person{"Bob", 20})
	fmt.Println(person{name: "Alice", age: 30})
	fmt.Println(person{name: "Fred"})
	fmt.Println(&person{name: "Ann", age: 40})
	s := person{name: "Sean", age: 50}
	fmt.Println(s.name)
	sp := &s
	fmt.Println(sp.age)
	sp.age = 51
	fmt.Println(sp.age)
}


#output
{Bob 20}
{Alice 30}
{Fred 0}
&{Ann 40}
Sean
50
51

package main
import "fmt"
func main() {
	var numbers = make([]int, 3, 5)
	printSlice(numbers)
}
func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}


//output
len=3 cap=5 slice=[0 0 0]

package main
import "fmt"
func main() {
	var countryCapitalMap map[string]string = make(map[string]string)
	/* create a map*/
	// countryCapitalMap = make(map[string]string)
	/* insert key-value pairs in the map*/
	countryCapitalMap["France"] = "Paris"
	countryCapitalMap["Italy"] = "Rome"
	countryCapitalMap["Japan"] = "Tokyo"
	countryCapitalMap["India"] = "New Delhi"
	/* print map using keys*/
	for country := range countryCapitalMap {
		fmt.Println("Capital of", country, "is", countryCapitalMap[country])
	}
	/* test if entry is present in the map or not*/
	capital, ok := countryCapitalMap["United States"]
	/* if ok is true, entry is present otherwise entry is absent*/
	if ok {
		fmt.Println("Capital of United States is", capital)
	} else {
		fmt.Println("Capital of United States is not present")
	}
	/* delete an entry */
	delete(countryCapitalMap, "France")
	fmt.Println("Entry for France is deleted")
	fmt.Println("Updated map")
	/* print map */
	for country := range countryCapitalMap {
		fmt.Println("Capital of", country, "is", countryCapitalMap[country])
	}
}

package main
import "fmt"
func main() {
	nums := []int{2, 3, 4}
	sum := 0
	for _, num := range nums {
		sum += num
	}
	fmt.Println("sum:", sum)
	for i, num := range nums {
		if num == 3 {
			fmt.Println("index:", i)
		}
	}
	kvs := map[string]string{"a": "apple", "b": "banana"}
	for k, v := range kvs {
		fmt.Printf("%s -> %s\n", k, v)
	}
	for k := range kvs {
		fmt.Println("key:", k)
	}
}

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

package main
import "fmt"
type rect struct {
	width, height int
}
func (r *rect) area() int {
	return r.width * r.height
}
func (r rect) perim() int {
	return 2*r.width + 2*r.height
}
func main() {
	r := rect{width: 10, height: 5}
	fmt.Println("area: ", r.area())
	fmt.Println("perim:", r.perim())
	rp := &r
	fmt.Println("area: ", rp.area())
	fmt.Println("perim:", rp.perim())
}



// output
  area:  50
  perim: 30
  area:  50
  perim: 30

package main
import "fmt"
// 函数 adder 返回一个闭包。每个闭包被绑定到自己的 sum 变量上
func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return sum
	}
}
func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}

package main

import "fmt"
import "math"

type geometry interface {
area() float64
perim() float64
}
type rect struct {
width, height float64
}
type circle struct {
radius float64
}

func (r rect) area() float64 {
return r.width * r.height
}
func (r rect) perim() float64 {
return 2*r.width + 2*r.height
}
func (c circle) area() float64 {
return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
return 2 * math.Pi * c.radius
}
func measure(g geometry) {
fmt.Println(g)
fmt.Println(g.area())
fmt.Println(g.perim())
}
func main() {
r := rect{width: 3, height: 4}
c := circle{radius: 5}
measure(r)
measure(c)
}

// output
{3 4}
12
14
{5}
78.53981633974483
31.41592653589793

type error interface {
	Error() string
}

package main
import "errors"
import "fmt"
import "math"
func Sqrt(value float64) (float64, error) {
	if value < 0 {
		return 0, errors.New("Math: negative number passed to Sqrt")
	}
	return math.Sqrt(value), nil
}
func main() {
	result, err := Sqrt(-1)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(result)
	}
	result, err = Sqrt(9)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(result)
	}
}

package main
import "fmt"
func f(from string) {
	for i := 0; i < 3; i++ {
		fmt.Println(from, ":", i)
	}
}
func main() {
	f("direct")
	go f("goroutine")
	go func(msg string) {
		fmt.Println(msg)
	}("going")
	var input string
	fmt.Scanln(&input)
	fmt.Println("done")
}


// output

$ go run goroutines.go
direct : 0
direct : 1
direct : 2
goroutine : 0
going
goroutine : 1
goroutine : 2
<enter>
done

package main
import "fmt"
func main() {
	messages := make(chan string)
	go func() { messages <- "ping" }()
	msg := <-messages
	fmt.Println(msg)
}

package main
import "fmt"
func main() {
	c := make(chan int, 2)
	c <- 1
	c <- 2
	fmt.Println(<-c)
	fmt.Println(<-c)
}

package main
import "fmt"
func main() {
	jobs := make(chan int, 5)
	done := make(chan bool)
	go func() {
		for {
			j, more := <-jobs
			if more {
				fmt.Println("received job", j)
			} else {
				fmt.Println("received all jobs")
				done <- true
				return
			}
		}
	}()
	for j := 1; j <= 3; j++ {
		jobs <- j
		fmt.Println("sent job", j)
	}
	close(jobs)
	fmt.Println("sent all jobs")
	<-done
}

package main
import "time"
import "fmt"
func main() {
	c1 := make(chan string)
	c2 := make(chan string)
	c3 := make(chan string)
	t1 := time.Now().UnixNano()
	go func() {
		time.Sleep(time.Second * 1)
		c1 <- "one"
	}()
	go func() {
		time.Sleep(time.Second * 2)
		c2 <- "two"
	}()
	go func() {
		time.Sleep(time.Second * 2)
		c3 <- "three"
	}()
	for i := 0; i < 3; i++ {
		select {
		case msg1 := <-c1:
			fmt.Println("received", msg1)
		case msg2 := <-c2:
			fmt.Println("received", msg2)
		case msg3 := <-c3:
			fmt.Println("received", msg3)
		}
	}
	t2 := time.Now().UnixNano()
	dt := (t2 - t1) / 1e6
	fmt.Println(dt)
}