GO学习 --- 函数调用与注意事项

最新推荐文章于 2023-12-04 12:27:53 发布

鸭鸭老板

最新推荐文章于 2023-12-04 12:27:53 发布

阅读量375

点赞数

分类专栏： GO语言文章标签： golang

本文链接：https://blog.csdn.net/qq_46093575/article/details/120637395

版权

GO语言专栏收录该内容

128 篇文章 8 订阅

订阅专栏

一、函数

为完成某-功能的程序指令(语句)的集合,称为函数。

传统解决方案

输入两个数，再输入一个运算符(+,-.*,/)，得到结果。

//goto入门练习
package main
import (
	"fmt" 
)
func main(){
	//定义四个变量
	var a1 float32 
	var a2 float32 
	var kay byte
	var a3 float32
	fmt.Println("请输入")
	fmt.Scanln(&a1)
	fmt.Scanln(&a2)
	fmt.Scanf("%c",&kay)
	switch kay {
		case '+':
			a3 = a1 + a2
		case '-':
			a3 = a1 - a2
		case '*':
			a3 = a1 * a2
		case '/':
			a3 = a1 / a2
		default:
			fmt.Println("请正确输入")	
	}
	fmt.Println("a3=",a3)
}

二、基本语法

func函数名(形参列表) (返回值类型列表) {

执行语句...

return返回值列表

}

三、函数入门练习

//函数入门练习
package main
import (
	"fmt" 
)
//定义一个函数
func cal(a1 float64, a2 float64, kay byte) float64 {
	var a3 float64
	switch kay {
	case '+':
		a3 = a1 + a2
	case '-':
		a3 = a1 - a2
	case '*':
		a3 = a1 * a2
	case '/':
		a3 = a1 / a2
	default:
		fmt.Println("请正确输入")	
	}
	return a3
} 
func main(){
	var a1 float64 
	var a2 float64
	var kay byte
	fmt.Println("请输入")
	fmt.Scanln(&a1)
	fmt.Scanln(&a2)
	fmt.Scanf("%c",&kay)
	result := cal(a1,a2,kay)
	fmt.Println("result=",result)
}

四、内存分布图

//函数练习
package main


import (
	"fmt" 
)
//定义一个函数
func test1(n1 int) {
	n1 += 1
	fmt.Println("test1的n1:",n1)
}
//定义一个函数
func test2(n2 int)int {
	n2 += 1
	fmt.Println("test1的n2:",n2)
	return n2 //谁调用就把结果返回给谁
}

func main(){
	n1 := 1
    test1(n1)
	fmt.Println("main的test的n1:",n1)
    	
	n2 :=test2(10)
	fmt.Println("main的test的n2:",n2)
}

五、函数返回值

1、如果返回多个值时，在接收时，希望忽略某个返回值，则使用_符号表示占位忽略

2、如果返回值只有一个，(返回值类型列表)可以不写()

//函数练习
package main

import (
	"fmt" 
)
//定义一个函数返回多个值
func test1(n1 int,n2 int) (int, int) {
	a1 := n1 + n2
	a2 := n1 - n2
	return a1,a2
}

func main(){
	a3, a4 := test1(2,1)
	fmt.Println(a3,a4) 
	//可以使用占位符
	_,a5 := test1(2,1)
	fmt.Println(a5) 
}

六、函数注意事项

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

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

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

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

//函数注意事项
package main

import (
	"fmt" 
)
//定义一个函数
func test()  {
	var n1 int = 1
}

func main(){
	//fmt.Println(n1) //因为n1是局部变量
}

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

//函数注意事项
package main

import (
	"fmt" 
)
//定义一个函数
func test(n1 int)  {
	n1++
	fmt.Println("test():",n1)
}

func main(){
	var n1 int = 1
	test(n1)
	fmt.Println("main的n1",n1)
	
}

6、如果希望函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量。从效果上看类似引用

//函数注意事项
package main

import (
	"fmt" 
)
//定义一个函数,使用指针类型作为变量
func test(n1 *int)  {
	*n1++
	fmt.Println("test():",*n1)
}

func main(){
	var n1 int = 1
	test(&n1)
	fmt.Println("main的n1",n1)
	
}

7、Go函数不支持重载。

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

import (
	"fmt" 
)
//定义一个函数
func test(n1 int, n2 int) int {
	n3 := n1 + n2
	return n3
}

func main() {
	n4 := test 
	fmt.Printf("n4的类型为%T，test的类型为%T\n",n4,test) 
	num := n4(10,20)
	fmt.Println(num)
}

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

//函数注意事项
package main

import (
	"fmt" 
)
//定义一个函数
func test(n1 int, n2 int) int {
	n3 := n1 + n2
	return n3
}
//定义一个函数将第一个函数类型当作形参
func test1(file func(int, int) int, num1 int, num2 int ) int {
	return file(num1,num2)
}

func main() {

	result := test1(test,20,30)
	fmt.Println(result)
}

10、为了简化数据类型定义，Go支持自定义数据类型，基本语法: type 自定义数据类型名数据类型/理解:相当于一个别名

//函数注意事项
package main

import (
	"fmt" 
)
//定义一个函数
func test(n1 int, n2 int) int {
	n3 := n1 + n2
	return n3
}
//定义一个函数
 //自定义函数变量
 type myFun func(int, int) int

func test1(file myFun, num1 int, num2 int ) int {
	return file(num1,num2)
}

func main() {
   //自定义变量
   type myInt int 
   var a1 int
   var a2 myInt //a1与a2的类型是不一样的
   fmt.Printf("a1的类型%T,a2的类型%T\n",a1,a2)

   a3 := test1(test,20,20)
   fmt.Println("a3=",a3)	
}

11、支持对函数返回值命名

//函数注意事项
package main

import (
	"fmt" 
)
//定义一个函数
func test(n1 int, n2 int) (a1 int,a2 int){
   a1 = n1 * n2
   a2 = n1 / n2
   return
}

func main() {
   b1,b2 := test(2,2)
   fmt.Println(b1,b2) 
}

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

//函数注意事项
package main

import (
	"fmt" 
)
//定义一个函数
func test(n1 int, n2 int) (a1 int,a2 int){
   a1 = n1 * n2
   a2 = n1 / n2
   return
}

func main() {
   //可以用_忽视结果  
   b1,_ := test(2,2)
   fmt.Println(b1) 
}

13、GO支持可变参数

//函数注意事项
package main

import (
	"fmt" 
)
//定义一个函数
func test(n1 int, args... int) int{
   sum := n1
   for i := 0; i < len(args); i++ {
      sum += args[i]  
   }
   return sum
}

func main() {
   a1 := test(1)
   fmt.Println("a1=",a1)
   a2 := test(1,2,3,4,5,6)
   fmt.Println("a2=",a2)
}

七、练习一

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

//函数注意事项
package main

import (
	"fmt" 
)
//定义一个函数
func swap(n1 *int, n2 *int ) {
   //定义一个中间变量
   var n3 int
    n3 = *n1
   *n1 = *n2
   *n2 = n3
}

func main() {
   a1 := 10
   a2 := 20
   swap(&a1,&a2)
   fmt.Printf("a1=%v,a2=%v",a1,a2)
}

练习二

编写一个函数，从终端输入-一个整数打印出对应的金子塔

//函数练习
package main

import (
	"fmt"
)
//定义一个变量用于封装
func test(levl int) {
	//打印金字塔
	for i := 1; i <= levl; i++ {
		//打印空格
		for k := 1; k <= levl - i; k++ {
			fmt.Print(" ")
		}
		for j := 1; j <= 2 * i - 1; j++ {
			 	fmt.Print("*")
		}  
		fmt.Println()
	}
}

func main() {
	var a1 int 
	fmt.Println("请输入要打印的层数")
	fmt.Scanln(&a1)
	//调用这个函数
	test(a1)
}

练习三

编写一个函数，从终端输入一个整数(1一9)，打印出对应的乘法表

//函数练习
package main

import (
	"fmt"
)
//定义一个变量用于封装
func test(levl int) {
	//打印九九乘法表
	//定义一个变量
	var a1 int = 9
	for i := 1; i <= a1; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%v * %v = %v \t",j,i,j*i)
		} 
		fmt.Println()
	} 
}

func main() {
	var a1 int
	fmt.Println("请输入一个数")
	fmt.Scanln(&a1)
	test(a1)
}