标签：name 入参 rom 区分 导包 对比 变长参数 应该 from
函数的声明
在 Go 语言中，函数声明通用语法如下：
func functionname(parametername type) returntype {
// 函数体（具体实现的功能）
}
函数的声明以关键词 func 开始，后面紧跟自定义的函数名 functionname (函数名)。
函数的参数列表定义在 ( 和 ) 之间，返回值的类型则定义在之后的 returntype (返回值类型)处。声明一个参数的语法采用 参数名 参数类型 的方式，任意多个参数采用类似 (parameter1 type, parameter2 type) 即(参数1 参数1的类型,参数2 参数2的类型)的形式指定。之后包含在 { 和 } 之间的代码，就是函数体。
函数中的参数列表和返回值并非是必须的，所以下面这个函数的声明也是有效的
func functionname() {
// 译注: 表示这个函数不需要输入参数，且没有返回值
}
/*
函数
*/
package main
import "fmt"
func main() {
//1 函数调用
//test()
//2 函数调用
//a:=10
//test(a)
//test(10)
//3 函数调用
//test(10,11)
//test(b=10,a=11) //没有关键字参数
//4 函数调用
//var a int
//a=test(10,11)
//a:=test(100,11)
//fmt.Println(a)
//5 函数调用(有几个返回值，必须用几个值来接收)
//a,b:=test(10,11)
//第二个参数不接收了（跟python中_不一样，python中_就是一个变量）
//a,_:=test(10,11)
////fmt.Println(a,b)
//fmt.Println(a)
////fmt.Println(_)
//6 可变长参数
//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)
//7 匿名函数（定义在函数内部，没有名字）
//放在函数内部，有两种处理方案
//1 让它执行
//2 当参数返回
//否则报错
//func (){
// fmt.Println("我是匿名函数")
//}()
//8 函数是一等公民
//test()() 没问题
//var a func()
//a=test()
//a()
//a:=test()
//a()
// 9 闭包函数调用
//a:=test(10)
//fmt.Println(a)
//a()
//10 闭包函数高级
//test(99)(88,77)
//a:=test(99)
//a(88,77)
}
//func关键字 函数名(参数1 类型，参数2 类型){函数体的内容}
//1 定义一个无参数，无返回值的普通函数
//func test() {
// fmt.Println("我是test")
//}
//2 带参数，无返回值
// go中全是位置参数， 没有所谓的关键字参数，默认参数
//func test(b int) {
// fmt.Println(b)
//
//}
//3 带多个参数，无返回值(没有默认参数和关键字参数)
//func test(a int,b int) {
//如果两个参数都是同一个类型，就可以简略写
//func test(a ,b int,c string) {
// fmt.Println(a+b)
//}
//4 带多个参数，有一个返回值(指明返回参数类型是什么)
//返回值类型是int类型
//func test(a, b int) int {
// c := a + b
// return c
//}
//5 带多个参数，多返回值（返回值类型，返回值类型。。。）
//func test(a,b int)(int,int) {
// c:=a+b
// d:=a*b
// return c,d
//}
//补充
//func test(a,b int)(){}
//func test(a,b int)(int){}
//func test(a,b int)(int,string,int){}
//func test(a,b int)int{}
//6 可变长参数
//可以传任意长度的int类型
//func test(a ...int) {
// //a是切片
// fmt.Println(a[1])
//}
//7 匿名函数（定义在函数内部，没有名字）
//8 函数是一等公民（头等函数）,函数也是一个类型
//在一门语言中，如果函数可以赋值个变量，那函数就叫一等公民，或者叫头等函数
//返回值是函数类型
//func test() func() {
// var a func()=func (){
// fmt.Println("我是内层函数")
// }
// return a
//}
//func test() func() {
// return func (){
// fmt.Println("我是内层函数")
// }
//}
//9 闭包函数（1 定义再函数内部 2 对外部作用域有引用）
// 闭包函数：多了一种函数传参的方式
//func test(b int) func() {
// a:= func() {
// fmt.Println(b)
// }
// return a
//}
//go语言中没有装饰器语法糖，但是可以自己实现装饰器
//@ttt
//func test() {
//}
//10 闭包函数高级
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
}
//func test(b func(z int)()) (func(x,y int)(),func()()) {
// var a func(x,y int)
// a= func(x,y int) {
// b(12)
// fmt.Println(x+y)
// }
// return a, func() {
// }
//}
//规范
/*
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")
*/
main 函数和 main 包
所有可执行的 Go 程序都必须包含一个 main 函数。这个函数是程序运行的入口。main 函数应该放置于 main 包中。
package packagename 这行代码指定了某一源文件属于一个包。它应该放在每一个源文件的第一行。
//1 在同一个包下（文件夹下），包名必须一致
//2 以后，包名就是文件夹的名字
//3 同一个包下，同名函数只能有一个（init除外）
//4 一个包（当成一个文件），同一包下的函数，直接调用即可
//5 导包的位置，从src路径开始
//6 包只要在src路径下就可以导入
//7 大写表示导出，在外部包可以使用，小写只能再包内部适应
//8 使用第三方包：go get github.com/astaxie/beego （放到gopath的src路径下）
-python：pip3 install requests
package main
import "github.com/astaxie/beego"
func main() {
beego.Run()
}
//1 包导入 import . "github.com/astaxie/beego" 类似于python中form xx import *
//2 包导入 import _ "github.com/go-sql-driver/mysql" 触发init的执行，但是不试用包内的函数
//3 包导入 import f "fmt" 重命名，以后直接用f
//4 对比python中__init__.py
//在代码中导入模块
import xx 实质上触发__init__.py 的执行(在__init__.py中也可以执行其他代码，对应到go中就是init函数)
一般情况下，在__init__.py写from xx import 会使用到的函数，导过来
以后再用 xx.函数()
//5 go mod没有之前，可以设置多个gopath，开发某个项目，切到不同的gopath，类似于虚拟环境
//6 go env
-GO111MODULE="off" 表示go mod模式是关闭的，用gopath
-一旦开启了go mod模式，代码不需要放在src路径下（任意位置都可以）
-在项目路径下要有 go.mod 文件（文件里记录了，go版本，项目依赖的包，包的版本）
-写代码，建自己的包即可
-一般情况下，项目有一个main.go 内部是main包，main函数，整个程序的入口
标签：name 入参 rom 区分 导包 对比 变长参数 应该 from
原文地址：https://www.cnblogs.com/kai-/p/12747356.html
