Go | 函数的使用细节和注意事项

简介: Go | 函数的使用细节和注意事项

细节汇总


  1. 函数的形参列表可以是多个,返回值列表也可以是多个
  2. 形参列表和返回值列表的数据类型,可以是值类型、也可以是引用类型
  3. 函数的命名遵循标识符命名规范,首字母不能是数字,首字母大写表示该函数可以被本包文件和其它文件使用,类似public;首字母小写只能被本包文件使用,类似private。
  4. 函数中的变量是局部的,外部不能访问。作用域
  5. 基本数据类型和数组都是值传递的,即进行值拷贝。在函数内修改,不会影响到原来的值,
  6. 如果希望函数内的变量能够修改函数外的变量,可以传入变量的地址(&),函数内以指针的方式操作变量,从效果上看类似引用
  7. Go函数不支持函数重载。
  8. 在Go中,函数也是一种数据类型,可以赋值给一个变量,则该变量是一个函数类型的变量,通过该变量可以对函数调用。
  9. 函数既然是一种数据类型,因此在Go中,函数也可以作为形参,并且调用。(回调函数)
  10. 为了简化数据类型定义,Go支持自定义数据类型
  • 语法: type 自定数据类型名 数据类型  (相当于一个别名)
  • 案例: type myInt int 这时,myInt就等价于int来使用了
  • type mySum  func(int, int) int  这时,mySum就等价于func(int, int) int
  1. 支持对函数返回值命名(可以不受返回值顺序限制)
  2. 使用 _ 下划线标识符,忽略返回值。(占位符)
  3. Go支持可变参数


值传递和指针传递


func test(n1 int) {
  n1 = n1 + 10
  fmt.Println("test n1=", n1)
}
// 指针类型接收处理
func test02(n2 *int) {
  *n2 = *n2 + 10
  fmt.Println("test02 n2=", *n2)
}
func main() {
  n1 := 20
  n2 := 2
  test(n1) // 值类型
  test02(&n2) // 指针类型
  fmt.Println("main n1=", n1)
  fmt.Println("main n2=", n2)
}


什么是重载


重载: 函数名相同,但是形参不同或者数据类型不同的情况。

Golang语言中是不支持传统的函数重载的,fn redeclared in this block

Golang语言是支持可变参数的,空接口的形式

image.png


函数类型的变量


类型: func(int, int) int

func getSum(n1 int, n2 int) int {
  return n1 + n2
}
func getSums(n1 int, n2 int, n3 int) int {
  return n1 + n2 + n3
}
// main 函数
sumFn := getSum
res := sumFn(10, 20)
fmt.Printf("%T %v\n", res, res) // int 30
fmt.Printf("%T \n", sumFn) // func(int, int) int
sumsFn := getSums
result := sumsFn(10, 20, 30)
fmt.Printf("result : %T %v\n", result, result) // result : int 60
fmt.Printf("sumsFn类型:%T \n", sumFn) // sumsFn类型:func(int, int) int


函数作为形参传入


func getSum(n1 int, n2 int) int {
  return n1 + n2
}
func testFn(fnVar func(int, int) int, num1 int, num2 int) int {
  return fnVar(num1, num2) // 调用传入的函数,并返回值
}
// 函数类型形参
sumFn := getSum
total := testFn(sumFn, 1, 2)
fmt.Println("total=", total) // 3


自定义数据类型


  1. 自定义函数数据类型, 相当于起了一个别名
type mySum func(int, int) int
func testFn(fnVar mySum, num1 int, num2 int) int {
  return fnVar(num1, num2)
}
// func testFn(fnVar func(int, int) int, num1 int, num2 int) int {
//  return fnVar(num1, num2)
// }
  1. 自定义数据类型
// main函数下
type myInt int
var num1 myInt = 2
// var num2 int = num1 // 这样是报错的, myInt和int并不等价
var num2 int = int(num1) // 显式类型转换
fmt.Printf("num1的类型:%T 值:%v \n", num1, num1) // num1的类型:main.myInt 值:2
fmt.Printf("num2的类型:%T 值:%v \n", num2, num2) // num2的类型:int 值:2
  1. 定义的类型: 包名.类型名,如:utils.myInt
// 以下是utils包
package utils
import "fmt"
func TestFn() string {
  fmt.Println("TestFn 函数被调用")
  type myInt int
  var n myInt = 10
  fmt.Printf("n的类型:%T 值:%v", n, n) // n的类型:utils.myInt 值:10
  return "hahaha"
}


返回值命名


func sumSub(n1 int, n2 int) (sum int, sub int) {
    // 这里不需要声明sum, sub变量了,也不用在return时写
  sum = n1 + n2
  sub = n1 - n2
  return
}
// main函数
sum, sub := sumSub(9, 8)
fmt.Println("sum=", sum, "sub=", sub) // sum= 17 sub= 1


可变参数


基本语法

  1. 支持零到多个参数

func sum(args... int) {}

  1. 支持1到多个参数

func sum(n1 int, args... int) {}

args:就是一个承接的变量名,可以自定义,如:func sum(n1 int, **vars**... int) {}


说明:


  • args是slice切片,通过args[index]可以访问到各个值
  • args必须放到形参列表的最后面


参数个数可变

func sumV2(n1 int, args ...int) int {
  sum := n1
  fmt.Printf("args类型是:%T\n", args) // args类型是:[]int
  // 遍历args切片
  for i := 0; i < len(args); i++ {
    sum += args[i]
  }
  return sum
}
// main函数
// 参数可变
total02 := sumV2(1, 2, 3, 4)
fmt.Println("total02=", total02) // total02= 10


总结练习


交换变量a, b的值

package main
import "fmt"
func swap(n1 *int, n2 *int) {
  *n1 = *n1 + *n2
  *n2 = *n1 - *n2 // *n1
  *n1 = *n1 - *n2 // *n2
}
func main() {
  a := 12
  b := 20
  swap(&a, &b)
  fmt.Println("a = ", a, "b = ", b)
}


目录
相关文章
|
16天前
|
JSON 安全 网络协议
go语言使用内置函数和标准库
【10月更文挑战第18天】
13 3
|
6月前
|
存储 算法 Go
go语言中的延迟执行函数
【5月更文挑战第13天】`defer`是Go语言中用于延迟执行函数的关键字,尤其适用于资源管理,如文件关闭和锁的释放。它在函数返回前按照LIFO顺序执行,确保资源在任何返回路径下都能正确释放。`defer`可以拦截`panic`并在函数返回前执行,但无法阻止某些致命的`panic`。此外,`defer`可用于修改返回值、输出调试信息和还原变量值。尽管在某些场景下可能影响性能,但Go的优化使得其在多数情况下性能表现良好,特别是在资源清理方面。在Go 1.20及以后的版本,`defer`的性能已显著提升,尤其是在高计算量的场景下。
273 2
|
2月前
|
Go
go函数
go函数
33 10
|
2月前
|
编译器 Go C++
Go to Learn Go之函数
Go to Learn Go之函数
25 0
|
2月前
|
编译器 Go 索引
Go数组、多维数组和切片(动态数组),及常用函数len(),cap(),copy(),append()在切片中的使用
本文介绍了Go语言中数组、多维数组和切片(动态数组)的基本概念和操作,包括数组的定义、初始化、访问,多维数组的定义和访问,以及切片的创建、使用和扩容。同时,还讲解了切片中常用的函数len()、cap()、copy()和append()的使用方法。
|
3月前
|
Prometheus Cloud Native Go
Go 1.22 标准库 slices 新增函数和一些旧函数增加新特性
Go 1.22 标准库 slices 新增函数和一些旧函数增加新特性
|
3月前
|
安全 编译器 Go
Go 1.21: 泛型函数的全面回顾
Go 1.21: 泛型函数的全面回顾
|
3月前
|
Go
深入理解 Go 中的 new() 和 make() 函数
深入理解 Go 中的 new() 和 make() 函数
|
3月前
|
设计模式 Java 数据库连接
|
3月前
|
Go 开发者