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())
}
*/
