Go函数

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)
}

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)
}

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){

}

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]
}

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....")
}