Go by Example

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

package main
import "fmt"
func main(){
  //string 可以使用 + 连接在一起
  fmt.Println("go"+"lang")
  fmt.Println("1+1=",1+1)
  fmt.Pritnln("7.0/3.0=",7.0/3.0)
  fmt.Println(true&&false)
  fmt.Println(true||false)
  fmt.Pritnln(!true)
}

package main
import "fmt"
func main(){
  // 声明一个或多个变量
  var a string="initial"
  fmt.Println(a)
  var b,c int = 1,2
  fmt.Println(b,c)
  //Go 将推断变量的初始化类型
  var d = true
  fmt.Println(d)
  // 声明没有初始值的变量将被初始化为零值，如 int 的零值是 0
  var e int
  fmt.Println(e)
  //var f string = "short" 的简化写法
  f:="short"
  fmt.Println(f)
}

package main
import "fmt"
import "math"
const s string = "constant"
func main(){
  fmt.Println(s)
  //const 声明可以出现在任何 var 声明出现的地方
  const n = 50000000
  // 常量表达式可以任意精度进行运算
  const d = 3e20 / n
  fmt.Println(d)
  // 数值常量没有类型，除非进行了显式转换等类型赋予
  fmt.Println(int64(d))
  // 数值在使用环境上下文中会得到类型，如变量赋值或者方法调用，如 math.Sin 需要的是一个 float64
  fmt.Println(math.Sin(n))
}

package main
import "fmt"
func main(){
  i := 1
  // 最基本的类型，只有一个条件
  for i<=3{
    fmt.Println(i)
    i = i+1
  }
  // 经典的 初始化 / 条件 / 循环后 for 循环
  for j:=7;j<=9;j++{
    fmt.Println(j)
  }
  // 没有条件的 for 语句将无限循环，除非在内部的方法中使用了 break 或者 return
  for{
    fmt.Println("loop")
    break
  }
  // 也可以使用 continue 来直接到下一个循环
  for n:=0;n<=5;n++ {
    if n%2 == 0{
      continue
    }
    fmt.Println(n)
  }
}

package main
import "fmt"
func main(){
  if 7%2==0{
    fmt.Println("7 is even")
  }else{
    fmt.Println("7 is odd")
  }
  // 可以单独使用 if
  if 8%4==0{
    fmt.Println("8 is divisible by 4")
  }
  // 条件之前可以有语句，声明在该语句中的任何变量可以用于所有分支
  if num:=9;num<0{
    fmt.Println(num,"is negative")
  }else if num<10{
    fmt.Println(num,"has 1 digit")
  }else{
    fmt.Println(num,"has multiple digits")
  }
}

package main
import "fmt"
import "time"
func main(){
  i:=2
  fmt.Print("write",i,"as")
  switch i{
  case 1: fmt.Println("one")
  case 2: fmt.Println("two")
  case 3: fmt.Println("three")
  }
  // 可以在同一个 case 语句中使用逗号来分隔多个表达式
  switch time.Now().weekday(){
  case time.Saturday,time.Sunday:
    fmt.Println("it's the weekend")
  // 这里也使用了 default case
  default:
    fmt.Println("it's a weekday")
  }
  t:=time.Now()
  // 没有表达式的 switch 是另一种实现 if/else 逻辑的路子，同时这也展示了 case 表达式可以是非常量值。
  switch{
  case t.Hour()<12:
    fmt.Println("it's before noon")
  default:
    fmt.Println("it's after noon")
  }
  // 类型 switch 比较了类型而非值
  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.Println("Don't know type %T\n",t)
    }
  }
  whatAmI(true)
  whatAmI(1)
  whatAmI("hey")
}

package main
import "fmt"
func main(){
  // 这里创建了一个 5 个 int 元素的数组。默认是零值，对于 int 而言就是 0
  var a [5]int
  fmt.Println("emp:",a)
  // 可以通过 array[index]=value 语法设值，或者通过 array[index] 取值
  a[4]=100
  fmt.Println("set:",a)
  fmt.Println("get:",a[4])
  // 内置的 len 函数返回数组的长度
  fmt.Println("len:",len(a))
  // 声明并初始化数组
  b:=[5]int{1,2,3,4,5}
  fmt.Prinln("dc1:",b)
  // 数组是一维的，但你可以组合类型来构建多维数组结构
  var twoD [2][3]int
  for i:=0;i<2;i++{
    for j:=0;j<3;j++{
      twoD[i][j]=i+j
    }
  }
  fmt.Println("2d:",twoD)
}

package main
import "fmt"
func main(){
  // 与数组不同，切片仅由其包含的元素（不是元素的数量）键入。 
  // 要创建一个非零长度的空切片，请使用内置的 make。 这里我们制作长度为 3 的字符串（最初为零值）。
  s:=make([]string,3)
  fmt.Println("emp:",s)
  // 可以像数组一样 set 和 get
  s[0]="a"
  s[1]="b"
  s[2]="c"
  fmt.Println("set:",s)
  fmt.Println("get:",s[2])
  //len 能够返回 slice 的长度
  fmt.Println("len:",len(s))
  // 作为这些基本操作的补充，slice 支持一些令其比数组更丰富的东西。
  // 其中一个是 append 函数，其返回一个包含一个或多个新值的 slice
  // 注意需要接受 append 的返回值来获取新的 slice 值
  s=append(s,"d")
  s=append(s,"e","f")
  fmt.Println("apd:",s)
  //slice 可以复制
  c:=make([]string,len(s))
  copy(c,s)
  fmt.Println("cpy:",c)
  //slice 支持切片操作，语法为 slice[low:high]。如下将得到元素 s[2],s[3] 和 s[4]
  l:=s[2:5]
  fmt.Println("sl1:",l)
  // 如下切片截止到（不包含）s[5]
  l=s[:5]
  fmt.Pritnln("sl2:",l)
  // 如下切片从 s[2] 开始（包含）
  l=s[2:]
  fmt.Println("sl3:",l)
  // 声明并初始化 slice
  t:=[]string{"g","h","i"}
  fmt.Println("dcl:",t)
  //slice 也可以组织成一个多为数据结构，内部的 slice 长度可以变化，这与多维数组不同
  twoD:=make([][]int,3)
  for i:=0;i<3;i++{
    innerLen:=i+1
    twoD[i]=make([]int,innerLen)
    for j:=0;j<innerLen;j++{
      twoD[i][j]=i+j
    }
  }
  fmt.Println("2d:",twoD)
}

package main
import "fmt"
func main(){
  // 要创建一个空的 map，使用内置 make 函数：make(map[key-type]val-type)
  m:=make(map[string]int)
  // 通过经典的 name[key]=val 语法来设置 key/value 对
  m["k1"]=7
  m["k2"]=13
  fmt.Println("map:",m)
  // 通过 name[key] 来获取一个 value
  v1:=m["k1"]
  fmt.Println("v1:",v1)
  //len 函数返回 map 中键值对的个数
  fmt.Println("len:",len(m))
  // 内置的 delete 函数将移除 map 中的键值对
  delete(m,"k2")
  fmt.Println("map:",m)
  // 第一个值是该 key 的 value，但此处不需要，故使用空白占位符“_”忽略
  // 第二个可选的返回值表明该键是否在 map 中，这样可以消除不存在的键，和键值为 0 或者 "" 的歧义
  _,prs:=m["k2"]
  fmt.Println("prs:",prs)
  // 声明并初始化 map
  n:=map[string]int{"foo":1,"bar":2}
  fmt.Println("map:",n)
}

package main
import "fmt"
func main(){
  // 这里使用 range 来计算元素的和，数组也是类似的用法
  nums:=[]int{2,3,4}
  sum:=0
  for _,num:=range nums{
    sum+=num
  }
  fmt.Println("sum:",sum)
  // 在 slice 和 array 上的 range 均为每个条目提供了索引和值
  for i,num:=range nums{
    if num==3{
      fmt.Pritnln("index",i)
    }
  }
  //map 上的 range 通过 key/value 对进行遍历
  kvs:=map[string]string{"a":"apple","b":"banana"}
  for k,v:=range kvs{
    fmt.Printf("%s -> %s\n",k,v)
  }
  //range 可以仅通过 key 进行遍历
  for k:= range kvs{
    fmt.Println("key:",k)
  }
  //range 作用在 string 上将得到 unicode code points，第一个值是字符的起始字节索引，第二个值是字符本身
  for i,c:range "go" {
    cmt.Println(i,c)
  }
}

package main
import "fmt"
// 这个函数接收两个 int 并以 int 类型返回他们的和
func plus(a int,b int) int{
  //Go 需要显式的 return 语句，它不会自动返回最后一个表达式的值
  return a+b
}
// 如果有多个连续的相同类型的参数，可以忽略前面的类型声明
func plusPlus(a,b,c int) int{
  return a+b+c
}
func main(){
  // 如你所想的那样调用函数
  res := plus(1,2)
  fmt.Println("1+2=",res)
  res = plusPlus(1,2,3)
  fmt.Println("1+2+3=",res)
}

package main
import "fmt"
// 方法签名中的 (int,int) 表明它将返回两个 int 值
func vals()(int,int){
  return 3,7
}
func main(){
  // 这里我们通过多重赋值来使用两个不同的返回值
  a,b := vals()
  fmt.Println(a)
  fmt.Println(b)
  // 如果只需要返回结果的子集，使用空白占位符 _
  _,c := vals()
  fmt.Println(c)
}

package main
import "fmt"
// 这是一个接收任意数量的 int 值的函数
func sum(nums ...int){
  fmt.Print(nums," ")
  total := 0
  for _, num := range nums{
    total += num
  }
  fmt.Println(total)
}
func main(){
  sum(1,2)
  sum(1,2,3)
  // 如果你已经在一个 slice 中定义了多个参数，可以使用 func(slice...) 来直接应用到变参函数中
  nums :=[]int{1,2,3,4}
  sum(nums...)
}

package main
import "fmt"
//intSeq 函数返回另一个函数，它定义在了 intSeq 函数内部，并且是匿名的。
// 返回的函数关闭变量 i 以形成闭包
func intSeq() func int{
  i := 0
  return func() int{
    i+=1
    return i
  }
}
func main(){
  // 调用 intSeq，并将结果 (一个函数) 赋予 nextInt
  // 这个函数持有一个自己的 i 值，每次调用 nextInt 时都会更新
  nextInt:=intSeq()
  // 多次调用 nextInt 函数可以看到闭包的效果
  //zephyr: 如非闭包写法，每次函数都会进行初始化变量 i，反复调用 intSeq 不会有这个效果
  fmt.Println(nextInt())
  fmt.Println(nextInt())
  fmt.Pritnln(nextInt())
  // 要确认该状态对该特定函数是唯一的，请创建并测试一个新函数。
  newInts:=intSeq()
  fmt.Println(newInts())
}

package main
import "fmt"
func fact(n int) int {
  if n==0 {
    return 1
  }
  //fact 函数调用自身，直到 n 为 0
  return n * fact(n-1)
}
func main(){
  fmt.Println(fact(7))
}

package main
import "fmt"
//zeroval 将取得 ival 的值的拷贝，与调用方不同
func zeroval(ival int){
  ival = 0
}
//zeroptr 有一个 *int 类型的参数，代表它接收的是一个指针
func zeroptr(iptr *int){
  //*iptr 解引用，从内存指定地址中获取存放的值
  // 对解引用指针的赋值将改变指定地址上的值
  *iptr = 0
}
func main(){
  i:=1
  fmt.Println("initial:",i)
  zeroval(i)
  fmt.Println("zeroval:",i)
  //&i 语法将获得变量 i 的内存地址，也就是指向变量 i 的指针
  zeroptr(&i)
  fmt.Println("zeroptr:",i)
  // 指针也可以被打印
  fmt.Println("pointer:",&i)
}

package main
import "fmt"
type person struct{
  name string
  age int
}
func main(){
  // 这个语法创建了一个新的 struct
  fmt.Println(person{"Bob",20})
  // 在初始化 struct 时，可以指定字段名
  fmt.Println(person{name:"Alice",age:30})
  // 被忽略的字段将会被初始化为零
  fmt.Println(person{name:"Fred"})
  // 一个 & 将产生 struct 的指针
  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)
}

package main
import "fmt"
type rect struct{
  width,height int
}
//area 方法有一个 rect 指针类型的接收器
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())
  //Go 为方法调用自动处理了值和引用的转换。使用指针接收器可以避免获得方法调用的拷贝 (?) 或允许方法修改接收到的 struct 值
  rp:=&r
  fmt.Println("area:",rp.area())
  fmt.Println("perim:",rp.perim())
}

package main
import "fmt"
import "math"
// 这是一个 geometry 的基本接口，本例中将在 rect 类型和 circle 类型中实现这个接口
type geometry interface{
  area() float64
  perim() float64
}
type rect struct{
  width,height float64
}
type circle struct{
  radius float64
}
// 在 Go 中，实现一个接口只需要实现其中定义的所有方法即可
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
}
// 如果变量是接口类型，那么它可以调用接口内定义的方法
// 这是一个通用的 measure 方法，利用它能够工作在任何 geometry 上
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}
  //rect 和 circle 均实现了 geometry 接口，所以可以作为 measure 的参数
  measure(r)
  measure(c)
}

package main
import "errors"
import "fmt"
// 按照惯例，错误是最后一个返回值，类型为 error，一个内置的接口。
func f1(arg int)(int,error){
  if arg==42{
    //errors.New 使用给定的错误信息构建了一个基本的 error 值
    return -1,errors.New("can't work with 42")
  }
  // 在 error 位置上放 nil 值代表没有错误
  return arg+3,nil
}
// 通过实现 Error() 方法，可以自定义错误类型。这里有一个上例的变种
// 使用一个自定义类型来显式地展示一个参数错误
type argError struct{
  arg int
  prob string
}
type argError struct{
  arg int
  prob string
}
func (e *argError) Error() string{
  return fmt.Sprintf("%d - %s",e.arg,e.prob)
}
func f2(arg int)(int,error){
  if arg==42{
    // 这里我们使用 &argError 语法来创建一个新的结构体，提供了 arg 和 prob 两个域的值
    return -1,&argError{arg,"can't work with it"}
  }
  return arg+3,nil
}
func main(){
  // 下面的两个循环测试了每个返回 error 的函数
  // 注意在 if 中的错误检查是 Go 代码中的习惯用法
  for _,i:=range []int{7,42}{
    if r,e:=f1(i);e!=nil{
      fmt.Println("f1 failed:",e)
    }else{
      fmt.Println("f1 worked:",r)
    }
  }
  for _,i := range []int{7,42}{
    if r,e :=f2(i);e!=nil{
      fmt.Println("f1 failed:",e)
    }else{
      fmt.Println("f1 worked:",r)
    }
  }
  // 如果要以编程方式使用自定义错误中的数据，
  // 则需要通过类型断言将错误作为自定义错误类型的实例获取。
  _,e:=f2(42)
  if ae,ok := e.(*argError);ok{
    fmt.Println(ae.arg)
    fmt.Println(ae.prob)
  }
}

package main
import "fmt"
func f(from string){
  for i:=0;i<3;i++{
    fmt.Println(from,";",i)
  }
}
func main(){
  // 假设我们有个 f(s) 的函数调用。这里我们通过一般方法调用，令其同步执行
  f("direct")
  // 要想让这个函数在 goroutine 中触发，使用 go f(s)。这个新的 goroutine 将会与调用它的并行执行
  go f("goroutine")
  // 我们也可以启动一个调用匿名函数的 goroutine
  go func(msg string){
  fmt.Println(msg)
  }("going")
  // 现在，这两个方法调用在独立的 goroutine 中异步执行了，故方法执行直接落到了这里
  //Scanln 代码需要在程序退出前按下一个键
  var input string
  fmt.Scanln(&input)
  fmt.Println("done")
}

package main
import "fmt"
func main(){
  // 通过 make(chan val-type) 创建新的 channel
  //channel 的类型依赖于它们要传递的值
  messages:=make(chan string)
  // 向 channel 传递值使用 channel <- 语法。在这里我们从一个新的 goroutine 中发送了一个 "ping" 到 message 通道中
  go func(){messages<-"ping"}()
  //<-channel 语法从 channel 中获取值。这里我们接收了上面发送的 "ping" 信息并打印
  msg:=<-messages
  fmt.Println(msg)
}

package main
import "fmt"
func main(){
  // 这里我们创建了一个能够缓冲 2 个字符串值的 channel
  messages:=make(chan string,2)
  // 由于 channel 带有缓冲区，我们可以发送值，无需响应的并发接收
  messages<-"buffered"
  messages<-"channel"
  // 稍后，我们像往常一样，接收了这两个值
  fmt.Println(<-messages)
  fmt.Println(<-messages)
}

package main
import "fmt"
import "time"
// 这个方法将在一个 goroutine 中运行。
//done channel 用来通知其他的 goroutine 这个方法执行完毕
func worker(done chan bool){
  fmt.Print("working...")
  time.Sleep(time.Second)
  fmt.Println("done")
  // 发送一个值来通知这里已经做完
  done<-true
}
func main(){
  启动一个worker goroutine，赋予它用以通知的channel
  done:=make(chan bool,1)
  go worker(done)
  // 在 channel 接收到来自 worker 的通知前，保持阻塞
  <-done
}

package main
import "fmt"
//ping 函数只接受一个发送数据的 channel，如果试图在其上获取数据，将会引发编译时异常
func ping(pings chan<- string,msg string){
  pings<-msg
}
//pong 函数接受一个通道用于接收 (pings)，另一个用于发送 (pongs)
func pong(pings <-chan string,pongs chan<- string){
  msg:=<-pings
  pongs<-msg
}
func main(){
  pings:=make(chan string,1)
  pongs:=make(chan string,1)
  ping(pings,"passed message")
  pong(pings,pongs)
  fmt.Println(<-pongs)
}

package main
import "time"
import "fmt"
func main(){
  // 本例中我们将在两个通道中进行选择
  c1:=make(chan string)
  c2:=make(chan string)
  // 每个通道都会在一定时间后接收到一个值，在并发的 goroutine 中模拟阻塞 RPC 操作执行
  go func(){
    time.Sleep(time.Second*1)
    c1<-"one"
  }()
  go func(){
    time.Sleep(time.Second*2)
    c2<-"two"
  }()
  // 我们将使用 select 来同时等待这两个值，当它们到达时打印。
  for i:=0;i<2;i++{
    select{
    case msg1:=<-c1:
      fmt.Println("received",msg1)
    case msg2:=<-c2:
      fmt.Println("received",msg2)
    }
  }
}

package main
import "time"
import "fmt"
func main(){
  // 在本例中，假设我们执行了一个外部调用，它在两秒后将结果返回到通道 c1 上
  c1:=make(chan string,1)
  go func(){
    time.Sleep(time.Second*2)
    c1<-"result 1"
  }()
  // 这里是用 select 实现超时。res:=<-c1 等待一个结果，而 <-Time.After 等待超时 1 秒后发送一个值。
  // 由于 select 将在有第一个准备就绪的接收时继续，我们会在操作超过允许的 1 秒时进入超时事件。
  select{
  case res:=<-c1:
    fmt.Println(res)
  case <-time.After(time.Second*1):
    fmt.Println("timeout 1")  
  }
  // 如果我们允许一个更长的超时时间 3 秒，则将能成功得到 c2 的值，并打印
  c2:=make(chan string,1)
  go func(){
    time.Sleep(time.Second*2)
    c2<-"result 2"
  }()
  select{
  case res:=<-c2:
    fmt.Println(res)
  case <-time.After(time.Second*3):
    fmt.Printnln("timeout 2")
  }
}

package main
import "fmt"
func main(){
  messages:=make(chan string)
  signals:=make(chan bool)
  // 这是一个非阻塞的接收。如果 message 的值可以获取，select 将随值进入 <-message 子句
  // 否则将立刻进入 default 事件
  select{
  case msg:=<-messages:
    fmt.Println("received message",msg)
  default:
    fmt.Pritln("no message received")
  }
  msg:="hi"
  // 类似的有非阻塞发送
  select{
  case messages<-msg:
    cmt.Println("sent message",msg)
  default:
    fmt.Println("no message sent")
  }
  // 我们可以在 default 上使用多个事件来实现多路非阻塞 select。
  // 这里我们试图在 message 和 signal 上均进行非阻塞接收
  select{
  case msg:=<-messages:
    fmt.Println("received message",msg)
  case sig:=<-signals:
    fmt.Println("received signal",sig)
  default:
    fmt.Println("no activity")
  }
}

package main
import "fmt"
// 在这个例子中，我们将使用一个作业通道将工作从主函数 goroutine 传递给工人 goroutine。当没有更多作业给工人时，我们将关闭工作渠道。
func main(){
  jobs:=make(chan int,5)
  done:=make(chan bool)
  // 下面是工人 goroutine。它通过 j,more:=<-jobs 反复获取作业
  // 在这个 2 返回值的接收中，如果作业关闭，所有值都已接收，more 会变为 false
  // 我们用其在完成所有作业时进行已完成通知
  go func(){
    for{
      j,more:=<-jobs
      if more{
        fmt.Println("received job",j)
      }else{
        fmt.Println("received all jobs")
        done<-true
        return
      }
    }
  }()
  // 此处向工人发送了 3 个作业，然后关闭它
  for j:=1;j<=3;j++{
    jobs<-j
    fmt.Println("sent job",j)
  }
  close(jobs)
  fmt.Println("sent all jobs")
  // 使用前面见过的同步机制来等待工人、
  <-done
}

package main
import "fmt"
func main(){
  // 遍历 queue 通道上的 2 个值
  queue:=make(chan string,2)
  queue<-"one"
  queue<-"two"
  close(queue)
  //range 遍历通道上接收的每个值。由于在上面关闭了通道，这个遍历将在接收 2 个值后结束。
  for elem:=range queue{
    fmt.Println(elem)
  }
}

package main
import "time"
import "fmt"
func main(){
  //timer 代表未来的一个单独事件。你要告诉它要等待多久，它提供一个通道，在指定时间发出通知。下面这个 timer 将等待 2 秒钟
  timer1:=time.NewTimer(time.Second*2)
  // 定时器通道由于操作 <-timer1.c 发生阻塞，直到它发送了一个值来表明定时器到时
  <-timer1.C
  fmt.Println("Timer 1 expired")
  // 如果你仅仅想等待一段时间，可以用 time.Sleep，使用 timer 的一个原因是，你可以在计时结束前取消，如下例：
  timer2:=time.NewTimer(time.Second)
  go func(){
    <-timer2.C
    fmt.Println("Timer 2 expired")
  }()
  stop2:=timer2.Stop()
  if stop2{
    fmt.Println("Timer 2 stopped")
  }
}

package main
import "time"
import "fmt"
func main(){
  //ticker 与 timer 的机制相似，都是一个发送值的通道
  // 这里我们使用 channel 内置的 range 来遍历每 500ms 到达的值
  ticker:=time.NewTicker(time.Millisecond*500)
  go func(){
    for t:=range ticker.C{
    fmt.Prinltn("Tick at",t)
    }
  }()
  //ticker 可以像 timer 一样停止。一旦 ticker 停止，将不会在其通道上接收到任何信息。我们将在 1600ms 后结束。
  time.Sleep(time.Millisecond*1600)
  ticker.Stop()
  fmt.Println("Ticker stopped")
}

package main
import "fmt"
import "time"
// 这里是我们将要运行多个并发实例的工人。他们将从 jobs 通道获取任务，并将相应的结果返回到 results 上。我们将在每个作业沉睡 1 秒，来模拟一个复杂的任务。
func worker(id int,jobs <-chan int,results chan<- int){
  for j:=range jobs{
    fmt.Println("worker",id,"started job",j)
    time.Sleep(time.Second)
    fmt.Println("worker",id,"finished job",j)
    results <- j*2
  }
}
func main(){
  // 为了使用工人池，我们需要派发任务并且回收结果。我们使用两个通道来做这件事
  jobs:=make(chan int,100)
  results:=make(chan int,100)
  // 这里启动了 3 个工人，初始时阻塞，因为当前没有作业
  for w:=1;w<=3;w++{
    go worker(w,jobs,results)
  }
  // 添加 5 个作业，然后关闭通道来表明这就是所有的工作
  for j:=1;j<=5;j++{
    jobs<-j
  }
  close(jobs)
  
  for a:=1;a<=5;a++{
    <-results
  }
}

package main
import "time"
import "fmt"
func main(){
  // 首先，我们看下基本的速率控制。
  // 假设我们想要控制处理的输入请求，我们通过同一个通道来为这些请求提供服务
  requests:=make(chan int,5)
  for i:=1;i<=5;i++{
    request<-i
  }
  close(requests)
  //limiter 通道将每过 200 毫秒接收一次数据。这是速率控制策略中的调节器
  limiter:=time.Tick(time.Millisecond*200)
  // 在服务每个请求之前，通过 limiter 通道阻塞接收，我们将自己限制在每 200ms 处理 1 个请求上。
  for req:=range request{
    <-limiter
    fmt.Println("request",req,time.now())
  }
  // 我们可能希望在我们的速率限制方案中允许短时间的请求，同时保留整体速率限制。 
  // 我们可以通过缓冲限制器通道来实现这一点。
  // 这个 burstyLimiter 通道将允许多达 3 个事件的突发。
  burstyLimiter:=make(chan time.Time,3)
  // 填充通道，来展示可允许的突发
  for i:=0;i<3;i++{
    burstyLimiter<-time.Now()
  }
  // 每过 200 毫秒将试图添加一个新值到 burstyLimiter，最多 3 个
  go func(){
    for t:=range time.Tick(time.Millisecond*200){
      burstyLimiter<-t
    }
  }()
  // 模拟 5 个输入请求。前 3 个将受益于 burstyLimiter 的突发能力
  burstyRequests:=make(chan int,5)
  for i:=1;i<=5;i++{
    burstyRequest<-i
  }
  close(burstyRequests)
  for req:=range burstyRequests{
    <-burstyLimiter
    fmt.Println("request",req,time.Now())
  }
}

package main
import "fmt"
import "time"
import "sync/atomic"

func main(){
  // 我们使用无符号整数来代表我们的计数器
  var ops unit64=0
  // 为了模拟并发更新操作，我们将启动 50 个 goroutine，每个都会在每过 1 毫秒时增长一次计数器
  for i:=0;i<50;i++{
    go func(){
      for{
        // 为了原子地增加计数器，我们使用 AddUint64，使用＆语法给它我们的 ops 计数器的内存地址。
        atomic.AddUnit64(&ops,1)
        // 在两个增长之间稍作等待
        time.Sleep(time.Millisecond)
      }
    }()
  }
  // 等一下让一些操作积累起来。
  time.Sleep(time.Second)
  // 为了安全地使用计数器，当它仍被其他 goroutine 更新时，我们通过 LoadUint64 将当前值的副本提取到 opsFinal 中。
  // 如上所述，我们需要给出这个函数来获取值的内存地址和操作。
  opsFinal:=atomic.LoadUnit64(&ops)
  fmt.Println("ops:",opsFinal)
}

package main
import(
  "fmt"
  "math/rand"
  "sync"
  "sync/atomic"
  "time"
)
func main(){
  // 这个例子中，状态是一个 map
  var state=make(map[int]int)
  // 这个 mutext 将同步访问状态值
  var mutex=&sync.Mutex{}
  // 我们将记录做了多少读写操作
  var readOps unit64=0
  var writeOps unit64=0
  // 这里我们启动了 100 个 goroutine 来重复读取状态值
  // 每毫秒在每个 goroutine 执行一次
  for r:=0;r<100;r++{
    go func(){
      total:=0
      for{
        // 每次读取时我们将获得一个进入的钥匙
        //Lock() 住 mutex 来保证独家访问状态值
        // 在选中的钥匙上读取值，Unlock() 掉 mutext
        // 对 readOps 计数加 1
        key:=rand.Intn(5)
        mutex.Lock()
        total+=state[key]
        mutex.Unlock()
        atomic.AddUnit64(&readOps,1)
        // 每次操作等待一下
        time.Sleep(time.Millisecond)
      }
    }()
  }
  // 再启动 10 个模拟写的 goroutine，与读取类似的模式
  for w:=0;w<10;w++{
    go func(){
      for{
        key:=rand.Intn(5)
        val:=rand.Intn(100)
        mutex.Lock()
        state[key]=val
        mutex.Unlock()
        atomic.AddUnit64(&writeOps,1)
        time.Sleep(time.Millisecond)
      }
    }()
  }
  // 让这 10 个 go 协程在 state 和 mutext 上工作一会儿
  time.Sleep(time.Second)
  // 获取并且报告最终操作的个数。
  readOpsFinal:=atomic.LoadUnit64(&readOps)
  fmt.Println("readOps:",readOpsFinal)
  writeOpsFinal:=atomic.LoadUnit64(&writeOps)
  fmt.Println("writeOps:",writeOpsFinal)
  // 随着最后一次锁住状态，展示它是如何结束的
  mutex.Lock()
  fmt.Println("state:",state)
  mutex.Unlock()
}

package main
import(
  "fmt"
  "math/rand"
  "sync/atomic"
  "time"
)
// 在这个例子中，状态值将被一个单独的 goroutine 拥有
// 这保证了数据不会受到并发访问的影响
// 为了读或写状态值，其它 goroutine 将向拥有它的 goroutine 发送一个消息，然后接收其回复。
//readOp 和 writeOp 结构封装了这些请求和响应
type readOp struct{
  key int
  resp chan int
}
type writeOp struct{
  key int
  val int
  resp chan bool
}
func main() {
  // 像之前一样我们记录执行了多少次操作
  var readOp unit64=0
  var writeOps unit64=0
  //reads 和 writes 通道将被用于其它 goroutine 分别发送读写请求
  reads:=make(chan *readOp)
  writes:=make(chan *writeOp)
  // 这里便是拥有状态值的 goroutine，与之前一样是个 map，但被私有化
  // 这个 goroutine 反复选择 reads 和 writes 通道，响应到达的请求。
  // 首先执行所请求的操作然后在响应通道上发送值来表示成功执行响应
  //(或者 reads 期望的数据)
  go func(){
    var state=make(map[int]int)
    for{
      select{
      case read:=<-reads:
        read.resp<-state[read.key]
      case write:=<-writes:
        state[write.key]=write.val
        write.resp<-true
      }
    }
  }()
  // 启动 100 个 goroutine，通过读取通道来读取有状态的 goroutine
  // 每次读取需要构建一个 readOp，通过 reads 发送给它
  // 再通过所提供的 resp 通道获取结果
  for r:=0;r<100;r++{
    go func(){
      for {
        read:=&readOp{
          key:rand.Intn(5),
          resp:make(chan int)
        }
        reads<-read
        <-read.resp
        atomic.AddUnit64(&readOps,1)
        time.Sleep(time.Millisecond)
      }
    }()
  }
  // 启动 10 个写操作
  for w:=0;w<10;w++{
    go func(){
      for {
        write:=&writeOp{
          key:rand.Intn(5),
          val:rand.Intn(100),
          resp:make(chan bool)
        }
      }
    }()
  }
  time.Sleep(time.Second)
  readOpsFinal:=atomic.LoadUnit64(&readOps)
  fmt.Println("readOps:",readOpsFinal)
  writeOpsFinal:=atomic.LoadUnit64(&writeOps)
  fmt.Println("writeOps:",writeOpsFinal)
}

package main
import "fmt"
import "sort"
func main(){
  //sort 改变了给定的 slice，而不是返回一个新的
  strs:=[]string{"c","a","b"}
  sort.Strings(strs)
  fmt.Println("Strings:",strs)
  ints:=[]int{7,2,4}
  sort.Ints(ints)
  fmt.Println("Ints:",ints)
  // 可以使用 sort 检查一个 slice 是不是已经排好序了
  s:=sort.IntsAreSorted(ints)
  fmt.Println("Sorted:",s)
}

package main
import "fmt"
import "sort"
// 为了根据自定义函数排序，我们需要相应的类型
// 这里我们创建了一个 ByLength 类型
// 这就是一个 []string 类型的别名
type ByLength []string
// 我们在 ByLength 上实现了 sort 接口的 Len、Less 和 Swap 方法
// 这里我们想要按照字符串长度的增序排列
func (s ByLength) Len() int{
  return len(s)
}
func (s ByLength) Swap(i,j int){
  s[i],s[j] = s[j],s[i]
}
func (s ByLength) Less(i,j int) bool {
  return len(s[i])<len(s[j])
}
// 通过将原有的 fruits 片段转换为 ByLength
// 就可以使用 sort.Sort 来进行自定义排序了。
func main(){
  fruits:=[]string{"peach","banana","kiwi"}
  sort.Sort(ByLength(fruits))
  fmt.Println(fruits)
}

package main
import "os"
func main(){
  // 我们将在整个网站使用 panic 来检查意外的错误。
  // 这是该网站上唯一旨在 panic 的程序。
  panic("a problem")
  //panic 的一个常见作用是终止一个函数返回了一个不知道如何处理或者不想处理的错误。
  // 这里是一个 panic 的例子，在创建一个新文件时发生意外错误
  _,err:=os.Create("/tmp/file")
  if err!=nil{
    panic(err)
  }
}

packgae main
import "fmt"
import "os"
// 假设我们想要创建并写一个文件，在完成后关闭它。
func main(){
  // 在获取一个文件对象后立即使用 defer 并关闭这个文件
  // 这个将在 main 函数末尾关闭的时候执行，在 writeFile 完成后
  f:=createFile("/tmp/defer.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.Println(f,"data")
}
func closeFile(f *os.File){
  fmt.Println("closing")
  f.Close()
}

package main
import "strings"
import "fmt"
// 返回目标字符串 t 的第一个索引，如果没有找到则返回 -1
func Index(vs []string,t string) int{
  for i,v:=range vs{
    if v==t{
      return i
    }
  }
  return -1
}
// 如果字符串在切片中，则返回 true
func Include(vs []string,t string) bool{
  return Index(vs,t)>=0
}
// 如果有一个字符串满足期望的 f 则返回 true
func Any(vs []string,f func(string) bool) bool{
  for _,v:=range vs{
    if f(v){
      return true
    }
  }
  return false
}
// 所有的字符串满足期望的 f 则返回 true
func All(vs []string,f func(string) bool) bool{
  for _,v:=range vs{
    if !f(v){
      return false
    }
  }
  return true
}
// 返回一个满足给定方法的所有字符串
func Filter(vs []string,f func(string) bool)[]string{
  vsf :=make([]string,0)
  for _,v:=range vs{
    if f(v){
      vsf=append(vsf,v)
    }
  }
  return vsf
}
// 返回一个包含将 f 函数应用于原始切片中每个字符串的结果的新切片。
func Map(vs []string,f func(string) string)[] string{
  vsm := make([]string,len(vs))
  for i,v:=range vs{
    vsm[i]=f(v)
  }
  return vsm
}
func main(){
  var strs=[]string{"peach","apple","pear","plum"}
  fmt.Println(Index(strs,"pear"))
  fmt.Println(Include(strs,"grape"))
  fmt.Println(Any(strs,func(v string) bool{
    return strings.HasPrefix(v,"p")
  }))
  fmt.Println(All(strs,func(v string) bool{
    return strings.HasPrefix(v,"p")
  }))
  fmt.Println(Filter(strs,func(v string) bool{
    return strings.Contains(v,"e")
  }))
  // 以上示例全部使用匿名函数，但也可以使用正确类型的命名函数。
  fmt.Println(Map(strs,strings.ToUpper))
}

package main
import s "strings"
import "fmt"
// 鉴于后文大量用到，我们给字符串输出函数起一个别名
var p=fmt.Println
func main(){
  // 这里是字符串可以用的函数示例
  // 由于这些函数是包中的而不是字符串对象本身的方法，我们需要给他们传递一个字符串参数
  // 你可以在 strings 包下的 doc 找到更多的函数
  p("Contains:",s.Contains("test","es"))
  p("Count:",s.Count("test","t"))
  p("HasPrefix:",s.HasPrefix("test","te"))
  p("HasSuffix:",s.HasSuffix("test","st"))
  p("Index:",s.Index("test","e"))
  p("Join:",s.Join([]string{"a","b"},"-"))
  p("Repeat:",s.Repeat("a",5))
  p("Replace:",s.Replace("foo","o","0",-1))
  p("Replace",s.Replace("foo","o","0",1))
  p("Split:",s.Split("a-b-c-d-e","-"))
  p("ToLower:",s.ToLower("TEST"))
  p("ToUpper:",s.ToUpper("test"))
  p()
  // 并非 strings 包的一部分，但是这里值得一提
  // 即获取字符串长度以及字符串中的某个字符
  p("Len:",len("hello"))
  p("Char:","hello"[1])
}

package main
import "fmt"
import "os"
type point struct{
  x,y int
}
func main(){
  //Go 提供了一些修饰符来格式化一般的 Go 数值
  // 例如，这里输出了一个 point 结构体的实例
  p:=point{1,2}
  fmt.Printf("%v\n",p)
  // 如果值是结构体，%+v 变量将输出结构体中的域名称
  fmt.Printf("%+v\n",p)
  //%#v 将打印 Go 语法形式
  fmt.Printf("%#v\n",p)
  // 要想打印值的类型，使用 %T
  fmt.Printf("%T\n",p)
  // 格式化输出布尔值
  fmt.Printf("%t\n",true)
  // 整数有许多格式化选项，使用 %d 来进行标准十进制格式化
  fmt.Printf("%d\n",123)
  // 这样打印了二进制形式
  fmt.Printf("%b\n",14)
  // 这里打印了十进制数字对应的字符
  fmt.Printf("%c\n",33)
  //%x 提供了十六进制编码
  fmt.Printf("%x\n",456)
  // 浮点数也有许多格式化选项，标准十进制使用 %f
  fmt.Printf("%f\n",78.9)
  //%e 和 %E 格式化浮点数为科学计数法
  fmt.Printf("%e\n",123400000.0)
  fmt.Printf("%E\n",123400000.0)
  // 基本的字符串输出，使用 %s
  fmt.Pirntf("%s\n","\"string\"")
  // 将 Go 代码中的字符串加引号输出 (等同参数形式)
  fmt.Printf("%q\n","\"string\"")
  // 将字符串十六进制编码化
  fmt.Printf("%x\n","hex this")
  // 打印一个指针
  fmt.Printf("%p\n",&p)
  // 控制数字输出的宽度和精度，在 % 后面跟上数字可以控制宽度,. 后面跟上数字控制精度
  // 默认靠右显示，用空格填充
  fmt.Printf("|%6d|%6d|\n",12,345)
  fmt.Printf("|%6.2f|%6.2f|\n",1.2,3.45)
  // 靠左对齐使用 -
  fmt.Printf("|%-6.2f|%-6.2f|\n",1.2,3.45)
  // 你可能也需要控制字符串输出的格式，特别是要以表格形式输出的时候
  fmt.Printf("|%6s|%6s|\n","foo","b")
  fmt.Printf("|%-6s|%-6s|\n","foo","b")
  //Printf 将格式化的字符串打印到标准输出上
  //Sprintf 格式化并返回这个字符串而不打印
  s:=fmt.Sprintf("a %s","string")
  fmt.Println(s)
  // 你也可以格式化并打印到 io.Writers 而非 os.StdOut
  fmt.Fprintf(os.Stderr,"an %s\n","error")
}

package main
import "bytes"
import "fmt"
import "regexp"
func main(){
  // 测试模式是否符合字符串
  math,_:=regexp.MatchString("p([a-z]+)ch","peach")
  fmt.Printf(match)
  // 上面我们直接使用了字符串模式。但是对于其他正则任务，你需要先编译一个正则表达式结构体
  r,_:=regexp.Compile("p([a-z]+)ch")
  // 这种结构体上有许多方法。这里是一个如同上面的匹配测试
  fmt.Println(r.MatchString("peach"))
  // 这里找到一个匹配
  fmt.Println(r.FindString("peach punch"))
  // 这里也是寻找第一个匹配，但返回起止的索引而非字符串
  fmt.Println(r.FindStringIndex("peach punch"))
  //submatch 包含整串匹配，也包含内部的匹配。
  fmt.Println(r.FindStringSubmatch("peach punch"))
  // 与上面类似，返回整串匹配和内部匹配的索引信息
  fmt.Println(r.FindStringSubmatchIndex("peach punch"))
  // 这些函数的 All 修饰将返回输入中所有匹配的，不仅仅是第一个。例如找到所有匹配正则表达式的
  fmt.Println(r.FindAllString("peach punch pinch",-1))
  fmt.Println(r.FindAllStringSubmatchIndex("peach punch pinch",-1))
  // 第二个参数如果是非负数，则将限制最多匹配的个数
  fmt.Println(r.FindAllString("peach punch pinch",2))
  // 例子中都是字符串参数，并且用了类似于 MatchString 这样的名字
  // 我们可以提供 []byte 参数，并将函数名中的 String 去掉
  fmt.Println(r.Match([]byte("peach")))
  // 当用正则表达式创建一个常量的时候你可以使用 MustCompile。
  // 一个纯 Compile 不能用于常量，因为它有 2 个返回值。
  r=regexp.MustComplie("p([a-z]+)ch")
  fmt.Println(r)
  //regexp 包也能用于使用其他值替换字符串的子集
  fmt.Println(r.ReplaceAllString("a peach","<fruit>"))
  //Func 修饰允许你使用一个给定的函数修改匹配的字符串
  in:=[]byte("a peach")
  out:=r.ReplaceAllFunc(in,bytes.ToUpper)
  fmt.Println(string(out))
}

package main
import "encoding/json"
import "fmt"
import "os"
// 我们使用这两个结构体来展示自定义类型的编码和解码
type Response1 struct{
  Page int
  Fruits []string
}
type Response2 struct{
  Page int `json:"page"`
  Fruits []string `json:"fruits"`
}
func main(){
  // 首先我们来看编码基本数据类型到 JSON 字符串。
  // 这里有一些原子类型的示例
  bolB,_:=json.Marshal(true)
  fmt.Println(string(bolB))
  intB,_:=json.Marshal(1)
  fmt.Println(string(intB))
  fltB,_:=json.Marshal(2.34)
  fmt.Println(string(fltB))
  strB,_:=json.Marshal("gopher")
  fmt.Println(string(strB))
  // 这里有些 slice 和 map 的例子，他们将按需编码成 JSON 数组和对象。
  slcD:=[]string{"apple","peach","pear"}
  slcB,_:=json.Marshal(slcD)
  fmt.Println(string(slcB))
  mapD:=map[string]int{"apple":5,"lettuce":7}
  mapB,_:=json.Marshal(mapD)
  fmt.Println(string(mapB))
  //JSON 包将自动编码你的自定义数据类型
  // 他将在编码后的输出中只包含对外的域并且用名字作为 JSON 键
  res1D:=&Response1{
    Page:1,
    Fruits:[]string{"apple","peach","pear"}
  }
  res1B,_:=json.Marshal(res1D)
  fmt.Println(string(res1B))
  // 你可以在结构体的域声明上定制编码后的 JSON 键名。
  // 可以看上面 Reponse2 的定义
  res2D:=&Reponse2{
    Page:1,
    Fruits:[]string{"apple","peach","pear"}
  }
  res2B,_:=json.Marshal(res2D)
  fmt.Println(string(res2B))
  // 我们需要提供一个变量来放 JSON 包编码的值。
  //map[string]interface{} 将承载一个字符串数据类型的 map
  byt:=[]byte(`{"num":6.13,"strs":["a","b"]}`)
  var dat map[string]interface{}
  // 这里是相应的解码，以及相关错误的检查
  if err:=json.Unmarshal(byt,&dat);err!=nil{
    panic(err)
  }
  fmt.Println(dat)
  // 为了使用解码的 map 的值，我们需要将它们转换为合适的类型
  // 例如这里我们将 num 中饿值转变为 float64 类型
  num:dat["num"].(float64)
  fmt.Println(num)
  // 访问内部数据需要一系列的转换
  strs:=dat["strs"].([]interface{})
  str1:=strs[0].(string)
  fmt.Println(str1)
  // 我们也可以将 JSON 解码到定制的数据类型
  // 这样为程序添加了额外的类型安全，并不再需要在访问数据的时候进行类型断言
  str:=`{"page":1,"fruits":["apple","peach"]}`
  res:=Response2{}
  json.Unmarshal([]byte(str),&res)
  fmt.Println(res)
  fmt.Println(res.Fruits[0])
  // 在上面的例子中我们经常使用 bytes 和字符串在标准输出上来进行数据和 JSON 形式的交互
  // 我们也可以将 JSON 编码流入到 os.Writers 甚至 HTTP 响应体
  enc:json.NewEncoder(os.Stdout)
  d:=map[string]int{"apple":5,"lettuce":7}
  enc.Encode(d)
}

package main
import "fmt"
import "time"
func main(){
  p:=fmt.Pritnln
  // 首先获取当前时间
  now:=time.Now()
  p(now)
  // 你可以创建一个时间结构体，提供年月日等。
  // 时间经常与地区，例如时区关联
  then:=time.Date(2009,11,17,20,34,58,651387237,time.UTC)
  p(then)
  // 可以按照需要抽取时间变量中的不同部分
  p(then.Year())
  p(then.Month())
  p(then.Day())
  p(then.Hour())
  p(then.Minute())
  p(then.Second())
  p(then.Nanosecond())
  p(then.Location())
  p(then.Weekday())
  p(then.Before(now))
  p(then.After(now))
  p(then.Equal(now))
  //sub 方法返回两个时间中的时间长度
  diff:=now.Sub(then)
  p(diff)
  // 我们可以计算不同单位的持续时间长度
  p(diff.Hours())
  p(diff.Minutes())
  p(diff.Seconds())
  p(diff.Nanoseconds())
  // 可以使用 Add 来向前推进一个给定的时间
  // 或者使用减号来倒退
  p(then.Add(diff))
  p(then.Add(-diff))
}

package main
import "fmt"
import "time"
func main(){
  now:=time.Now()
  secs:=now.Unix()
  nanos:=now.UnixNano()
  fmt.Println(now)
  millis:=nanos/1000000
  fmt.Println(secs)
  fmt.Println(millis)
  fmt.Println(nanos)
  fmt.Println(time.Unix(secs,0))
  fmt.Println(time.Unix(0,nanos))
}

package main
import "fmt"
import "time"
func main(){
  p:=fmt.Println
  // 这里是一个根据 RFC3339 基本的格式化时间的例子，使用响应的布局常量
  t:=time.Now()
  p(t.Format(time.RFC3339))
  // 时间解析使用格式化相同的布局值
  t1,e:=time.Parse(
    time.RFC3339,
    "2012-11-01T22:08:41+00:00"
  )
  p(t1)
  // 格式化和解析使用基于示例的布局
  // 通常你使用常量在进行布局。但你也可以提供自定义的格式。
  // 但你必须使用 Mon Jan 2 15:04:05 MST 2006 来作为示例
  p(t.Format("3:04PM"))
  p(t.Format("Mon Jan _2 15:04:05 2006"))
  p(t.Format("2006-01-02T15:04:05.999999-07:00"))
  form:="3 04 PM"
  t2,e:=time.Parse(form,"8 41 PM")
  p(t2)
  // 纯数字展示你可以使用标准的字符串格式化及响应部分的时间值
  fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n",
    t.Year(),t.Month(),t.Day(),
    t.Hour(),t.Minute(),t.Second()
  )
  // 解析返回一个错误来说明是什么问题
  ansic:="Mon Jan _2 15:04:05 2006"
  _,e=time.Parse(ansic,"8:41PM")
  p(e)
}

package main
import "time"
import "fmt"
import "math/rand"
func main(){
  // 例如，rand.Intn 产生一个随机的整数 n，0<=n<100
  fmt.Print(rand.Intn(100),",")
  fmt.Print(rand.Intn(100))
  fmt.Println()
  //rand.Float64 返回一个随机的浮点数，0.0<=f<1.0
  fmt.Println(rand.Float64())
  // 这个可以用于产生其他区间的浮点数，如 5.0<=f<10.0
  fmt.Print((rand.Float64()*5)+5,",")
  fmt.Print((rand.Float64()*5)+5)
  fmt.Println()
  // 默认的数字产生器是 deterministic，故它每次善生的数字序列是固定的
  // 为了产生不同的序列，赋予它一个变化的种子
  // 注意，随即数字用来加密并不安全，用 crypto/rand 来做
  s1:=rand.NewSource(time.Now().UnixNano())
  r1:=rand.New(s1)
  // 调用产生的 rand.Rand
  fmt.Print(r1.Intn(100),",")
  fmt.Print(r1.Intn(100))
  fmt.Println()
  // 如果你给 Source 设置了相同的数字种子，他将产生相同的随即数字序列。
  s2:=rand.NewSrouce(42)
  r2:=rand.New(s2)
  fmt.Print(r2.Intn(100),",")
  fmt.Print(r2.Intn(100))
  fmt.Println()
  s3:=rand.NewSource(42)
  r3:=rand.New(s3)
  fmt.Print(r3.Intn(100),",")
  fmt.Print(r3.Intn(100))
}

package main
// 内置的 strconv 包提供了数字解析
import "strconv"
import "fmt"
func main(){
  //64 代表要解析的浮点数精度
  f,_:=strconv.ParseFloat("1.234",64)
  fmt.Println(f)
  //0 代表根据字符串推断基数，64 要求结果要适应 64 位
  i,_:=strconv.ParseInt("123",0,64)
  fmt.Println(i)
  //ParseInt 可以识别十六进制
  d,_:=strconv,Parseint("0x1c8",0,64)
  fmt.Println(d)
  u,_:=strconv.ParseUint("789",0,64)
  fmt.Println(u)
  //atoi 是十进制整数解析的简便函数
  k,_:=strconv.Atoi("135")
  fmt.Println(k)
  // 不合法的输入将导致解析函数返回一个错误
  _,e:=strconv.Atoi("wat")
  fmt.Println(e)
}

package main
import "fmt"
import "net"
import "net/url"
func main(){
  // 我们解析这个示例 URL，包含一个协议，授权信息，地址，端口，路径，查询参数以及查询拆分
  s:="postgres://user:pass@host.com:5432/path?k=v#f"
  // 解析这个 URL 并且保证没有错误
  u,err:=url.Parse(s)
  if err!=nil{
    panic(err)
  }
  // 可以直接访问协议
  fmt.Println(u.Scheme)
  //User 包含所有授权信息，调用 Username 和 Password 可以得到单独的值
  fmt.Println(u.User)
  fmt.Println(u.User.Username())
  p,_:=u.User.Password()
  fmt.Println(p)
  //Host 包含地址和端口。使用 SplitHostPort 来抽取他们
  fmt.Println(u.Host)
  host,port,_:=net.SplitHostPort(u.Host)
  fmt.Println(host)
  fmt.Println(port)
  fmt.Println(u.Path)
  fmt.Println(u.Fragment)
  // 为了以 k=v 的格式得到查询参数，使用 RawQuery
  // 你也可以将查询参数解析到一个 map 中
  // 解析的查询参数是从字符串到字符串的片段，故索引 0 可以只得到第一个值
  fmt.Println(u.RawQuery)
  m,_:=url.ParseQuery(u.RawQuery)
  fmt.Println(m)
  fmt.Println(m["k"][0])
}