二、Go基础语法

1.Go语言结构

package main

import "fmt"

func main() {
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}

仅声明与其他编程语言不同的点。

第一行代码 package main 定义了包名。必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
{ 不能单独放在一行，否则会报错。

2.Go数据类型和基础语法

与其他编程语言几乎一样，不展开。

3.Go语言变量和常量

变量

共有三种声明变量的方法。

指定变量类型，声明后若不赋值，使用默认值。
```
var v_name v_type
v_name = value
```
根据值自行判定变量类型
```
var v_name = value
```
省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误。该命名方法只能用在方法内。
```
func main(){
    a := 10
}
```

常量

使用const声明常量。

显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数ß
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}


//输出结果为：0 1 2 ha ha 100 100 7 8

4.Go 条件判断

if语句

与java的条件判断语句基本相同，但是条件表达式不需要用 ()。

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

if 布尔表达式 1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {
      /* 在布尔表达式 2 为 true 时执行 */
   }
}

switch

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。

一个case 后面可以跟两个条件，用,分割。

switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break。

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

Type switch

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:      
         fmt.Printf(" x 的类型 :%T",i)                
      case int:      
         fmt.Printf("x 是 int 型")                       
      case float64:
         fmt.Printf("x 是 float64 型")           
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )       
      default:
         fmt.Printf("未知型")     
   }   
}

select

select是Go中的一个控制结构，类似于用于通信的switch语句。每个case必须是一个通信操作，要么是发送要么是接收。

select随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。一个默认的子句应该总是可运行的。

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s); 
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

每个case都必须是一个通信
所有channel表达式都会被求值
所有被发送的表达式都会被求值
如果任意某个通信可以进行，它就执行；其他被忽略。
如果有多个case都可以运行，Select会随机公平地选出一个执行。其他不会执行。

否则：
1. 如果有default子句，则执行该语句。
2. 如果没有default字句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。

5.Go语言循环

for循环

主要有3种用法

1.与C语言的for循序一样：

for init; condition; post { }

for a = 1; a < 100 ; a++{
    //dosomething
}

2.与C语言的while一样：

for condition { }

for true{
     //dosomething
}

3.和 C 的 for(;;) 一样：

for {
    //dosomething
}
//跟for true其实一样

嵌套循环的用法与其他语音一样。

for [condition |  ( init; condition; increment ) | Range]
{
   for [condition |  ( init; condition; increment ) | Range]
   {
      statement(s);
   }
   statement(s);
}

range的用法

类似于Python。

循序控制语句

break

用于循环语句中跳出循环，并开始执行循环之后的语句。

continue

跳过当前循环执行下一次循环语句。

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。

goto语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。

但是，在结构化程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解和调试程序都产生困难。

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* 循环 */
   LOOP: for a < 20 {
      if a == 15 {
         /* 跳过迭代 */
         a = a + 1
         goto LOOP
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++     
   }  
}

二、Go 基础语法