go 函数使用细节讨论和小练习_函数细节讨论-CSDN博客

本文链接：https://blog.csdn.net/chengqiuming/article/details/115606561

一细节讨论

1 函数的形参列表可以是多个，返回值列表也可以是多个。

2 形参列表和返回值列表的数据类型可以是值类型和引用类型。

3 函数的命名遵循标识符命名规范，首字母不能是数字，当首字母大写，该函数可以被本包文件和其它包文件使用，类似 public , 当首字母小写，只能被本包文件使用，其它包文件不能使用，类似 private。

4 函数中的变量是局部的，函数外不生效。

// 函数中的变量是局部的，函数外不生效
func test() {
   // n1 是 test 函数的局部变量, 只能在test函数中使用
   var n1 int = 10
   fmt.Println(n1)
}

func main(){
   // 这里不能使用 n1，因为 n1 是 test 函数的局部变量
   fmt.Println(n1); // error
}

5 基本数据类型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值。

a 代码

func test02(n1 int) {
   n1 = n1 + 10
   fmt.Println("test02() n1= ", n1)
}


func main() {
   num := 20
   test02(num)
   fmt.Println("main() num= ", num)
}

b 测试

test02() n1=  30
main() num=  20

6 如果希望函数内的变量能修改函数外的变量(指的是默认以值传递的方式的数据类型)，可以传入变量的地址，函数内以指针的方式操作变量。从效果上看类似引用。

a 代码

// n1 就是 *int 类型
func test03(n1 *int) {
   fmt.Printf("n1的地址 %v\n", &n1)
   *n1 = *n1 + 10
   fmt.Println("test03() n1= ", *n1) // 30
}

func main() {
   num := 20
   fmt.Printf("num的地址=%v\n", &num)
   test03(&num)
   fmt.Println("main() num= ", num) // 30
}

b 测试

num的地址=0xc04204c080
n1的地址 0xc04206a020
test03() n1=  30
main() num=  30

c 图解

7 Go 函数不支持函数重载。

func test02(n1 int) {
   n1 = n1 + 10
   fmt.Println("test02() n1= ", n1)
}


// go 不支持传统的函数重载，会报函数重复定义
func test02(n1 int, n2 int) {
}

8 在 Go 中，函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量。通过该变量可以对函数调用。

a 代码

func getSum(n1 int, n2 int) int {
   return n1 + n2
}

func main() {
   a := getSum
   fmt.Printf("a的类型%T, getSum类型是%T\n", a, getSum)

   res := a(10, 40) // 等价  res := getSum(10, 40)
   fmt.Println("res=", res)
}

b 测试

a的类型func(int, int) int, getSum类型是func(int, int) int
res= 50

9 函数既然是一种数据类型，因此在 Go 中，函数可以作为形参，并且调用。

a 代码

package main

import "fmt"

// 在Go中，函数也是一种数据类型。
// 可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用
func getSum(n1 int, n2 int) int {
   return n1 + n2
}

// 函数既然是一种数据类型，因此在 Go 中，函数可以作为形参，并且调用
func myFun(funvar func(int, int) int, num1 int, num2 int) int {
   return funvar(num1, num2)
}

func main() {
   res2 := myFun(getSum, 50, 60)
   fmt.Println("res2=", res2)
}

b 测试

res2= 110

10 为了简化数据类型定义，Go 支持自定义数据类型

基本语法

type 自定义数据类型名数据类型 // 相当于一个别名

示例

type myInt int // 这时 myInt 就等价 int 来使用

示例

type mySum func (int, int) int // 这时 mySum 就等价一个函数类型 func (int, int) int

a 代码

func main() {
   // 给int取了别名，在 go 中 myInt 和 int 虽然都是 int 类型，但是 go 认为 myInt 和 int 是两个类型
   type myInt int
   var num1 myInt
   var num2 int
   num1 = 40
   num2 = int(num1) // 注意这里依然需要显示转换,go 认为 myInt 和 int 是两个不同类型
   fmt.Println("num1=", num1, "num2=", num2)
}

b 测试

num1= 40 num2= 40

c 代码

package main

import "fmt"

// 在Go中，函数也是一种数据类型。
// 可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用
func getSum(n1 int, n2 int) int {
   return n1 + n2
}

// 这时 myFunType 就是 func(int, int) int类型
type myFunType func(int, int) int

// 函数既然是一种数据类型，因此在 Go 中，函数可以作为形参，并且调用
func myFun2(funvar myFunType, num1 int, num2 int) int {
   return funvar(num1, num2)
}

func main() {
   res3 := myFun2(getSum, 500, 600)
   fmt.Println("res3=", res3)
}

d 测试

res3= 1100

11 支持对函数返回值命名

a 代码

package main

import "fmt"

// 支持对函数返回值命名
func getSumAndSub(n1 int, n2 int) (sum int, sub int) {
   sub = n1 - n2
   sum = n1 + n2
   return
}

func main() {
   a1, b1 := getSumAndSub(1, 2)
   fmt.Printf("a=%v b=%v\n", a1, b1)
}

b 测试

a=3 b=-1

12 使用 _ 标识符，忽略返回值。

13 Go 支持可变参数

// 支持0到多个参数
func sum(args... int) sum int{
}
// 支持1到多个参数
func sum(n1 int,args... int) sum int{
}

a 说明

args是slice切片，通过args[index]可以访问各个值。

如果一个函数的形参列表中有可变参数，则可变参数需要放在形参列表最后。

b 代码

package main

import "fmt"

// 编写一个函数sum ,可以求出1到多个int的和
// 可以参数的使用
func sum(n1 int, args ...int) int {
   sum := n1
   // 遍历args
   for i := 0; i < len(args); i++ {
      sum += args[i] //args[0] 表示取出args切片的第一个元素值，其它依次类推
   }
   return sum
}


func main() {
   // 可变参数的使用
   res4 := sum(10, 0, -1, 90, 10, 100)
   fmt.Println("res4=", res4)
}

c 测试

res4= 209

二小练习

1 代码分析

2 代码分析

3 编写一个函数 swap(n1 int, n2 int) 可以交换 n1 和 n2 的值。

a 代码

package main

import (
   "fmt"
)

// 编写一个函数 swap(n1 *int, n2 *int) 可以交换 n1 和 n2的值
func swap(n1 *int, n2 *int) {
   //定义一个临时变量
   t := *n1
   *n1 = *n2
   *n2 = t
}

func main() {
   a := 10
   b := 20
   swap(&a, &b) //传入的地址
   fmt.Printf("a=%v, b=%v", a, b)
}

b 测试