1 Go 的根底组成有以下几局部

• 包申明
• 引入包
• 函数
• 变量
• 语句 & 表达式
• 正文

package main

import "fmt"

func main(){
 /**/
   fmt.Println("hello,world!")
}

• 每个 Go 应用程序都蕴含一个名为 main 的包
• fmt 包实现了格式化 IO（输出 / 输入）的函数
• 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须蕴含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
• 当标识符（包含常量、变量、类型、函数名、构造字段等等）以一个大写字母结尾，如：Group1，那么应用这种模式的标识符的对象就能够被内部包的代码所应用（客户端程序须要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母结尾，则对包外是不可见的，然而他们在整个包的外部是可见并且可用的（像面向对象语言中的 protected）
• 须要留神的是 {不能独自放在一行，所以以下代码在运行时会产生谬误：

···
文件名与包名没有间接关系，不肯定要将文件名与包名定成同一个。
文件夹名与包名没有间接关系，并非须要统一。
同一个文件夹下的文件只能有一个包名，否则编译报错。
···

Go 语法根底

Go 程序能够由多个标记组成，能够是关键字，标识符，常量，字符串，符号。如以下 GO 语句由 6 个标记组成：

数据类型

Go 语言变量

申明变量的个别模式是应用 var 关键字：

var identifier type

package main

import "fmt"
function main(){
    var a string = "Runoob"
    fmt.Println(a)
    
    var b,c int = 1,2
    fmt.Println(b,c)

变量申明

• 第一种，指定变量类型，如果没有初始化，则变量默认为零值
• 第二种，依据值自行判断变狼类型
• 第三种，省略 var，留神:= 左侧如果没有申明新的变量，就产生编译谬误

intVal := 1 // 此时不会产生编译谬误，因为有申明新的变量，因为 := 是一个申明语句

相当于

var intVal int 
intVal =1 

多变量申明

// 类型雷同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像, 不须要显示申明类型，主动推断

vname1, vname2, vname3 := v1, v2, v3 // 呈现在 := 左侧的变量不应该是曾经被申明过的，否则会导致编译谬误


// 这种因式分解关键字的写法个别用于申明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

值类型和援用类型

Go 语言常量

const identifier [type] = value

多个雷同类型的申明能够简写为：

const c_name1, c_name2 = value1, value2

常量还能够用作枚举

const (
    Unknown = 0
    Female = 1
    Male = 2
)

iota

iota，非凡常量，能够认为是一个能够被编译器批改的常量。

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

iota 能够被用作枚举值：

const (
    a = iota
    b = iota
    c = 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)
}

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}


以上实例运行后果为
i= 1
j= 6
k= 12
l= 24

Go 语言运算符

其余运算符

Go 语言条件语句

switch

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

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

switch 默认状况下 case 最初自带 break 语句，匹配胜利后就不会执行其余 case，如果咱们须要执行前面的 case，能够应用 fallthrough。

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

Go 语言循环

for 循环

for init; condition; post{}

for condition{}

for{}

for 循环的 range 格局能够对 slice、map、数组、字符串等进行迭代循环

for key,value := range oldMap{newMap[key] = vaule
}

package main
import "fmt"

func main() {strings := []string{"google", "runoob"}
        for i, s := range strings {fmt.Println(i, s)
        }


        numbers := [6]int{1, 2, 3, 5}
        for i,x:= range numbers {fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

Go 语言函数

func function_name([parameter list] ) [return_types] {函数体}

返回多个值

package main

import "fmt"

func swap(x, y string) (string, string) {return y, x}

func main() {a, b := swap("Google", "Runoob")
   fmt.Println(a, b)
}

函数参数

默认状况下，Go 语言应用的事值传递，即再调用过程中不会影响到理论参数

函数用法

• 函数作为另外一个函数的实参

  package main
  
  import (
    "fmt"
    "math
  )
  
  func main(){getSquareRoot := func(x float64) float64{return math.Sqrt(x)
    }
    
    fmt.Println(getSquareRoot(9))
  }

• 闭包
  Go 语言反对匿名函数，可作为闭包。匿名函数是一个”内联“语句或表达式。匿名函数的优越性在于能够间接应用函数外部的变量，不用申明。

package main

import "fmt"

func getSequence() func() int {
  i:=0
  
  return func() int {
    i+=1
    return i
  }
}

func main(){nextNumber := getSequence()
  
  fmt.Println(nextNumber())
  fmt.Println(nextNumber())
  fmt.Println(nextNumber())
  
  nextNumber1 := getSequence()
  fmt.Println(nextNumber1())
  fmt.Println(nextNumber1())

• 办法

Go 语言变量作用域

作用域为以生命标识符所示意的常量、类型、变量、函数或包再源代码中的作用范畴。

int -> 0
float32 -> 0
pointer -> nil

Go 语言数组

申明数组

var variable_name [size] variable_type

var balance [10] float32

初始化数组

var balance = [5]float32{100.0,2.0.3.4,7.0,50.0}

balance := [5]float32{1000.0,2.0,3.4,6.0,50.0}

如果数组长度不确定，能够应用 … 代替数组的长度，编译器会依据元素个数自行推断数组的长度：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，咱们还能够通过指定下标来初始化元素：

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

多维数组

var variable_name [size1][size2]...[sizeN] variable_type

var threadim [5][10][4]int

初始化二维数组

a := [3][4]int{{0,1,2,3},
 {4,5,6,7},
 {8,9,10,11},
}

留神：以上代码中倒数第二行的 } 必须要有逗号，因为最初一行的 } 不能独自一行，也能够写成这样：

a := [3][4]int{{0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11}}   /* 第三行索引为 2 */

向函数传递数组

形式一
设置形参大小

void myFunction(param [10]int)
{...}

形式二
未设置数组大小

void myFunction(param []int)
{...}