原则

  • 函数与变量名首字母小写，本包可见，首字母大写，整个项目可见
  • 同包内函数与变量名不能重复

    导入

    再引入自己的包时，是从src的下一层开始，前提是当前项目路径在GOPATN中 ```go

  1. 点操作 有时候会看到如下的方式导入包 import( . “fmt”) 这个点操作的含义就是这个包导入之后在你调用这个包的函数时，你可以省略前缀的包名， 也就是前面你调用的fmt.Println(“hello world”) 可以省略的写成Println(“hello world”)

  2. 别名操作 别名操作顾名思义可以把包命名成另一个用起来容易记忆的名字 import( f “fmt” ) 别名操作调用包函数时前缀变成了重命名的前缀，即f.Println(“hello world”)

  3. 操作 这个操作经常是让很多人费解的一个操作符，请看下面这个import import ( “database/sql” “github.com/ziutek/mymysql/godrv” ) 操作其实只是引入该包。当导入一个包时，它所有的init()函数就会被执行，但有些时候并非真的需 要使用这些包，仅仅是希望它的init()函数被执行而已。这个时候就可以使用操作引用该包了。 即使用_操作引用包是无法通过包名来调用包中的导出函数，而是只是为了简单的调用其init函数()。

    1. <a name="uaJsD"></a>
    2. ## 定义函数
    3. ```go
    4. func  name(参数 类型，...) 返回值类型{
    5. }
    6. 例1：
    7. func sum(i int,n int )int{
    8. fmt.Println(i+n)
    9. return  i+n
    10. }
    11. 例2：定义返回值变量
    12. func sum(i int,n int )(m int){
    13. fmt.Println(i+n)
    14. m = i+n
    15. return//定义了返回值变量，return后就不用接语句了
    16. }

    函数的返回值

  • go支持多个返回值，用逗号隔开即可 ```go func sum_sub(i int,n int )int{ sum := i+n sub := i-n return sum,sub }

func main(){ sum,sub :=sumsub(1,2) //如果只想要其中一个,另一个用‘’占位即可 sum,_ :=sum_sub(1,2) }

  1. <a name="ELcTV"></a>
  2. ## 传参
  4. - **_值类型:_**_基本数据类型int系列, float系列, bool, string 、数组和结构体struct_
  5. - **_引用类型:_**_指针、slice切片、map、管道chan, interface等都是引用类型，传的是地址_
  6. ```go
  7. func fun(i string){
  8.     i+="b"
  9. }
  11. func fun2(i *string){
  12.     *i+="b"
  13. }
  14. func main(){
  15.     i:="a"
  16.     fun(i)//基本类型传递的是值，如果函数中对值发生了变化，这里的i是不会变的
  17.     fmt.Println(i)//a
  19.     n :="a"
  20.     fun2(&n)//这里传递的是n的地址，
  21.     fmt.Println(n) //ab
  22. }

将函数作为参数传递

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  9. type Student struct {
  10.     Name string
  11.     Age int
  12.     IsMan bool
  13.     Score float64
  14. }
  16. // 定义一个接收一个Student类型参数的函数类型
  17. type handle func(str Student) string
  19. // exec函数，接收handle类型的参数
  20. func exec(f handle) string{
  21.     s :=Student{"jw",12,true,100}
  22.     return f(s)
  23. }
  25. func fun(s Student) string{
  26.     data,_ :=json.Marshal(s)
  27.     return string(data)
  28. }
  30. func main() {
  31.     //带名函数
  32.     stu_1 :=exec(fun)
  33.     // 匿名函数作为参数直接传递给exec函数
  34.     stu_2 :=exec(func(s Student) string{
  35.         data,_ :=json.Marshal(s)
  36.         return string(data)
  37.     })
  38.     fmt.Println(stu_1)
  39.     fmt.Println(stu_2)
  40. }

一种高可用的设计模式

  1. package main
  3. import "fmt"
  5. type Options struct {
  6.     StringOption1 string
  7.     StringOption2 string
  8.     IntOption1 int
  9.     IntOption2 int
  10. }
  12. type Option func(opt *Options)
  14. func InitOption(opt ...Option){
  15.     options := &Options{}
  16.     for _,opt :=range opt{
  17.         opt(options)
  18.     }
  19.     fmt.Printf("%v",*options)
  20. }
  21. func WithStringOption1(str string)Option{
  22.     return func(opt *Options) {
  23.         opt.StringOption1=str
  24.     }
  25. }
  26. func WithStringOption2(str string)Option{
  27.     return func(opt *Options) {
  28.         opt.StringOption2=str
  29.     }
  30. }
  31. func WithIntOption1(intvar int)Option{
  32.     return func(opt *Options) {
  33.         opt.IntOption1=intvar
  34.     }
  35. }
  36. func WithIntOption2(intvar int)Option{
  37.     return func(opt *Options) {
  38.         opt.IntOption2=intvar
  39.     }
  40. }
  41. func main() {
  42.     InitOption(
  43.         WithStringOption1("aaa"),
  44.         WithStringOption2("bbb"),
  45.         WithIntOption1(111),
  46.         WithIntOption2(222),
  47.     )
  48. }

不定参

  1. //arr相当于切片
  2. func test_sum(arr ...int) int{
  3.     sum:=0
  4.     for _,v :=range arr{
  5.         sum+=v
  6.     }
  7.     return sum
  8. }
  10. func main() {
  11.     sum:=test_sum(1,2,3)
  12.     fmt.Println(sum)
  13. }

数组陷阱

  1. 语法错误：
  2. 注意：[]int是切片，而不是数组，[3]int才是数组类型
  3. func array(arr []int){
  4.     fmt.Println(arr)
  5. }
  6. func main() {
  7.     arr := [3]int{1,2,3}
  8.     array(arr)
  9. }
  10. array(arr [4]int)，这样定义也是错的，长度不一致，编译器会认为它们数据类型不一样
  11. array(arr [...]int),这样定义也是错的，必须明确指定数组长度

匿名函数

  1. //全局匿名函数
  2. var(
  3.     Fun1 = func (i int,n int) int{
  4.         return i*n
  5.     }
  6. )
  8. func main() {
  9.     方式一：
  10.     sum :=func (i int,n int) int{
  11.         return i+n
  12.     }(1,2)
  13.     fmt.Println(sum)//3
  14.     方式二：
  15.     sub := func (i int,n int) int{
  16.         return i-n
  17.     }
  18.     res:=sub(1,2)
  19.     fmt.Println(res)//-1
  20.     方式三：全局匿名函数
  21.     res1:=Fun1(2,3)
  22.     fmt.Println(res1)//6
  23. }

闭包

  1. //闭包
  2. func run() func(int) int{
  3.     i:=10//外层包的数据只会初始化一次
  4.     str:="hello"
  5.     return func(n int) int {
  6.         i+=n
  7.         newn :=strconv.FormatInt(int64(i),10)
  8.         str+=newn
  9.         fmt.Println(str)
  10.         /*
  11.             hello11
  12.             hello1112
  13.             hello111213
  14.         */
  15.         return i
  16.     }
  17. }
  19. func main() {
  20.     f:=run()
  21.     fmt.Println(f(1)) //11
  22.     fmt.Println(f(1))//12
  23.     fmt.Println(f(1))//13
  24. }

函数体内可修改全局变量

  1. var name = "张三"
  2. //不能使用   name :="张三"  这样去定义
  3. func test1(){
  4.     name = "李四"//修改值，对全局变量有影响
  5.     name := "李四"//重新定义name，对全局没影响，且语法正确
  6.     fmt.Println(name)
  7. }
  9. func main() {
  10.     test1()
  11.     fmt.Println(name)//李四  李四
  12. }
  13. //将test1中的name="李四"改为，name :="李四"
  14. //李四
  15. //张三

函数的执行顺序

  1. import (
  2.     "fmt"
  3.     u"函数/utlis"
  4. )
  5. var age = test()
  6. func test()int{
  7.     fmt.Println("test函数执行了")
  8.     return 1
  9. }
  11. //init函数会在main函数之前执行，通常用于初始化
  12. func init() {
  13.     fmt.Println("init函数执行了")
  14. }
  16. func main(){
  17.     fmt.Println("main函数执行了")
  18.     fmt.Println(age)
  19.     fmt.Println(u.Name)
  20. }
  21. /*
  22. utlis包中的init函数执行了
  23. test函数执行了
  24. init函数执行了
  25. main函数执行了
  26. 1
  27. 张三
  28. */

defer

  1. func sum1(i int,n int) int{
  2.     //defer语句，暂时不执行，而是当所在函数执行完之后再执行，会将defer后的语句压入到栈中
  3.     //当函数执行完后，会以LIFO的方式出栈并开始执行，通常用于收尾工作
  4.     defer fmt.Println("i=",i)
  5.     defer fmt.Println("n=",n)
  7.     i++//注意在defer之后对值发生变化，对已经压入站的defer语句没影响
  8.     n++
  9.     res:=i+n
  10.     fmt.Println("计算完成")
  11.     return res
  12. }
  13. func main() {
  14.     res := sum1(10,20)
  15.     fmt.Println(res)
  16. }
  17. /*
  18. 计算完成
  19. n= 20
  20. i= 10
  21. 32
  22. */

使用陷阱

  1. func f1() (t int){
  2.     defer func() {
  3.         t++
  4.     }()
  5.     return 0
  6. }
  8. func f2() (r int){
  9.     t:=5
  10.     defer func() {
  11.         t++
  12.     }()
  13.     return t
  14. }
  16. func f3() (r int){
  17.     defer func(r int) {
  18.         r++
  19.     }(r)
  20.     return r
  21. }
  23. func main() {
  24.     res1 :=f1()//1
  25.     res2 :=f2()//5
  26.     res3 :=f3()//0
  27. }

解析：f1

  • 带名返回值，t被赋值为零值：0
  • return 0，复制0到返回值栈区，返回值t被赋值为0
  • defer ，由于匿名函数是对t的闭包引用（地址一样），t++后，t=1，因此函数返回值被修改为1

解析：f2

  • 带名返回值，r被赋值为零值：0
  • 定义局部变量t，变并初始化为5
  • return t，复制t的值到返回值栈区，返回值r被赋值为5
  • defer t++，由于匿名函数是对t的闭包引用,t++后，t=6,此时返回值栈区变量为r，且值是5，所以函数返回值为5

解析：f3

  • 带名返回值，r被赋值为零值：0
  • return r = return 0，复制0到返回值栈区，返回值r被赋值为0
  • defer r++ ，此时匿名函数是带参数的，参数为r，此时会复制f3中的r值：0传给匿名函数，经过r++后，匿名函数中的r值修改为1，注意此时f3中与匿名函数中的变量r的地址是不一样的，因此函数返回0

例子1

  1. func f3() (r int){
  2.     defer func(r *int) {
  3.         *r++
  4.     }(&r)//传地址
  5.     return r
  6. }
  7. res3 :=f3()//1，

例子2

  1. func f3() (int){
  2.     var r int
  3.     defer func(r *int) {
  4.         *r++
  5.     }(&r)
  6.     return r
  7. }
  8. res3 :=f3()//0，

例子3

  1. package main
  3. import "fmt"
  5. type A struct {
  6.     A1 int64
  7. }
  8. func main() {
  9.     fmt.Printf("%d\n",test1().A1)  // 100
  10.     fmt.Printf("%d\n",test2().A1)  // 200
  11. }
  14. func test1()(A){
  15.     var a A
  16.     defer func() {
  17.         a.A1 = 200
  18.     }()
  19.     a.A1 = 100
  20.     return a
  21. }
  23. func test2()(*A){
  24.     var a A
  25.     defer func() {
  26.         a.A1 = 200
  27.     }()
  28.     a.A1 = 100
  29.     return &a
  30. }

例子4

  1. package main
  3. import "fmt"
  5. type A struct {
  6.     A1 int64
  7. }
  8. func main() {
  9.     fmt.Printf("%d\n",test1().A1)  // 100
  10.     fmt.Printf("%d\n",test2().A1)  // 200
  11.     fmt.Printf("%d\n",test3().A1)  // 200
  12. }
  15. func test1()(A){
  16.     var a A
  17.     defer func() {
  18.         a.A1 = 200
  19.     }()
  20.     a.A1 = 100
  21.     return a
  22. }
  24. func test2()(*A){
  25.     var a A
  26.     defer func() {
  27.         a.A1 = 200
  28.     }()
  29.     a.A1 = 100
  30.     return &a
  31. }
  33. func test3()(a A){
  34.     defer func() {
  35.         a.A1 = 200   // 这里的a是对返回值栈区的闭包引用（地址一样）
  36.     }()
  37.     a.A1 = 100
  38.     return a
  39. }