GoLang(2）

Go 语言函数

Go 语言函数定义格式如下：

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

函数定义解析：

• func：函数由 func 开始声明
• function_name：函数名称，函数名和参数列表一起构成了函数签名。
• parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
• return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
• 函数体：函数定义的代码集合。

函数调用

package main

import "fmt"

func swap(x, y string) (string, string) {     #返回两个值
   return y, x
}

func main() {
   a, b := swap("Mahesh", "Kumar")            #函数调用
   fmt.Println(a, b)
}

函数参数

传递类型	描述
值传递	值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递	引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

 

 

 

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

值传递

/* 定义相互交换值的函数 */
func swap(x, y int) int {
   var temp int

   temp = x /* 保存 x 的值 */
   x = y    /* 将 y 值赋给 x */
   y = temp /* 将 temp 值赋给 y*/

   return temp;
}

引用传递

/* 定义交换值函数*/
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保持 x 地址上的值 */                          #指针变量
   *x = *y      /* 将 y 值赋给 x */
   *y = temp    /* 将 temp 值赋给 y */
}

package main

import "fmt"

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

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

   /* 调用 swap() 函数
   * &a 指向 a 指针，a 变量的地址
   * &b 指向 b 指针，b 变量的地址
   */
   swap(&a, &b)         #&a得到变量的内存地址

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

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

Go 语言数组

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type    #var  数组名称  [数组长度] 数据类型

var balance [10] float32

Go 语言支持多维数组，以下为常用的多维数组声明方式：

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

var threedim [5][10][4]int

初始化数组

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

Go 语言指针

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

什么是指针

一个指针变量指向了一个值的内存地址。当一个指针被定义后没有分配到任何变量时，它的值为 nil

var var_name *var-type

Go 语言结构体

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

结构体表示一项记录，比如保存图书馆的书籍记录，每本书有以下属性：

• Title ：标题
• Author ： 作者
• Subject：学科
• ID：书籍ID

定义结构体

定义： type+结构体名称+struct { }

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

这里是将结构体定义成为一个变量类型，定义以后就能用于变量的声明。

package main

import "fmt"

type book struct {
    titile string
    author string
    subject string
    book_id int
}

func main(){

    var book1 book
    var book2 book
    book1.titile="GO语言"
    book1.author="小明"
    book1.subject="Go语言教程"
    book1.book_id=1
    book2.titile="python语言"
    printBook(book1)
    printbook_prt(&book2)     #输入的参数为变量的内存地址 
}

func printBook(books book){
    fmt.Printf("Book title : %s
",books.titile)  #访问机构体成员，需使用.操作符   结构体.成员名
    fmt.Printf("Book title : %s
",books.author)
    fmt.Printf("Book title : %s
",books.subject)
    fmt.Printf("Book title : %d
",books.book_id)
}
func printbook_prt(book *book){
    fmt.Printf("Book title : %s
",book.titile)
}

Go 语言切片(Slice)     ---长度可变的数组

定义切片

你可以声明一个未指定大小的数组来定义切片：

var identifier []type

切片不需要说明长度。

或使用make()函数来创建切片:

var slice1 []type = make([]type, len)     #len代表切片的初始长度

也可以简写为

slice1 := make([]type, len)

初始化切片