go 基本语法

====type====

import (
	"fmt"
	)

func main()  {
	type bigint byte //定义类型
	var a  bigint
	fmt.Printf("a type is %T\n",a)
	type(
		long int64
		char byte
	)
	var b char ='a'
    var c long =1000

	fmt.Printf("b=%c,c=%d",b,c)




========channel========

package main

import (
	"time"
	"fmt"
)

func test_channel()  {
	//ch:=make(chan int)
	ch<-1
	ch<-1
	fmt.Println("come to end go runtime 1")
}

var  ch  chan  int
func main()  {
	ch =make(chan int,0)
	go test_channel()
	time.Sleep(2* time.Second)
	fmt.Println("runing end")
	<-ch
	time.Sleep(time.Second)
}

=====协程==========
package main

import (
	"fmt"
	"time"
)

func test_Rou(){
	fmt.Println("ddd")
}
func Add (x,y int){
	z:=x+y
	fmt.Println(z)
}
func main()  {	
	go test_Rou()
	for index := 0; index < 10; index++ {
		go Add(index,index)
	}
	time.Sleep(10)
}

 

-----指针----
package main
import ("fmt")
func swap(p1 * int,p2 * int){
   *p1,*p2 =*p2,*p1;
}
func main() {
  a :=10;
 var p * int;p=&a;
 fmt.Printf("p=%d,&a=%v,*p=%v\n",p,&a,*p)
  a,b :=10,20
  swap(&a,&b)
  fmt.Printf("a=%d,b=%d\n",a,b)
}

　　

--------多维数组------
package  main
import (
	"fmt"
)
func main() {
	//多维数组
 //var a [10] int
 //var b [5] int
  //fmt.Println(a,b);	   
  var c [3][4] int
  k:=0;
  for i:= 0; i<3; i++ {
	  for j := 0; j <4; j++	{
		  k++;
		  c[i][j]=k;
		  fmt.Printf("a[%d][%d]=%d,\n",i,j,c[i][j])
		  //frm.fmt.Println(i,j,a[i][j])
	  }
   }

}

 

 

 

 

 

 

 

 

 随机数

 

 

　产生数据数　

package main

import (
    "fmt"
    "math/rand"
    "strconv"
    "time"
)

func main() {
    //设置随机数种子
    rand.Seed(time.Now().UnixNano())
    var captcha string
    for i := 0; i < 6; i++ {
        //产生0到9的整数
        num := rand.Intn(10)
        //将整数转为字符串
        captcha += strconv.Itoa(num)
    }
    fmt.Println(captcha)
}

　　

 ---go 回调函数

package main

import (
	"fmt"
)

type FuncType01 func(int,int)int

//回调函数 就是函数有一个参数是函数类型，这个函数就是回调函数
//fTest FuncType01 多态接口 调用一个接口，可以有不同实现方式

func Calc(a,b int,fTest FuncType01)(result int){ //fTest = Add1
//  fmt.Println("Calc")
  result = fTest(a,b)
  //result =Add1（3，4）
  return
}

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

// func Minus1(a,b int) int  {
// 	return  a -b
// }

// func Mul(a,b int) int{
// 	return  a*b
// }

func main()  {

	a := Calc(3,4,Add1)
	fmt.Println("a=",a)

	// a = Calc(7,5,Minus1)
	// fmt.Println("a=",a)

	// a = Calc(4,3,Mul)
	//fmt.Println("a=",a)

}

 

-----闭包及闭包的特点　

package main

import "fmt"

func main(){
	 a := 20
	 str := "aaa"

	 func(){
	 	//闭包以引用的方式捕获外部变量
	 	a = 40
	 	str ="bbb"
	 	fmt.Printf("a=%d,str=%s\n",a,str)
	 }()

	fmt.Printf("a=%d,str=%s\n",a,str)

}

package main

import "fmt"

func test() func() int {

  var x int //x没有初始化，值为0

  return func() int {

     x++

     return x*x

  }

}

func main()  {

  //返回值是一个匿名函数，返回一个函数类型，通过f来调用返回的匿名函数，f来    调用闭包函数

  //f不关心这些捕获的变量和常量是否超出作用范围，只要你的f存在，还在使用x，这个变量x就会一直存在

  f := test()

  fmt.Println(f())

  fmt.Println(f())

  fmt.Println(f())

  fmt.Println(f())

    f = test()

    fmt.Println(f())

}

/*

func test() int  {

    //函数调用时候，x才会分配空间，才初始化为0

    var x int //没有初始化，值为0

    x++

    return x*x //函数调用完毕，x自动释放

}

func main(){

    fmt.Println(test())

    fmt.Println(test())

    fmt.Println(test())

    fmt.Println(test())

}

*/