go语言2

所有文件内的package必须一样（可以改别名，但是各个文件内的别名要一样）

-函数高级

• 闭包函数

  闭包函数：定义在函数内部，对外部作用有引用
  内层函数：定义在函数内部的函数
  
  //(重点) go中函数内部定义的函数是不能有名的，需要定义匿名函数:没有名字
  
  func testt(a int)  {
  	func() {
  		fmt.Println("我是内层函数")
  	}()//此处，内部函数定义了，就必须使用！！或者赋值给变量
  }
  
  
  func testt(a int) (func()) {//func（）是它的返回类型为函数！
  	//var c int =100
  	b:= func() {
  		fmt.Println(a)
  		fmt.Println("我是闭包函数")
  	}
  	return b
  }
  
  func testt(a int) func(){
  	b:= func() {
  		fmt.Println(a)
  		fmt.Println("我是内部的函数")
  	}
  	return b
  }
  func main()  {
  	a:=testt(111111)
  	a()
  }
  

• 类型命别名

  type MyInt int
  
  var a MyInt=10
  var b int =90
  a=MyInt(b)
  fmt.Println(a)
  

-if-else

• -基本用法

  if 条件{
  }else if 条件{
  }else{
  }
  

• -在条件中可以定义变量

  if a:=80;a>90{
  }
  

-包

• 前言：其实就是导模块

  		-新建一个文件夹，内部写很多go文件，但是包名必须一致
  		-如果想在外部包使用，首字母必须大写；小写则是内部使用
  		-在其他包中使用
  			-import "mypackage"
  			-mypackage.Test1()
  		-下载第三方包
  			go get github.com/astaxie/beego
  			beego、gin
  

• 实例

  mypackage 1

  package mypackage
  
  func test(a,b int ) int {
  	//fmt.Println(a+b)
  	return a+b
  }
  
  

  mypackage 2

  package mypackage
  
  import "fmt"
  
  func Test2()  {
  	fmt.Println(test(1,2))// 那边return才能用
  	fmt.Println("这里是Test2")
  }
  

  调用

  // 包的使用
  package main
  
  import "mypackage"
  import "fmt"
  
  
  
  func main() {
  
  	//想使用mypackage包下的test函数和test1函数
  	mypackage.Test2()
  	fmt.Println("这里是S3")
  
  }
  

-循环

-switch语句

• switch相当于if-else

  //基本用法
  a:=10
  switch a {
  	case 1:
  fmt.Println("1")
  	case 2:
  fmt.Println("2")
  	case 10:
  fmt.Println("10")
  }
  

• default相当于else：最后其他情况

• 多值匹配

  	a:=11
  	switch a {
  	case 1,4,5:
  		fmt.Println("1")
  	case 2,8,9:
  		fmt.Println("2")
  	case 10,11:
  		fmt.Println("10")
  	default:
  		fmt.Println("不知道")
  	}
  

• 无表达式的 switch：相当于a写在内部

  	a:=11
  	switch {
  	case a > 10:
  		fmt.Println("大于10")
  	case a < 10:
  		fmt.Println("小于10")
  	default:
  		fmt.Println("10")
  	}
  

• Fallthrough（坠落，穿过）:达到条件，继续执行一个

  	//Fallthrough
  	a := 1
  	switch a {
  	case 1:
  		fmt.Println("1")
  		fmt.Println("xxxx")
  		//穿透，无条件执行下一个case的内容
  		fallthrough
  	case 11:
  		fmt.Println("11")
  		test5()
  

-数组和切片

• 定义

  //数组 在定义阶段，长度和类型就固定了，以后不能更改
  
  var a [5]int  //定义了一个长度为5的int类型数组
  

• 指定数组位置的值

  	//第99个位置设为99
  	a :=[100]int{1,2,98:99,87:88}
  
  	fmt.Println(a)
  

• 数组是值类型

  // 所有的函数传参都是copy传递
  //所有的函数传参都是copy传递,不会影响本身
  a:=[4]int{1,2,3}
  test6(a)
  fmt.Println(a,"111")
  
  func test6(b [4]int)  {
  	b[0]=100
  	fmt.Println(b)
  }
  

• 数组迭代（取值）

  	var a=[4]int{1,2,}
  	for i:=0;i<len(a);i++{
  		fmt.Println(a[i])
  	}
  

  • 通过range迭代

    var a=[4]int{1,2,}
    for i,_ := range a{
    	fmt.Println("----",i)
    }
    

• 多维数组

  //多维数组
  var a [7][2]int//产生一个7位数字类型两两一对的数组
  a[0][1]=100
  fmt.Println(a)
  

编译型语言和位置无关

同一包下，无需导入，直接使用