本文已参与「新人创作礼」活动，一起开启掘金创作之路。

Go语言的变量作用域

/*package main

import "fmt"

//全局变量
var t int

// Go语言中全局变量和局部变量的名称可以相同，但同时出现会优先考虑局部变量
func main() {
   //局部变量
   var a, b, c int
   a = 10
   b = 20
   c = a + b
   t = a + b
   fmt.Printf("结果：a = %d, b = %d, c = %d\n", a, b, c)
   fmt.Printf("结果：a = %d, b = %d, t = %d\n", a, b, t)
}*/

//形式参数
package main

import (
   "fmt"
)

var a int = 20

func sum(a, b int) int {
   fmt.Printf("sum()函数中 a = %d\n", a)
   fmt.Printf("sum()函数中 b = %d\n", b)

   return a + b
}

func main() {
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("main()函数中 a = %d\n", a)
   c = sum(a, b)
   fmt.Printf("main()函数中 c = %d\n", c)
}

局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。

全局变量

在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。

全局变量可以在任何函数中使用

形式参数

形式参数会作为函数的局部变量来使用

Go语言的数组

package main

import "fmt"

/*func main() {
/*var num [10]int
var i, j int

for i = 0; i < 10; i++ {
   num[i] = i + 100
}

//输出每个数组元素的值
for j = 0; j < 10; j++ {
   fmt.Printf("num[%d] = %d\n", j, num[j])
}*/

/*var i, j, k int
   //声明并初始化数组
   num := [5]float64{123, 32, 0.9, 32.9, 5.2}

   //输出数组元素
   for i = 0; i < 5; i++ {
      fmt.Printf("num[%d] = %f\n", i, num[i])
   }

   num2 := [...]float64{123, 32, 0.9, 32.9, 5.2}
   for j = 0; j < 5; j++ {
      fmt.Printf("num2[%d] = %f\n", j, num2[j])
   }

   //将索引为1和3 的元素初始化
   num3 := [5]float64{1: 2.0, 3: 7.0}
   for k = 0; k < 5; k++ {
      fmt.Printf("num3[%d] = %f\n", k, num3[k])
   }
}
*/
//多维数组
//初始化一个二维数组
/*func main() {
   size := [2][2]string{}

   //添加元素
   size[0][0] = "abcd"
   size[0][1] = "efg"
   size[1][0] = "hijk"
   size[1][1] = "lmn"

   //显示结果
   fmt.Println(size)
}
*/

/*func main() {
   //创建数组
   values := [][]int{}

   //使用append()函数向空的二维数组添加两行一维数组
   row1 := []int{1, 2, 3}
   row2 := []int{4, 5, 6}
   values = append(values, row1)
   values = append(values, row2)

   //显示数据
   fmt.Println("row 1", values[0])
   fmt.Println("row 2", values[1])

   //访问第一个元素
   fmt.Println(values[0][0])
}*/

//Go 语言向函数传递数组
func getAvg(arr []int, size int) float64 {
   var i int
   var avg, sum float64

   for i = 0; i < size; i++ {
      sum += float64(arr[i])
   }

   avg = sum / float64(size)

   return avg
}

func main() {
   var nums = []int{1, 3, 2.0, 5, 4.0}
   var avg float64

   avg = getAvg(nums, 5)
   fmt.Printf("平均值：%f", avg)

}

Go语言的指针

package main

import "fmt"

const MAX int = 3

func main() {
   var a int = 10
   var ip *int  //声明指针变量
   ip = &a      //指针变量的存储地址
   var ptr *int //空指针

   fmt.Printf("变量的地址：%x\n", &a)
   fmt.Printf("ip 变量存储的指针地址：%x\n", ip)
   fmt.Printf("ip 变量的值：%d\n", *ip)

   fmt.Printf("ptr 的值为：%x\n", ptr) //空指针的值

   //指针数组
   aa := []int{10, 20, 30} //声明整型指针数组并初始化
   var i int
   var p [MAX]*int

   for i = 0; i < MAX; i++ {
      p[i] = &aa[i]
   }
   for i = 0; i < MAX; i++ {
      fmt.Printf("a[%d] = %d\n", i, *p[i])
   }
}

package main

import "fmt"

func main() {
   //多级指针
   var a int = 1
   var ptr *int
   var pptr *(*int)

   a = 3000

   //指针ptr地址
   ptr = &a
   pptr = &ptr

   //获取pptr的值
   fmt.Printf("变量 a = %d\n", a)
   fmt.Printf("指针变量 *ptr = %d\n", *ptr)
   fmt.Printf("指向指针的指针变量 **pptr = %d\n", *(*pptr))
}


//Go语言允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可
package main

import "fmt"

func swap(x *int, y *int) {
   var temp int
   temp = *x
   *x = *y
   *y = temp
   /*
      上述代码简化
      *x, *y = *y, *x
   */
}

func main() {
   var a int = 100
   var b int = 200

   fmt.Printf("交换前a：%d, b：%d\n", a, b)

   swap(&a, &b)

   fmt.Printf("交换后a：%d, b：%d\n", a, b)
}