Go语言学习2

1.语言函数

1.定义函数

func max(num1, num2 int) int {
   /* 声明局部变量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result
}

定义函数用func 接下来函数名 定义变量 数据类型 （输出数据类型，输出数据的必要条件）；

定义的函数也可以同时输出两个数据，例如（string，string）或（int，int）;

函数传递时有值传递和引用传递，前者是将值复制一份代入函数，对值没有一影响；

后者是通过&a，&b即用指针将值的地址传到函数中，在函数中对值的修改将不再局限于函数。

2.闭包与方法

可以做到变量常驻内存但是不会污染全局。 

闭包就是定义的匿名函数中返回一个函数，使定义的变量会绑定函数。

方法就是包含了接收者的函数。

这个接受体是一个自定义类型，但是不能是基础类型例如int。

package main

import (
   "fmt"  
)

/* 定义结构体 */
type Circle struct {
  radius float64
}

func main() {
  var c1 Circle
  c1.radius = 10.00
  fmt.Println("圆的面积 = ", c1.getArea())
}

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

2.GO语言变量作用域

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

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

3.Go 语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑 

3.数组

 1.定义数组

var variable_name [SIZE] variable_type

即： 定义 数组名 [长度] 数组数据类型

对于不确定长度的数组，可以用...代替数组的长度

2.二维数组

对于二维数组就是 name:= [2][3] int{}

也就是创造一个二行三列的表格，[ ]中的数字代表的是行或列的长度

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

4.Go语言指针 

1. 指针引用前需要声明，声明格式如下：

var var_name *var-type

即 ：var 名字 *数据类型

使用指针

1）定义 2）赋值 3）使用

package main

import "fmt"

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}

2.Go空指针

空指针 名为nil，也就是说未赋值的指针地址为0，可以用来条件判断，if（name==nil）即表示当指针为空指针的情况。

3. 指针数组

指针数组 var zzsz [number] *int

则可创造一个指针数组，zzsz[0]即代表该数组中的第一个值

4.指向指针的指针

指针储存的是变量的地址，指向指针的指针即储存该地址的地址：

定义 ： var ptr**int

5.go语言指针作为函数的参数

package main

import "fmt"

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

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

   /* 调用函数用于交换值
   * &a 指向 a 变量的地址
   * &b 指向 b 变量的地址
   */
   swap(&a, &b);

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

func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保存 x 地址的值 */
   *x = *y      /* 将 y 赋值给 x */
   *y = temp    /* 将 temp 赋值给 y */
}

作用：可以利用函数改变变量的值并且影响到函数外的变量。

5.Go语言结构体

结构体就是包含了不同类型的结合，不局限于一种类型中。

定义 ： type name struct{

        变量1  数据类型

        变量2  数据类型

}

如果要访问结构体成员

结构体.成员名

结构体函数参数

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
   var Book1 Books        /* 声明 Book1 为 Books 类型 */
   var Book2 Books        /* 声明 Book2 为 Books 类型 */

   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   /* 打印 Book1 信息 */
   printBook(Book1)

   /* 打印 Book2 信息 */
   printBook(Book2)
}

func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title)
   fmt.Printf( "Book author : %s\n", book.author)
   fmt.Printf( "Book subject : %s\n", book.subject)
   fmt.Printf( "Book book_id : %d\n", book.book_id)
}

！！！结构体指针！！！

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
   var Book1 Books        /* 声明 Book1 为 Books 类型 */
   var Book2 Books        /* 声明 Book2 为 Books 类型 */

   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   /* 打印 Book1 信息 */
   printBook(&Book1)

   /* 打印 Book2 信息 */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title)
   fmt.Printf( "Book author : %s\n", book.author)
   fmt.Printf( "Book subject : %s\n", book.subject)
   fmt.Printf( "Book book_id : %d\n", book.book_id)
}