Go语言编程（二）顺序编程

变量

1. 声明

   var v1 int //变量
   var v3 [10]int //数组
   var v5 *int //指针
   var ( //组合定义
       v7 int
       v9 string
   )
   

2. 初始化
   定义有三种方式

   var v1 int = 1
   var v1 = 1  //正确
   v1 := 1 //正确，编译器自动推导出类型
   

   虽然不用指定类型，是因为编译器承担了这部分的工作。但是Go并不是动态类型语言，而是强类型语言（静态类型语言）

3. 赋值
   初始化和赋值是两个概念。Go语言支持多重赋值，如i，j = j,i实现变量值的交换。

4. 匿名变量
   使用多个返回值和匿名变量结合代码更加优雅
   如fun1函数有三个返回值

       func fun1() (ret1,ret2,ret3){
           return 1,2,3
       }
   

   如果只需要ret3,可以如下编写_,_,ret := fun1()

常量

1. 常量的定义

   const Pi float64 = 3.14159265358
   const mask = 1 << 3 //左移三位。常量的赋值是一个编译期的行为，因此可以赋值为一个编译期运算的常量表达式
   // 但是不能定义为运行期才能得到的表达式
   

2. 预定义的常量
   Go语言预定义的常量包括： true ,false, itoa

   itoa 是一个自增常量，const关键字出现的时候被初始化为0，之后再遇到const，自增1

   const (
       c0 = itoa //0
       c1 = itoa //1
       a = 1 << itoa //2
   )
   

3. 枚举类型
   GO语言不支持enum关键字。

   //注意，Go公有访问的属性，变量，大写字母开头； 私有的以小写字母开头。
   

4. 类型
   内置的类型有：

   • 布尔类型，bool
   • 整型： int8,byte,int16,int,unit,unitptr等
   • 浮点类型： float32 float64
   • 复数类型： complex64 complex128
   • 字符串 string
   • 字符 :有两种,byte一种，另：unicode字符rune
   • 错误类型 error

   还有复合类型：

    指针（pointer）
    数组（array） //需要注意再go语言中，数组是值类型，即作为函数参数的时候，是复制传值而不是传址
    切片（slice） //数组是值类型，定义之后无法修改，因此需要用切片
    字典（map）
    通道（chan）
    结构体（struct）
    接口（interface）
   

5. 数组切片
   主要有两种，一种基于现有数组的切片,一种直接创建切片

   • 基于数组的切片

   package main
   
   import "fmt"
   
   func main() {
       var myArray [10]int = [10]int{1,2,3,4,5,6,7,8,9,10}
       //基于数组创建一个切片
       var mySlice []int = myArray[:5] //前五个元素，使用格式myArray[first:last]
       
       `("Elementary of myArray:")
       for _,v := range myArray{
           fmt.Print(v," ")
       }
       fmt.Println("\nElementary of mySlice:")
       for _,v := range mySlice{
           fmt.Print(v," ")
       }
       fmt.p
   }
   
   

   运行结果：

   Elementary of myArray:
   1 2 3 4 5 6 7 8 9 10 
   Elementary of mySlice:
   1 2 3 4 5 
   

   • 直接创建切片

     1. mySlice1 := make([]int, 5) //创建个数为5的数组切片，并初始化为0
     2. mySlice2 := make（[]int, 5, 10） //创建元素个数为5的数组切片，并初始化为0，还要预留10个元素的存储空间
     3. myslice3 := []int{1,2,3,4,5} //创建并初始化

   • 元素遍历

     for i, v := range myslice {}, range表达式有两个返回值，第一个是索引，第二个是元素的值

   • 动态增减元素

     与数组相比，数组切片多了一个存储能力的概念，元素个数和分配的空间可以是两个不同的值，合理设置存储能力，可以大幅降低数组切片增加时内存操作的频率，从而提高程序性能。

     如果定义的数组切片存储能力过小，在超出的时候，内存需要重新分配一块较大的内存，并把原先的内存卡赋值过来，开销较大

   • 基于数组切片创建数组切片

     oldSlice := []int(1,2,3,4,5)
     newSlice := oldSlice[:3] //取前三个。
     

   • 内容复制

     copy(slice2, slice1) //slice1复制到slice2,长度限制
     

6. map
   在其他的语言中，map需要引入其他库，没有作为内置类型。Golang中有

   var person map[int]  string //声明
   //  变量名      键类型   值类型
   person = make(map[int]string) //创建
   person[1] = "John" //赋值
   name, ok := person[2] //查询
   //值，查询结果
   delete(person, 1) //删除
   

流程控制

流程控制一般有四种，条件语句，循环语句，选择语句，跳转语句。跳转还比较少。

1. 条件语句

   if a < 5 { //条件不用括号包围
       return 0
   } else { //花括号必须有且只能在这里
       return 1
   }
   

2. 选择语句

   switch i { //可以不指定变量，可以留空这里
       case 0：
           fmt.Println(0)
       case 1:
           fmt.Println(1)
       default:
           fmt.Printf("default")
   }
   

3. 循环语句
   GO语言中，只支持for语句的循环，没有when和while

   sum := 0
   for i:=0; i < 10; i++{
       sum += i;
   }
   //或者
   sum := 0
   i := 0
   for {
       sum += i++
       if i > 10{
           break
       }
   }
   

4. 跳转语句

goto语句被很多人看做不合时宜，如再c语言老师教学的时候会说这个关键字被弃置了，不推荐使用。但是再go语言中竟然还支持，不知道为什么。
但是 **存在的既是合理的** ，第一次听说是高三班主任的名言，印象深刻
```golang
func myfunc() {
i := 0
HERE:
fmt.Println(i)
i++
if i < 10 {
    goto HERE
}
}   
```

函数

1. 函数定义

func FuncName (a int, b string) (ret int ,err error){
//func关键字 函数名 （参数列表） （返回值列表）    
}

2. 函数调用

import packname
...
packname.FuncName(1, "2")
//**必须注意，大写字母开头的为公有属性，小写字母开头的私有属性，这条规则同样适用于变量和类型**

3. 不定参数

//定义
func func1(args ...int) //不定个数的参数，但是类型必须完全不是整型

//参数的传递
func1(1,2,3,4) 
func1（args...）
func1（args[1:]...） //可以给传递一个数组切片，因为本质上这个不定参数就是数组切片实现的，只是编写的时候不用太繁琐

//任意类型的不定参数
使用interface{}传递任意类型的参数是go语言的默认惯例
func myPrint(args ...interface{}){
    for _,arg := range args{
        switch arg.(type){
            case int:
            ...
            case string:
            ...
            default:
            ...
        }
    }
}

4. 多返回值
   与其他语言不同的事，golang可以有多个返回值，比如查询一个文件的大小，如果有就返回具体的值，如果为空返回nil，如果出错则返回具体的出错信息。如果要跳过某个具体的值，则使用_下划线
5. 匿名函数和闭包