• 【手把手教你写Go】05.函数

    5.函数

    5.1 定义格式

    函数构成代码执行的逻辑结构。

    在Go语言中，函数的基本组成为：关键字func、函数名、参数列表、返回值、函数体和返回语句。

    Go 语言函数定义格式如下：

    func FuncName(/*参数列表*/) (o1 type1, o2 type2/*返回类型*/) {
    //函数体
 
    return v1, v2 //返回多个值
}

    • 1
    • 2
    • 3
    • 4
    • 5

    函数定义说明：

    • func：函数由关键字 func 开始声明
    • FuncName：函数名称，根据约定，函数名首字母小写即为private，大写即为public
    • 参数列表：函数可以有0个或多个参数，参数格式为：变量名 类型，如果有多个参数通过逗号分隔，不支持默认参数
    • 返回类型：
      1. 上面返回值声明了两个变量名o1和o2(命名返回参数)，这个不是必须，可以只有类型没有变量名
      2. 如果只有一个返回值且不声明返回值变量，那么你可以省略，包括返回值的括号
      3. 如果没有返回值，那么就直接省略最后的返回信息
      4. 如果有返回值， 那么必须在函数的内部添加return语句

    5.2 自定义函数

    5.2.1 无参无返回值

    func Test() { //无参无返回值函数定义
    fmt.Println("this is a test func")
}
 
func main() {
    Test() //无参无返回值函数调用
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    5.2.2 有参无返回值

    5.2.2.1 普通参数列表

    func Test01(v1 int, v2 int) { //方式1
    fmt.Printf("v1 = %d, v2 = %d\n", v1, v2)
}
 
func Test02(v1, v2 int) { //方式2, v1, v2都是int类型
    fmt.Printf("v1 = %d, v2 = %d\n", v1, v2)
}
 
func main() {
    Test01(10, 20) //函数调用
    Test02(11, 22) //函数调用
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    5.2.2.2 不定参数列表

    1. 不定参数类型
      不定参数是指函数传入的参数个数为不定数量。

    为了做到这点，首先需要将函数定义为接受不定参数类型：

    //形如...type格式的类型只能作为函数的参数类型存在，并且必须是最后一个参数
func Test(args ...int) {
    for _, n := range args { //遍历参数列表
        fmt.Println(n)
    }
}
 
func main() {
    //函数调用，可传0到多个参数
    Test()
    Test(1)
    Test(1, 2, 3, 4)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    1. 不定参数的传递
    func MyFunc01(args ...int) {
    fmt.Println("MyFunc01")
    for _, n := range args { //遍历参数列表
        fmt.Println(n)
    }
}
 
func MyFunc02(args ...int) {
    fmt.Println("MyFunc02")
    for _, n := range args { //遍历参数列表
        fmt.Println(n)
    }
}
 
func Test(args ...int) {
    MyFunc01(args...)     //按原样传递, Test()的参数原封不动传递给MyFunc01
    MyFunc02(args[1:]...) //Test()参数列表中，第1个参数及以后的参数传递给MyFunc02
}
 
func main() {
    Test(1, 2, 3) //函数调用
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    1. 多个类型不一致的参数
    import "fmt"
func MyPrintf(args ...interface{}) {
    for _, arg := range args {
        switch arg.(type) {
            case int:
            fmt.Println(arg, "is an int value.")
            case string:
            fmt.Println(arg, "is a string value.")
            case int64:
            fmt.Println(arg, "is an int64 value.")
            default:
            fmt.Println(arg, "is an unknown type.")
        }
    }
}
func main() {
    var v1 int = 1
    var v2 int64 = 234
    var v3 string = "hello"
    var v4 float32 = 1.234
    MyPrintf(v1, v2, v3, v4)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    5.2.3 无参有返回值

    有返回值的函数，必须有明确的终止语句，否则会引发编译错误。

    5.2.3.1 一个返回值

    func Test01() int { //方式1
    return 250
}
 
//官方建议：最好命名返回值，因为不命名返回值，虽然使得代码更加简洁了，但是会造成生成的文档可读性差
func Test02() (value int) { //方式2, 给返回值命名
    value = 250
    return value
}
 
func Test03() (value int) { //方式3, 给返回值命名
    value = 250
    return
}
 
func main() {
    v1 := Test01() //函数调用
    v2 := Test02() //函数调用
    v3 := Test03() //函数调用
    fmt.Printf("v1 = %d, v2 = %d, v3 = %d\n", v1, v2, v3)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    5.2.3.2 多个返回值

    func Test01() (int, string) { //方式1
    return 250, "sb"
}
 
func Test02() (a int, str string) { //方式2, 给返回值命名
    a = 250
    str = "sb"
    return
}
 
func main() {
    v1, v2 := Test01() //函数调用
    _, v3 := Test02()  //函数调用， 第一个返回值丢弃
    v4, _ := Test02()  //函数调用， 第二个返回值丢弃
    fmt.Printf("v1 = %d, v2 = %s, v3 = %s, v4 = %d\n", v1, v2, v3, v4)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    5.2.4 有参有返回值

    //求2个数的最小值和最大值
func MinAndMax(num1 int, num2 int) (min int, max int) {
    if num1 > num2 { //如果num1 大于 num2
        min = num2
        max = num1
    } else {
        max = num2
        min = num1
    }
 
    return
}
 
func main() {
    min, max := MinAndMax(33, 22)
    fmt.Printf("min = %d, max = %d\n", min, max) //min = 22, max = 33
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    5.3 递归函数

    递归指函数可以直接或间接的调用自身。

    递归函数通常有相同的结构：一个跳出条件和一个递归体。
    所谓跳出条件就是根据传入的参数判断是否需要停止递归，而递归体则是函数自身所做的一些处理。

    函数调用顺序：

    和C一样，是栈的形式。被调用者先执行。

    比如ABC三个函数，调用顺序为C–>B–>A，则A会最先执行。

    同样，递归就是自己调用自己，假设3–>2–>1，则会最先输出1。

    //通过循环实现1+2+3……+100
func Test01() int {
    i := 1
    sum := 0
    for i = 1; i <= 100; i++ {
        sum += i
    }
 
    return sum
}
 
//通过递归实现1+2+3……+100
func Test02(num int) int {
    if num == 1 {
        return 1
    }
 
    return num + Test02(num-1) //函数调用本身
}
 
//通过递归实现1+2+3……+100
func Test03(num int) int {
    if num == 100 {
        return 100
    }
 
    return num + Test03(num+1) //函数调用本身
}
 
func main() {
 
    fmt.Println(Test01())    //5050
    fmt.Println(Test02(100)) //5050
    fmt.Println(Test03(1))   //5050
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    5.4 函数类型

    在Go语言中，函数也是一种数据类型，我们可以通过type来定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型。类似于重写（同名覆盖）。

    回调函数：函数有一个参数是函数类型，这个函数就是回调函数。

    更准确地说是将一个函数的指针作为参数传递给另一个函数。而回调函数的定义则是不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

    type FuncType func(int, int) int //声明一个函数类型, func后面没有函数名
 
//函数中有一个参数类型为函数类型：f FuncType
//回调函数，函数有一个参数是函数类型，这个函数就是回调函数
//计算器，可以进行四则运算
//多态，多种形态，调用同一个接口，不同的表现，可以实现不同表现，加减乘除//现有想法，后面再实现功能
func Calc(a, b int, f FuncType) (result int) {
    result = f(a, b) //通过调用f()实现任务
    return
}
 
func Add(a, b int) int {
    return a + b
}
 
func Minus(a, b int) int {
    return a - b
}
 
func main() {
    //函数调用，第三个参数为函数名字，此函数的参数，返回值必须和FuncType类型一致
    result := Calc(1, 1, Add)
    fmt.Println(result) //2
 
    var f FuncType = Minus
    fmt.Println("result = ", f(10, 2)) //result =  8
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    5.5 匿名函数与闭包

    所谓闭包就是一个函数“捕获”了和它在同一作用域的其它常量和变量。这就意味着当闭包被调用的时候，不管在程序什么地方调用，闭包能够使用这些常量或者变量。它不关心这些捕获了的变量和常量是否已经超出了作用域，所以只有闭包还在使用它，这些变量就还会存在。

    在Go语言里，所有的匿名函数(Go语言规范中称之为函数字面量)都是闭包。匿名函数是指不需要定义函数名的一种函数实现方式，它并不是一个新概念，最早可以回溯到1958年的Lisp语言。

    func main() {
    i := 0
    str := "mike"
 
    //方式1
    f1 := func() { //匿名函数，无参无返回值
        //引用到函数外的变量
        fmt.Printf("方式1：i = %d, str = %s\n", i, str)
    }
 
    f1() //函数调用
 
    //方式1的另一种方式
    type FuncType func() //声明函数类型, 无参无返回值
    var f2 FuncType = f1
    f2() //函数调用
 
    //方式2
    var f3 FuncType = func() {
        fmt.Printf("方式2：i = %d, str = %s\n", i, str)
    }
    f3() //函数调用
 
    //方式3
    func() { //匿名函数，无参无返回值
        fmt.Printf("方式3：i = %d, str = %s\n", i, str)
    }() //别忘了后面的(), ()的作用是，此处直接调用此匿名函数
 
    //方式4, 匿名函数，有参有返回值
    v := func(a, b int) (result int) {
        result = a + b
        return
    }(1, 1) //别忘了后面的(1, 1), (1, 1)的作用是，此处直接调用此匿名函数， 并传参
    fmt.Println("v = ", v)
 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    闭包捕获外部变量特点：

    func main() {
    i := 10
    str := "mike"
    func() {
        i = 100
        str = "go"
        //内部：i = 100, str = go
        fmt.Printf("内部：i = %d, str = %s\n", i, str)
    }() //别忘了后面的(), ()的作用是，此处直接调用此匿名函数
 
    //外部：i = 100, str = go
    fmt.Printf("外部：i = %d, str = %s\n", i, str)
}
 
函数返回值为匿名函数：
// squares返回一个匿名函数，func() int
// 该匿名函数每次被调用时都会返回下一个数的平方。
func squares() func() int {
    var x int
    return func() int {//匿名函数
        x++ //捕获外部变量
        return x * x
    }
}
 
func main() {
    f := squares()
    fmt.Println(f()) // "1"
    fmt.Println(f()) // "4"
    fmt.Println(f()) // "9"
    fmt.Println(f()) // "16"
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    函数squares返回另一个类型为 func() int 的函数。对squares的一次调用会生成一个局部变量x并返回一个匿名函数。每次调用时匿名函数时，该函数都会先使x的值加1，再返回x的平方。第二次调用squares时，会生成第二个x变量，并返回一个新的匿名函数。新匿名函数操作的是第二个x变量。

    通过这个例子，我们看到变量的生命周期不由它的作用域决定：squares返回后，变量x仍然隐式的存在于f中。

    5.6 闭包

    闭包，要理解起来会麻烦一点。首先我们要知道几个概念，当函数调用结束后，所有局部变量会释放，除了返回值。函数A中定义了函数B，则B外面的叫外函数，里面的叫内函数，假如外函数有有个临时变量a，内函数有个临时变量B。 此时，内函数使用了a，且函数A的返回值是函数B的引用，则叫闭包。 比如：

    import "fmt"
 
//函数A
func add_function_generator(i, j int) int {
    //这里是外函数
    
    //函数B，也叫闭包
    a := func(i, j int) (sum int) {
        //这里是内函数
        sum = i + j
        return 
    }(i,j)
    return a
}
 
func main() {
    a := add_function_generator(1,1)
    fmt.Println("a = ", a)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。
    比如：

    package main //必须
 
import "fmt"
 
//函数的返回值是一个匿名函数，返回一个函数类型
//该匿名函数每次被调用时都会返回下一个数的平方。
func squares() func() int {
    //函数被调用时，x才分配空间，才初始化为0
    var x int 
    return func() int {
        x++
        return x * x
    }
}
 
func test(){
    f := squares()
    fmt.Println(f()) //1
    fmt.Println(f()) //4
    fmt.Println(f()) //9
    fmt.Println(f()) //16
    fmt.Println(f()) //25
    //在这里squares()里面的x才释放
}
 
//一般函数，函数结束了就释放局部变量
func test01() int {
    var x int //没有初始化，值为0
    x++
    return x * x //函数调用完毕，x自动释放
}
 
func main() {
 
    //返回值为一个匿名函数，返回一个函数类型，通过f来调用返回的匿名函数，f来调用闭包函数
    //它不关心这些捕获了的变量和常量是否已经超出了作用域,所以只有闭包还在使用它，这些变量就还会存在。
    test()
    f := squares()
    fmt.Println(f()) //1
 
    fmt.Println(test01())//1
    fmt.Println(test01())//1
    fmt.Println(test01())//1
    fmt.Println(test01())//1
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    其实本质来说，就跟宏替换一样，把闭包里面的函数体直接替换到外函数就成了这样：

    func test(){
    var res int //这个变量原来会由系统生成，记录返回值
 
    var x int 
    
    x++
    res =  x * x
    fmt.Println(res) 
 
    x++
    res =  x * x
    fmt.Println(res) 
 
    x++
    res =  x * x
    fmt.Println(res) 
 
    x++
    res =  x * x
    fmt.Println(res) 
    
    //在这里x才释放
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    5.6 延迟调用defer

    5.6.1 defer作用

    关键字 defer ⽤于延迟一个函数或者方法（或者当前所创建的匿名函数）的执行。注意，defer语句只能出现在函数或方法的内部。

    func main() {
    fmt.Println("this is a test")
    defer fmt.Println("this is a defer") //main结束前调用
 
    /*
        运行结果：
        this is a test
        this is a defer
    */
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    defer语句经常被用于处理成对的操作，如打开、关闭、连接、断开连接、加锁、释放锁。通过defer机制，不论函数逻辑多复杂，都能保证在任何执行路径下，资源被释放。释放资源的defer应该直接跟在请求资源的语句后。

    5.6.2 多个defer执行顺序

    如果一个函数中有多个defer语句，它们会以LIFO（后进先出）的顺序执行。哪怕函数或某个延迟调用发生错误，这些调用依旧会被执⾏。

    func test(x int) {
    fmt.Println(100 / x)//x为0时，产生异常
}
 
func main() {
    defer fmt.Println("aaaaaaaa")
    defer fmt.Println("bbbbbbbb")
 
    defer test(0)
 
    defer fmt.Println("cccccccc")
    /*
    运行结果：
    cccccccc
    bbbbbbbb
    aaaaaaaa
    panic: runtime error: integer divide by zero
    */
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    5.6.3 defer和匿名函数结合使用

    func main() {
    a, b := 10, 20
    defer func(x int) { // a以值传递方式传给x
        fmt.Println("defer:", x, b) // b 闭包引用
    }(a)
 
    a += 10
    b += 100
 
    fmt.Printf("a = %d, b = %d\n", a, b)
 
    /*
        运行结果：
        a = 20, b = 120
        defer: 10 120
    */
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    5.6.4 defer 与 return 孰先孰后

    var name string = "go"
func myfunc() string {
    defer func() {
        name = "python"
    }()
    fmt.Printf("myfunc 函数里的name：%s\n", name)
    return name
}
func main() {
    myname := myfunc()
    fmt.Printf("main 函数里的name: %s\n", name)
    fmt.Println("main 函数里的myname: ", myname)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    输出如下
    myfunc 函数里的name：go
    main 函数里的name: python
    main 函数里的myname: go

    defer 是return 后才调用的。所以在执行 defer 前，myname 已经被赋值成 go 了。

    5.7 获取命令行参数

    package main
 
import (
    "fmt"
    "os"    //os.Args所需的包
)
 
func main() {
    args := os.Args //获取用户输入的所有参数
 
    //如果用户没有输入,或参数个数不够,则调用该函数提示用户
    if args == nil || len(args) < 2 {
        fmt.Println("err: xxx ip port")
        return
    }
    ip := args[1]   //获取输入的第一个参数
    port := args[2] //获取输入的第二个参数
    fmt.Printf("ip = %s, port = %s\n", ip, port)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    5.8 作用域

    作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。

    函数内定义的变量称为局部变量。
    函数外定义的变量称为全局变量。
    在不同作用域可以声明同名的变量，其访问原则为：在同一个作用域内，就近原则访问最近的变量，如果此作用域没有此变量声明，则访问全局变量，如果全局变量也没有，则报错。

    5.8.1 局部变量

    在函数体内声明的变量、参数和返回值变量就是局部变量，它们的作用域只在函数体内：

    func test(a, b int) {
    var c int
    a, b, c = 1, 2, 3
    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}
 
func main() {
    //a, b, c = 1, 2, 3 //err, a, b, c不属于此作用域
    {
        var i int
        i = 10
        fmt.Printf("i = %d\n", i)
    }
 
    //i = 20 //err, i不属于此作用域
 
    if a := 3; a == 3 {
        fmt.Println("a = ", a)
    }
    //a = 4 //err，a只能if内部使用
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    5.8.2 全局变量

    在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。

    var a int //全局变量的声明
 
func test() {
    fmt.Printf("test a = %d\n", a)
}
 
func main() {
    a = 10
    fmt.Printf("main a = %d\n", a) //main a = 10
 
    test() //test a = 10
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    5.8.3 不同作用域同名变量

    在不同作用域可以声明同名的变量，其访问原则为：在同一个作用域内，就近原则访问最近的变量，如果此作用域没有此变量声明，则访问全局变量，如果全局变量也没有，则报错。

    var a int //全局变量的声明
 
func test01(a float32) {
    fmt.Printf("a type = %T\n", a) //a type = float32
}
 
func main() {
    fmt.Printf("a type = %T\n", a) //a type = int, 说明使用全局变量的a
 
    var a uint8 //局部变量声明
 
    {
        var a float64                  //局部变量声明
        fmt.Printf("a type = %T\n", a) //a type = float64
    }
 
    fmt.Printf("a type = %T\n", a) //a type = uint8
 
    test01(3.14)
    test02()
}
 
func test02() {
    fmt.Printf("a type = %T\n", a) //a type = int
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
  • 相关阅读:
    Redis解决优惠券秒杀
    DCM09- ReadDataByIdentifier ($22)的功能和配置【基于DaVinci Configurator Classic】
    stm32和电机开发（上位系统）
    2022-2028全球直角变速箱行业调研及趋势分析报告
    [附源码]java毕业设计“云味坊”购物网站
    IF 19.865代谢组学高分文章，非靶标代谢流助力揭示18SrRNA中m6A控制肝癌机制！
    一键切割，激发无限创意：体验全新图片批量编辑器
    非零基础自学Java (老师：韩顺平) 第2章 Java概述 2.1 2.1 什么是程序——2.14 老韩聊 如何快速掌握技术或知识点
    49. Group Anagrams
    Redis（八）集群
  • 原文地址：https://blog.csdn.net/happy_teemo/article/details/119482136