1. package main
    3. import "fmt"
    5. //求两个数的和
    6. func sumFn(x int, y int) int {
    7.     sum := x + y
    8.     return sum
    9. }
    11. //求两个数的差
    12. func subFn(x int, y int) int {
    13.     fmt.Println(x, y) //20 2
    14.     sub := x - y
    15.     return sub
    16. }
    18. //函数参数的简写
    19. func subFn1(x, y int) int {
    20.     sub := x - y
    21.     return sub
    22. }
    24. //函数的可变参数，可变参数是指函数的参数数量不固定。Go 语言中的可变参数通过在参数名后加...来标识
    26. func sumFn1(x ...int) int {
    28.     // fmt.Printf("%v--%T", x, x) //[12 34 45 46]--[]int
    30.     sum := 0
    31.     for _, v := range x {
    32.         sum += v
    33.     }
    34.     return sum
    35. }
    37. func sumFn2(x int, y ...int) int {
    38.     fmt.Println(x, y) //100 [1 2 3 4]
    39.     sum := x
    40.     for _, v := range y {
    41.         sum += v
    42.     }
    43.     return sum
    44. }
    46. func main() {
    47.     // sum1 := sumFn(12, 3)
    48.     // fmt.Println(sum1) //15
    50.     // sum2 := sumFn(15, 5)
    51.     // fmt.Println(sum2) //20
    53.     // a := 20
    54.     // b := 2
    55.     // sub1 := subFn(a, b)
    56.     // fmt.Println(sub1)
    58.     // sub2 := subFn1(22, 4)
    59.     // fmt.Println(sub2) //18
    61.     // sum3 := sumFn1(12, 34, 45, 46) //137
    62.     // fmt.Println(sum3)
    64.     // sum4 := sumFn1(1, 2, 3, 4, 5) //15
    65.     // fmt.Println(sum4)
    67.     sum5 := sumFn2(100, 1, 2, 3, 4)
    68.     fmt.Println(sum5)
    70. }
    1. package main
    3. import "fmt"
    5. //int类型升序排序
    6. func sortIntAsc(slice []int) []int {
    7.     for i := 0; i < len(slice); i++ {
    8.         for j := i + 1; j < len(slice); j++ {
    9.             if slice[i] > slice[j] {
    10.                 temp := slice[i]
    11.                 slice[i] = slice[j]
    12.                 slice[j] = temp
    13.             }
    14.         }
    15.     }
    17.     return slice
    18. }
    20. //int类型降序排序  切片是引用数据类型
    21. func sortIntDesc(slice []int) {
    22.     for i := 0; i < len(slice); i++ {
    23.         for j := i + 1; j < len(slice); j++ {
    24.             if slice[i] < slice[j] {
    25.                 temp := slice[i]
    26.                 slice[i] = slice[j]
    27.                 slice[j] = temp
    28.             }
    29.         }
    30.     }
    32. }
    34. func main() {
    36.     //案例1：把前面讲的选择排序封装成方法，实现整型切片的升序降序排序排列
    38.     // var sliceA = []int{12, 34, 37, 35, 556, 36, 2}
    39.     // arr := sortIntAsc(sliceA)
    40.     // fmt.Println(arr)
    42.     // var sliceB = []int{1, 34, 4, 35, 6, 36, 2}
    43.     // fmt.Println(sortIntAsc(sliceB))
    45.     var sliceC = []int{1, 34, 4, 36, 126, 36, 2}
    46.     sortIntDesc(sliceC)
    47.     fmt.Println(sliceC)
    49. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sort"
    6. )
    8. func mapSort(map1 map[string]string) string {
    10.     var sliceKey []string
    12.     //1、把map对象的key放在一个切片里面
    13.     for k, _ := range map1 {
    14.         sliceKey = append(sliceKey, k)
    15.     }
    16.     //2、对key进行升序排序
    17.     sort.Strings(sliceKey)
    19.     var str string
    20.     for _, v := range sliceKey {
    21.         str += fmt.Sprintf("%v=>%v", v, map1[v])
    22.     }
    23.     return str
    25. }
    27. func main() {
    28.     /*
    29.         案例2：
    30.                 m1 := map[string]string{
    31.                     "username":"zhangsan",
    32.                     "age":"20",
    33.                     "sex":"男",
    34.                     "height":"180",
    35.                 }
    36.                 输出：age=>20height=>180sex=>男username=>zhangsan
    38.                 上面有一个map对象m1,封装一个方法,要求按照key升序排序，最后输出一个key=>valuekey=>value的字符串
    41.     */
    43.     m1 := map[string]string{
    44.         "username": "zhangsan",
    45.         "age":      "20",
    46.         "sex":      "男",
    47.         "height":   "180",
    48.         "salt":     "xxxxxx",
    49.     }
    51.     str := mapSort(m1)
    52.     fmt.Println(str)
    53. }
    1. package main
    3. import "fmt"
    5. var a = "全局变量"
    7. func run() {
    9.     var b = "局部变量"
    10.     fmt.Println("run方法a=", a)
    11.     fmt.Println("run方法b=", b)
    12.     fmt.Println("run")
    13. }
    15. func main() {
    16.     /*
    18.         函数变量作用域：
    20.             全局变量：全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效 （全局作用域）
    22.             局部变量：局部变量是函数内部定义的变量， 函数内定义的变量无法在该函数外使用 （局部作用域）
    23.     */
    25.     fmt.Println("main方法a=", a)
    27.     // fmt.Println("main方法b=", b)  //undefined: b
    28.     run()
    30.     //i就是局部变量 只能在for方法体内使用
    31.     for i := 0; i < 10; i++ {
    32.         fmt.Println(i)
    33.     }
    34.     // fmt.Println(i)    undefined: i
    36.     //在本作用域相当于全局变量
    37.     // var flag = true
    38.     // if flag {
    39.     //     fmt.Println("true")
    40.     // }
    42.     //flag块作用域 局部变量
    43.     if flag := true; flag {
    44.         fmt.Println("true")
    45.     }
    46.     // fmt.Println(flag)   //undefined: flag
    48. }
    1. package main
    3. import "fmt"
    5. type calc func(int, int) int //表示定义一个calc的类型
    7. type myInt int
    9. func add(x, y int) int {
    10.     return x + y
    11. }
    12. func sub(x, y int) int {
    13.     return x - y
    14. }
    16. func test() {
    17.     fmt.Println("test...")
    18. }
    20. func main() {
    22.     // var c calc
    23.     // c = sub
    24.     // fmt.Printf("c的类型：%T\n", c) //c的类型：main.calc
    25.     // fmt.Println(c(10, 5))      //5
    27.     // f := sub
    28.     // fmt.Printf("c的类型：%T\n", f) //c的类型：func(int, int) int
    29.     // fmt.Println(f(15, 5))      //10
    31.     var a int = 10
    32.     var b myInt = 20
    33.     fmt.Printf("a的类型：%T  b的类型：%T\n", a, b) //a的类型：int  b的类型：main.myInt
    34.     fmt.Println(a + int(b))                //30
    35. }
    1. package main
    3. import "fmt"
    5. //函数作为另一个函数参数
    7. func add(x, y int) int {
    8.     return x + y
    9. }
    10. func sub(x, y int) int {
    11.     return x - y
    12. }
    14. //自定义一个方法类型
    15. type calcType func(int, int) int
    17. func calc(x, y int, cb calcType) int {
    18.     return cb(x, y)
    19. }
    21. func main() {
    22.     // sum := calc(10, 5, add)
    23.     // fmt.Println(sum) //15
    25.     // s := calc(10, 5, sub)
    26.     // fmt.Println(s) //5
    28.     j := calc(3, 4, func(x, y int) int {
    29.         return x * y
    30.     })
    31.     fmt.Println(j) //12
    33. }
    1. package main
    3. import "fmt"
    5. //函数作为返回值
    6. func add(x, y int) int {
    7.     return x + y
    8. }
    9. func sub(x, y int) int {
    10.     return x - y
    11. }
    13. //定义一个方法类型
    14. type calcType func(int, int) int
    16. func do(o string) calcType {
    17.     switch o {
    18.     case "+":
    19.         return add
    20.     case "-":
    21.         return sub
    22.     case "*":
    23.         return func(x, y int) int {
    24.             return x * y
    25.         }
    26.     default:
    27.         return nil
    28.     }
    29. }
    31. func main() {
    32.     // var a = do("+")
    33.     // fmt.Println(a(12, 4)) //16
    35.     b := do("*")
    36.     fmt.Println(b(3, 4)) //12
    37. }
    1. package main
    3. import "fmt"
    5. func main() {
    7.     //匿名函数  匿名自执行函数
    8.     func() {
    9.         fmt.Println("test..")
    10.     }()
    12.     //匿名函数
    13.     var fn = func(x, y int) int {
    14.         return x * y
    15.     }
    17.     fmt.Println(fn(2, 3))
    19.     // 匿名自执行函数接收参数
    20.     func(x, y int) {
    21.         fmt.Println(x + y)
    22.     }(10, 20)
    23. }
    1. package main
    3. import "fmt"
    5. //函数的递归调用:传入1个整数，递归打印出1-到这个数之内的所有整数
    6. func fn1(n int) {
    7.     if n > 0 {
    8.         fmt.Println(n)
    9.         n--
    10.         fn1(n)
    11.     }
    12. }
    14. //递归实现1-100的和
    15. func fn2(n int) int {
    16.     if n > 1 {
    17.         return n + fn2(n-1)
    18.     } else {
    19.         return 1
    20.     }
    21. }
    23. //递归实现5的阶乘
    24. func fn3(n int) int {
    25.     if n > 1 {
    26.         return n * fn3(n-1)
    27.     } else {
    28.         return 1
    29.     }
    31. }
    33. //函数的递归调用
    34. func main() {
    36.     //1、for循环实现1到100的和
    37.     var sum = 0
    38.     for i := 1; i <= 100; i++ {
    39.         sum += i
    40.     }
    41.     fmt.Println(sum) //5050
    43.     //2、传入1个整数，递归打印出1-到这个数之内的所有整数
    45.     // fn1(5)
    47.     //3、递归实现1-100的和
    49.     // fmt.Println(fn2(100)) //5050
    51.     //4、递归实现5的阶乘
    53.     fmt.Println(fn3(5)) //120
    55. }
    1. package main
    3. import "fmt"
    5. //golang 闭包
    6. /*
    7.     全局变量特点：
    8.         1、常驻内存
    9.         2、污染全局
    11.     局部变量的特点：
    12.         1、不常驻内存
    13.         2、不污染全局
    15.     闭包：
    16.         1、可以让一个变量常驻内存
    17.         2、可以让一个变量不污染全局
    19. */
    21. /*
    22.     闭包
    24.         1、闭包是指有权访问另一个函数作用域中的变量的函数。
    25.         2、创建闭包的常见的方式就是在一个函数内部创建另一个函数，通过另一个函数访问这个函数的局部变量。
    27.     注意：由于闭包里作用域返回的局部变量资源不会被立刻销毁回收，所以可能会占用更
    28.         多的内存。过度使用闭包会导致性能下降，建议在非常有必要的时候才使用闭包。
    29. */
    31. //写法：闭包的写法 函数里面嵌套一个函数 最后返回里面的函数
    32. func adder1() func() int {
    33.     var i = 10
    34.     return func() int {
    35.         return i + 1
    36.     }
    37. }
    39. func adder2() func(int) int {
    40.     var i = 10 //常驻内存 、不污染全局
    41.     return func(y int) int {
    42.         i += y
    43.         return i
    44.     }
    45. }
    47. func main() {
    48.     var fn = adder1() //表示执行方法
    49.     fmt.Println(fn()) //11
    50.     fmt.Println(fn()) //11
    51.     fmt.Println(fn()) //11
    53.     var fn2 = adder2()   //表示执行方法
    54.     fmt.Println(fn2(10)) //20
    55.     fmt.Println(fn2(10)) //30
    56.     fmt.Println(fn2(10)) //40
    58. }
    1. package main
    3. import "fmt"
    5. /*
    6. Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。
    7. */
    9. func f1() {
    10.     fmt.Println("开始")
    12.     defer func() {
    13.         fmt.Println("aaaa")
    14.         fmt.Println("bbbb")
    15.     }()
    17.     fmt.Println("结束")
    18. }
    20. //    调用方法返回的是0   fmt.Println(f2()) //0
    21. func f2() int {
    22.     var a int //0
    23.     defer func() {
    24.         a++
    25.     }()
    26.     // fmt.Println("结束")
    27.     return a
    28. }
    30. func f3() (a int) {
    31.     defer func() {
    32.         a++
    33.     }()
    34.     return a
    35. }
    37. func main() {
    39.     //1、defer的使用演示
    40.     // fmt.Println("开始")
    41.     // defer fmt.Println(1)
    42.     // defer fmt.Println(2)
    43.     // defer fmt.Println(3)
    44.     // fmt.Println("结束")
    46.     //2、defer在命名返回值和匿名返回 函数中表现不一样
    48.     // f1()
    50.     fmt.Println(f2()) //0
    52.     fmt.Println(f3()) //1
    54. }
    1. package main
    3. import "fmt"
    5. /*
    6. Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。
    7. */
    9. func f1() int {
    10.     x := 5
    11.     defer func() {
    12.         x++
    13.     }()
    14.     return x //5
    15. }
    17. func f2() (x int) {
    18.     defer func() {
    19.         x++
    20.     }()
    21.     return 5 //6
    22. }
    24. func f3() (y int) {
    25.     x := 5
    26.     defer func() {
    27.         x++
    28.     }()
    29.     return x //5
    30. }
    31. func f4() (x int) {
    32.     defer func(x int) {
    33.         //x=0
    34.         // fmt.Println(x)
    35.         x++
    36.     }(x) //defer注册要延迟执行的函数时该函数所有的参数都需要确定其值
    38.     // fmt.Println("a=", x)
    39.     return 5 //5
    40. }
    42. func main() {
    43.     fmt.Println(f1())
    44.     fmt.Println(f2())
    45.     fmt.Println(f3())
    46.     fmt.Println(f4())
    47. }
    1. package main
    3. import "fmt"
    5. /*
    6. Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。
    9. 问，上面代码的输出结果是？
    11. 提示：defer注册要延迟执行的函数时该函数所有的参数都需要确定其值
    13. */
    15. func calc(index string, a, b int) int {
    16.     ret := a + b
    17.     fmt.Println(index, a, b, ret)
    18.     return ret
    19. }
    20. func main() {
    21.     x := 1
    22.     y := 2
    23.     defer calc("AA", x, calc("A", x, y))
    24.     x = 10
    25.     defer calc("BB", x, calc("B", x, y))
    26.     y = 20
    27. }
    29. /*
    30. 注册顺序
    31.     defer calc("AA", x, calc("A", x, y))
    32.     defer calc("BB", x, calc("B", x, y))
    33. 执行顺序
    34.     1、defer calc("BB", x, calc("B", x, y))
    35.     2、defer calc("AA", x, calc("A", x, y))
    37. */
    39. //1、calc("A", x, y)     A 1 2 3
    40. //2、calc("B", x, y)     B 10 2 12
    41. //3、calc("BB", x, calc("B", x, y))    BB 10 12  22
    42. //4、calc("AA", x, calc("A", x, y))    AA 1 3  4
    1. package main
    3. import "fmt"
    5. /*
    6. panic/recover
    8. Go 语言中目前（Go1.12）是没有异常机制，但是使用 panic/recover 模式来处理错误。
    10. panic 可以在任何地方引发，但 recover 只有在 defer 调用的函数中有效
    11. */
    13. func fn1() {
    14.     fmt.Println("fn1")
    15. }
    16. func fn2() {
    17.     defer func() {
    18.         err := recover()
    19.         if err != nil {
    20.             fmt.Println("err:", err)
    21.         }
    22.     }()
    23.     panic("抛出一个异常")
    24. }
    25. func main() {
    26.     fn1()
    27.     fn2()
    28.     fmt.Println("结束")
    29. }
    1. package main
    3. import "fmt"
    5. /*
    6. panic/recover
    8. Go 语言中目前（Go1.12）是没有异常机制，但是使用 panic/recover 模式来处理错误。
    10. panic 可以在任何地方引发，但 recover 只有在 defer 调用的函数中有效
    11. */
    14. func fn1(a int,b int) {
    15.     defer func ()  {
    16.         err := recover()
    17.         if err!=nil {
    18.             fmt.Println("error:",err)  //error: runtime error: integer divide by zero
    19.         }
    20.     }()
    21.     fmt.Println(a/b)
    22. }
    23. func main() {
    24.     fn1(10,0)
    25.     fmt.Println("结束")
    26.     fn1(10,2)
    27. }
    1. /*
    2.     大地老师专栏：https://www.itying.com/category-79-b0.html
    3.     Golang仿小米商城项目实战视频教程地址：https://www.itying.com/goods-1143.html
    4. */
    5. package main
    7. import (
    8.     "errors"
    9.     "fmt"
    10. )
    12. /*
    13. panic/recover
    15. Go 语言中目前（Go1.12）是没有异常机制，但是使用 panic/recover 模式来处理错误。
    17. panic 可以在任何地方引发，但 recover 只有在 defer 调用的函数中有效
    18. */
    20. // 模拟了一个读取文件的方法
    21. func readFile(fileName string) error {
    22.     if fileName == "main.go" {
    23.         return nil
    24.     } else {
    25.         return errors.New("读取文件失败")
    26.     }
    27. }
    29. func myFn() {
    30.     defer func() {
    31.         err := recover()
    32.         if err != nil {
    33.             fmt.Println("给管理员发送邮件")
    34.         }
    35.     }()
    36.     err := readFile("main.go")
    37.     if err != nil {
    38.         panic(err)
    39.     }
    40. }
    42. func main() {
    43.     myFn()
    44.     fmt.Println("继续执行...")
    45. }