基础
package main
import (
"fmt",
"math/rand"
"math"
)
func main() {
//导出的函数或者值必须大写开头
ftm.Print("My favorite time it", rand.Intn(10))
fmt.Println(math.Pi)
}
定义变量
//变量类型
//rune,int8,int16,int32,int64
//byte,uint8,uint16,uint32,uint64
//rune == int32
//byte == uint8
//go中字符串是不可变的
var s string = "Hello"
s[0] = 'W' //报错
//如果要修改字符串
s := "Hello"
c := []byte(s)//字符串s转化为字符数组
c[0] = 'W'
s2 := string(c) //转化为字符串
//字符串虽然无法改写，但是可以切片
var i, j = 1, 2
var x, y int = 1, 2
k := 3
var (
ToBe bool = false
MaxInt uint64 = 1 << 64 - 1
)
const f = "%T(%v)\\n"
const (
Big = 1 << 100
Small = Big >> 99
)
const (
x = iota //0
y = iota //1
z = iota //2
w //3
)
err = errors.New("emmit a error")
函数
func add(x, y int) int {
return x + y
}
func swap(x, y) (string, string) {
return y, x
}
//裸返回
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
//将函数作为变量
type testInt func(int) bool //申明一个函数类型
循环
sum := 0
for i := 0 ; i < 10; i++ {
sum += i
}
sum := 0
for ;sum < 1000; {
sum += sum
}
sum := 0
for sum < 1000 {
sum += sum
}
//死循环
for {
}
条件语句
if x < 10 {
//.....
}
if v := math.Pow(x, n); v < lim {
//...
} else {
//....
}
import runtime
switch os := runtime.GOOS; os {
case "darwin":
fmt.Println("Mac os")
case "linux":
fmt.Println("Linux.")
default:
fmt.Printf("%s", os)
}
import time
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")
}
指针
i, j := 42, 2701
p := &i
fmt.Println(*p)
*p = 81
//golang中没有指针运算
结构体
type Vertex struct {
X int
Y int
}
//创建结构体对象
v := Vertex{1, 2}
v.X = 12
p = &Vertex{1, 2}
p.X = 12
v := Vertex{X: 1}
数组和切片
var a [10]int //数组
//[3]int和[4]int是不同的类型，数组的长度不可变
c := [...]{4, 5, 6} //自动推算长度
s := []int{2, 3, 4, 5, 6, 7} //切片
for i:=0; i < len(s); i++ {
fmt.Println(s[i])
}
二维切片
game := [][]string{
[]string{"_", "_", "_"},
[]string{"_", "_", "_"},
[]string{"_", "_", "_"},
}
game[0][0] = "X"
game[2][2] = "O"
game[2][0] = "X"
game[1][0] = "O"
game[0][2] = "X"
strings.Join(game[0], " ") //数组变字符串
//对slice切片
s[low:hig] //左闭右开
//构造slice
a := make([]int, 5) //len(a) == 5
b := make([]int, 0, 5) // len(b) = 0, cap(b) = 5
//slice的0值为nil
//向slice添加元素
var a []int
a = append(a, 0) //如果原slice不够长，则创建新slice
var pow = []int{1, 2, 4, 8, 16, 32}
for i, v := range pow {
}
for _,v := range pow{
}
map
type Vertex struct {
Lat, Long float64
}
var m map[string]Vertex
m = make(map[string]Vertex)
var m = map[string]Vertex{
"Bell Labs": {40.68433, -74.39967},
"Google": {37.42202, -122.08408},
}
delete(m, "Bell Labs")
v, ok := m["Bell Labs"]
函数传参传函数
func compute(fn func(float64, float64) float64) float64 {
return fn(3, 4)
}
//函数闭包
func adder() func(int) int {
sum := 0
return func(x int) int {
sum+=x
return sum
}
}
//菲波那切数列
func fibonacci() func() int {
a, b := 0, 1
return func() int {
a, b = b, a+b
return a
}
}
方法
type Vertex struct {
X,Y float64
}
func (v *Vertex) Abs() float64 {
return math.Sqrt(v.X * v.X + v.Y*v.Y)
}
v := &Vertex{1, 3}
s := v.Abs()
接口
//接口类型是由一组方法定义的集合。
type Abser interface {
Abs() float
}
type Reader interface {
Read(b []byte) (n int, err error)
}
type Writer interface {
Write(b []byte) (n int, err error)
}
type ReadWriter interface {
Reader
Writer
}
//fmt包进行输出的时候回调用这个接口，如果想自定义输出，可以实现这个方法
type Stringer interface {
String() string
}
Reader
package main
import (
"fmt"
"io"
"strings"
)
func main() {
r := strings.NewReader("Hello, Reader!")
b := make([]byte, 8)
for {
n, err := r.Read(b)
fmt.Printf("n = %v err = %v b = %v\\n", n, err, b)
fmt.Printf("b[:n] = %q\\n", b[:n])
if err == io.EOF {
break
}
}
}
最简单的web服务器
package main
import (
"fmt"
"log"
"net/http"
)
type Hello struct{}
func (h Hello) ServeHTTP(
w http.ResponseWriter,
r *http.Request) {
fmt.Fprint(w, "Hello!")
}
func main() {
var h Hello
err := http.ListenAndServe("localhost:4000", h)
if err != nil {
log.Fatal(err)
}
}
goroutine
package main
import (
"fmt"
"time"
)
func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main() {
go say("world")
say("hello")
}
chanel
ch := make(chan int)
ch <- v // 将 v 送入 channel ch。
v := <-ch // 从 ch 接收，并且赋值给 v。
//缓冲chanel
ch := make(chan int, 100)
//发送者可以close一个channel来表示没有值会被发送
//接受者可以通过赋值语句的第二个参数来测试channel是否被关闭
v, ok := <-ch
for i := range c //会不断从channel接收值，直到被关闭
package main
import (
"fmt"
)
func fibonacci(n int, c chan int) {
x, y := 0, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x+y
}
close(c)
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
for i := range c {
fmt.Println(i)
}
}
//select会阻塞，直到条件分支中的某个可以继续执行，这时就会执行那个条件分支。
//当多个都准备好的时候，会随机选择一个。
//当 select中的其他条件分支都没有准备好的时候，default分支会被执行。
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
互斥
package main
import (
"fmt"
"sync"
"time"
)
// SafeCounter 的并发使用是安全的。
type SafeCounter struct {
v map[string]int
mux sync.Mutex
}
// Inc 增加给定 key 的计数器的值。
func (c *SafeCounter) Inc(key string) {
c.mux.Lock()
// Lock 之后同一时刻只有一个 goroutine 能访问 c.v
c.v[key]++
c.mux.Unlock()
}
// Value 返回给定 key 的计数器的当前值。
func (c *SafeCounter) Value(key string) int {
c.mux.Lock()
// Lock 之后同一时刻只有一个 goroutine 能访问 c.v
defer c.mux.Unlock()
return c.v[key]
}
func main() {
c := SafeCounter{v: make(map[string]int)}
for i := 0; i < 1000; i++ {
go c.Inc("somekey")
}
time.Sleep(time.Second)
fmt.Println(c.Value("somekey"))
}
