标签：可变   引用   作用   contain   位置   main   print   pac   containe   

命名规范

1 变量：go语言中变量区分大小写，建议用驼峰
		var Name="lqz"
		var name="lqz"
		fmt.Println(Name)
		fmt.Println(name)
2 文件名：建议用下划线
3 大写字母开头，表示导出字段（外部包可以使用）
4 先导入第三方包，内置包，自己写的包
5 不像python中缩进代表同一段代码块
    var a =10
    fmt.Println(a)
    fmt.Println("xxx")

函数

1、函数调用

package main

import "fmt"

func main() {
	//1 函数调用
	test()
}

//func关键字 函数名(参数1 类型，参数2 类型){函数体的内容}
//1 定义一个无参数，无返回值的普通函数
func test()  {
	fmt.Println("我是test")
}
// 我是test

2、函数调用

package main

import "fmt"

func main() {
	a:=10
	test(a)
	test(10)
}

//2 带参数，无返回值
// go中全是位置参数， 没有所谓的关键字参数，默认参数
func test(b int)  {
	fmt.Println(b)
}

// 10
// 10

3、带多个参数，有一个返回值(指明返回参数类型是什么)

package main

import "fmt"

func main() {
	var a int
	a=test(10,11)
	//a:=test(100,11)
	fmt.Println(a)
}

//4 带多个参数，有一个返回值(指明返回参数类型是什么)
//返回值类型是int类型
func test(a, b int) int {
	c := a + b
	return c
}

//21

4、带多个参数，多返回值（返回值类型，返回值类型）_接收

package main

import "fmt"

func main() {
	//5 函数调用(有几个返回值，必须用几个值来接收)
	a,b:=test(10,11)
	//第二个参数不接收了（跟python中_不一样，python中_就是一个变量）
	//a,_:=test(10,11)
	fmt.Println(a,b)
	fmt.Println(a)
	//fmt.Println(_)


}

func test(a,b int)(int,int) {
	c:=a+b
	d:=a*b
	return c,d
}

//21 110
//21

5、可变长参数

package main

import "fmt"

func main() {
	fmt.Println(1,"ddd",3.14,4,4,5,6,7,8)
	test(1,2,3,4,4,56,7,7,8,9,9,0)


}

//6 可变长参数
//可以传任意长度的int类型
func test(a ...int) {
	//a是切片
	fmt.Println(a[1])
}

//1 ddd 3.14 4 4 5 6 7 8
//2

6、匿名函数

package main

import "fmt"

func main() {
	//放在函数内部，有两种处理方案
	//1 让它执行
	//2 当参数返回
	//否则报错
	func (){
		fmt.Println("我是匿名函数")
	}()
}

//我是匿名函数

7、函数是一等公民（头等函数）,函数也是一个类型

//在一门语言中，如果函数可以赋值个变量，那函数就叫一等公民，或者叫头等函数
//返回值是函数类型


package main

import "fmt"

func main() {
	//8 函数是一等公民

	//方式一
	test()()  //没问题

	//方式二
	//var a func()
	//a=test()
	//a()

	//方式三
	//a:=test()
	//a()
}

//方式一
//func test() func() {
//	var a func()=func (){
//		fmt.Println("我是内层函数")
//	}
//	return a
//}

//方式二
func test() func() {
	return func (){
		fmt.Println("我是内层函数")
	}
}

//我是内层函数

8、闭包函数

闭包函数（1 定义再函数内部 2 对外部作用域有引用）
// 闭包函数：多了一种函数传参的方式

package main

import "fmt"

func main() {
	a:=test(10)
	fmt.Println(a)
	a()
}

func test(b int) func() {
	a:= func() {
		fmt.Println(b)
	}
	return a
}

9、闭包函数高级

package main

import "fmt"

func main() {
	//方式一传参调用
	test(99)(88,77)
	
	//方式二传参调用
	a:=test(99)
	a(88,77)
}

func test(b int) func(x,y int) {
	var a func(x,y int)
	a= func(x,y int) {
		fmt.Println(b+x+y)
	}
	return a
}

go 函数

标签：可变   引用   作用   contain   位置   main   print   pac   containe   

原文地址：https://www.cnblogs.com/guyouyin123/p/12747363.html