go语言底层调用 go语言函数调用

转载

blueice 2023-09-01 08:53:09

文章标签 go语言底层调用 golang 开发语言后端 bc 文章分类 Go语言后端开发

函数

声明函数
自变量为同类型可以合并类型
只有输出没有输入的函数声明
函数变量的使用
总结

Go语言函数支持的特性包括：

◇ 参数数量不固定（可变参数）。
◇ 匿名函数及其闭包。
◇ 函数本身作为值传递。
◇ 函数的延迟执行。
◇ 把函数作为接口调用

声明函数

声明的格式：

func 函数名(参数列表) (返回参数列表){
   函数体
}
可读形式 ：
func 函数名(参数1 类型1, 参数2 类型2, 参数n 类型n) (返回值a 类型a, 返回值b 类型b){
	函数流程
}

具体的使用方法：
举例1 ：

package main

import "fmt"

func func_abc(a int, b int) (c int) {
	c = a + b
	return c
}

func main() {
	fmt.Println("func_abc的返回值: ", func_abc(1, 2))
}

举例2 ：

package main

import (
	"fmt"
	"strconv"
)

func func_abc(a string, b int) (c string, d int) {
	c = a + strconv.Itoa(b)
	numA, _ := strconv.ParseInt(a, 10, 0)
	numB, _ := strconv.ParseInt(strconv.Itoa(b), 10, 0)
	d = int(numA) + int(numB)
	return c, d
}

func main() {
	test_a := "10"
	num, err := strconv.ParseInt(test_a, 10, 0)
	fmt.Println(num, err)
	fmt.Println(test_a + "b")
	outC, outD := func_abc("1", 3)
	fmt.Println("func_abc的返回值c: ", outC,
		"\nfunc_abc的返回值d: ", outD)
}

// 10 <nil>
// 10b
// func_abc的返回值c:  13
// func_abc的返回值d:  4

本例中，自变量参数为不同类型的 a 为string，b为string ；因变量参数也是不同类型的 c 为 string ， d为 int ；其中中间过程用到了字符串和数值之间的相互转化，举例：

整型转字符串：
参考网址： http://c.biancheng.net/view/5112.html

package main

import (
	"fmt"
	"strconv"
)

func main() {

	num := 10
	str := strconv.Itoa(num)
	fmt.Println("整型转字符串: ", str)
	fmt.Printf("str的数据类型为: %T", str)
}

字符串转整型：

package main

import (
	"fmt"
	"strconv"
)

func main() {

	str := "10"
	num, _ := strconv.ParseInt(str, 10, 0)
	fmt.Println("字符串转整型: ", num)
	fmt.Printf("num的数据类型为: %T", num)
}

自变量为同类型可以合并类型

一般情况下不推荐这种写法，因为会降低代码的可读性，无法区分每个返回值的实际意义。

func 函数名(自变量1, 自变量2, 自变量3, 同一类型1) (因变量a, 因变量b, 同一类型c){
	函数流程 
}

举例：

package main

import (
	"fmt"
)

func func_abca(a, b int) (c, d int) {
	c = a + b
	d = a - b
	return c, d
}

func main() {
	c, d := func_abca(8, 3)
	fmt.Println("func_abc的第一个返回值为: ", c)
	fmt.Println("func_abc的第一个返回值为: ", d)

}

// func_abc的第一个返回值为:  11
// func_abc的第一个返回值为:  5

只有输出没有输入的函数声明

package main

import (
	"fmt"
)

func func_abca() (c string, d int) {
	return "c", 2
}

func main() {
	c, d := func_abca()
	fmt.Println("func_abc的第一个返回值为: ", c)
	fmt.Println("func_abc的第一个返回值为: ", d)

}

// func_abc的第一个返回值为:  c
// func_abc的第一个返回值为:  2

函数变量的使用

就是用一个变量来代表某个函数。

使用var 进行声明：

package main

import "fmt"

func myfunc(x int, y int) (sum int, sub int) {
	sum = x + y
	sub = x - y
	return sum, sub
}

func main() {
	x, y := 6, 2
	var f1 func(x int, y int) (sum int, sub int)
	f1 = myfunc
	sum, sub := f1(x, y)
	fmt.Println(sum)
	fmt.Println(sub)
}

// 8
// 4

使用 := 完成声明：

package main

import "fmt"

func myfunc(x int, y int) (sum int, sub int) {
	sum = x + y
	sub = x - y
	return sum, sub
}

func main() {
	x, y := 6, 2
	f1 := myfunc
	sum, sub := f1(x, y)
	fmt.Println(sum)
	fmt.Println(sub)
}

// 8
// 4

用于对比的例子：

package main

import "fmt"

func myfunc(x int, y int) (sum int, sub int) {
	sum = x + y
	sub = x - y
	return sum, sub
}

func main() {
	x, y := 6, 2
	sum, sub := myfunc(x, y)
	fmt.Println(sum)
	fmt.Println(sub)
}

// 8
// 4

函数变量f1声明后其值初始化为nil，在将mufunc函数赋值给f1后，所有对f1的调用即为对
mufunc函数的调用