1. 函数的定义和使用
package main
import "fmt"
func main() { //程序的入口，是一个特殊的函数
/*
函数：function
一、概念：
具有特定功能的代码，可以被多次调用执行。
二、意义：
1.可以避免重复的代码
2.增强程序的扩展性
三、使用
step1：函数的定义，也叫声明
step2：函数的调用，就是执行函数中代码的过程
四、语法
1.定义函数的语法
func funcName(parametername type1, parametername type2) (output1 type1, output2 type2) {
//这里是处理逻辑代码
//返回多个值
return value1, value2
}
A:func，定义函数的关键字
B:funcName，函数的名字
C:()，函数的标志
D:参数列表：形式参数用于接收外部传入函数中的数据
E:返回值列表：函数执行后返回给调用处的结果
2、调用函数的语法
函数名(实际参数)
函数的调用处，就是函数调用的位置
3、注意事项
A：函数必须先定义，再调用，如果不定义：undefined: getSum
定义了函数，没有调用，那么函数就失去了意义
B：函数名不能冲突
C：main()，是一个特殊的函数，作为程序的入口，由系统自动调用
而其他函数，程序中通过函数名来调用。
*/
//求1-10的和
getSum() //函数的调用处
fmt.Println("hello world....")
//求1-10的和
getSum()
fmt.Println("aaa...")
//求1-10的和
getSum()
}
//定义一个函数：用于求1-10的和
func getSum() {
sum := 0
for i := 1; i <= 100; i++ {
sum += i
}
fmt.Printf("1-100的和是：%d\n", sum)
}
2. 函数的参数
package main
import "fmt"
func main() {
/*
函数的参数：
形式参数：也叫形参。函数定义的时候，用于接收外部传入的数据的变量。
函数中，某些变量的数值无法确定，需要由外部传入数据。
实际参数：也叫实参。函数调用的时候，给形参赋值的实际的数据
函数调用：
1.函数名：声明的函数名和调用的函数名要统一
2.实参必须严格匹配形参：顺序，个数，类型，一一对应的。
*/
//1.求1-10的和
getSum(10)
//2.求1-20的和
getSum(20)
fmt.Println()
//3.1-100的和
getSum(100)
//4.求2个整数的和
getAdd(20,10)
getAdd2(1,2)
fun1(1.3,2.4,"hello")
}
//定义一个函数：用于求1-10的和
func getSum(n int) {
sum := 0
for i := 1; i <= n; i++ {
sum += i
}
fmt.Printf("1-%d的和是：%d\n",n, sum)
}
func getAdd(a int,b int){
sum := a + b
fmt.Printf("%d + %d = %d \n",a,b,sum)
}
func getAdd2(a, b int){//参数的类型一致，可以简写在一起
fmt.Printf("a:%d,b:%d\n",a,b)
}
func fun1(a,b float64,c string){
fmt.Printf("a:%.2f,b:%.2f,c:%s\n",a,b,c)
}
3. 可变参数
package main
import "fmt"
func main() {
/*
可变参数：
概念：一个函数的参数的类型确定，但是个数不确定，就可以使用可变参数。
语法：
参数名 ... 参数的类型
对于函数，可变参数相当于一个切片。
调用函数的时候，可以传入0-多个参数。
Println(),Printf(),Print()
append()
注意事项：
A：如果一个函数的参数是可变参数，同时还有其他的参数，可变参数要放在
参数列表的最后。
B：一个函数的参数列表中最多只能有一个可变参数。
*/
//1.求和
getSum()
getSum(1,2,3,4,5)
getSum(1,2,3,4,5,6,7,8,9,10)
//2.切片
s1 :=[]int{1,2,3,4,5}
getSum(s1...)
}
func getSum(nums ... int){
//fmt.Printf("%T\n",nums) //[]int
sum := 0
for i := 0;i <len(nums);i++{
sum += nums[i]
}
fmt.Println("总和是：",sum)
}
func fun1(s1,s2 string,nums ... float64){
}
4. 值传递和应用传递
package main
import "fmt"
func main() {
/*
数据类型：
一：按照数据类型来分：
基本数据类型：
int，float,string，bool
复合数据类型：
array，slice，map，struct，interface。。。。
二：按照数据的存储特点来分：
值类型的数据：操作的是数值本身。
int，float64,bool，string，array
引用类型的数据：操作的是数据的地址
slice，map，chan
参数传递：
A：值传递：传递的是数据的副本。修改数据，对于原始的数据没有影响的。
值类型的数据，默认都是值传递：基础类型，array，struct
B：引用传递：传递的是数据的地址。导致多个变量指向同一块内存。
引用类型的数据，默认都是引用传递：slice，map，chan
*/
arr1 := [4]int{1,2,3,4}
fmt.Println("函数调用前，数组的数据：",arr1) //[1 2 3 4]
fun1(arr1)
fmt.Println("函数调用后，数组的数据：",arr1) //[1 2 3 4]
s1 :=[] int{1,2,3,4}
fmt.Println("函数调用前，切片的数据：",s1) // [1 2 3 4]
fun2(s1)
fmt.Println("函数调用后，切片刀数据：",s1) //[100 2 3 4]
}
//引用传递
func fun2(s2 []int){
fmt.Println("函数中，切片的数据：",s2) //[1 2 3 4]
s2[0] = 100
fmt.Println("函数中，切片的数据更改后：",s2) //[100 2 3 4]
}
//值传递
func fun1(arr2 [4]int){
fmt.Println("函数中，数组的数据：",arr2) //[1 2 3 4]
arr2[0] =100
fmt.Println("函数中，数组的数据修改后：",arr2) //[100 2 3 4]
}
5. 函数的返回值
package main
import "fmt"
func main() {
/*
函数的返回值：
一个函数的执行结果，返回给函数的调用处。执行结果就叫做函数的返回值。
return语句：
一个函数的定义上有返回值，那么函数中必须使用return语句，将结果返回给调用处。
函数返回的结果，必须和函数定义的一致：类型，个数，顺序。
1.将函数的结果返回给调用处
2.同时结束了该函数的执行
空白标识符，专门用于舍弃数据：_
*/
//1.设计一个函数，用于求1-10的和，将结果在主函数中打印输出
res := getSum()
fmt.Println("1-10的和：",res) //1-10的和： 55
fmt.Println(getSum2()) //5050
res1,res2 := rectangle(5,3)
fmt.Println("周长：",res1,"，面积：",res2) //周长： 16 ，面积： 15
res3,res4 := rectangle2(5,3)
fmt.Println("周长：",res3,"，面积：",res4) //周长： 16 ，面积： 15
_,res5 := rectangle(5,3)
fmt.Println(res5) //15
}
//函数，用于求矩形的周长和面积
func rectangle(len,wid float64)(float64,float64){
perimeter := (len +wid) *2
area := len * wid
return perimeter,area
}
func rectangle2(len,wid float64)(peri float64,area float64){
peri = (len +wid)*2
area = len*wid
return
}
func fun1()(float64,float64,string){
return 2.4,5.6,"hello"
}
//定义一个函数，带返回值
func getSum()int {
sum := 0
for i:=1;i<=10;i++{
sum += i
}
return sum
}
func getSum2()(sum int){//定义函数时，指明要返回的数据是哪一个
for i:=1;i<=100;i++{
sum += i
}
return
}
package main
import "fmt"
func main() {
/*
return语句：词义"返回"
A：一个函数有返回值，那么使用return将返回值返回给调用处
B：同时意味着结束了函数的执行
注意点：
1.一个函数定义了返回值，必须使用return语句将结果返回给调用处。return后的数据必须和函数定义的一致：个数，类型，顺序。
2.可以使用_,来舍弃多余的返回值
3.如果一个函数定义了有返回值，那么函数中有分支，循环，那么要保证，无论执行了哪个分支，都要有return语句被执行到
4.如果一个函数没有定义返回值，那么函数中也可以使用return，专门用于结束函数的执行。。
*/
a, b, c := fun1()
fmt.Println(a, b, c)
_, _, d := fun1()
fmt.Println(d)
fmt.Println(fun2(-30))
fun3()
}
func fun1() (int, float64, string) {
return 0, 0, "hello"
}
func fun2(age int) int {
if age >= 0 {
return age
} else {
fmt.Println("年龄不能为负。。")
return 0
}
}
func fun3(){
for i:=0;i<10;i++{
if i == 5{
//break //?强制结束循环
return
}
fmt.Println(i)
}
fmt.Println("fun3()...over....")
}
