zoukankan      html  css  js  c++  java
  • Go语言基础之函数参数

    Go语言基础之函数参数

    一、类型简写

    函数的参数中如果相邻变量的类型相同,则可以省略类型,例如:

    func intSum(x int, y int) int {
        return x + y
    }
    // 函数参数简写
    func intSum(x, y int) int {
        return x + y
    }
    

    上面的代码中,intSum函数有两个参数,这两个参数的类型均为int,因此可以省略x的类型,因为y后面有类型说明,x参数也是该类型。

    二、可变参数

    可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加...来标识。

    注意:可变参数通常要作为函数的最后一个参数。

    举个例子:

    func intSum(x ...int) int {
        fmt.Println(x) //x是一个切片
        sum := 0
        for _, v := range x {
            sum = sum + v
        }
        return sum
    }
    

    调用上面的函数:

    ret1 := intSum()
    ret2 := intSum(10)
    ret3 := intSum(10, 20)
    ret4 := intSum(10, 20, 30)
    fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60
    

    固定参数搭配可变参数使用时,可变参数要放在固定参数的后面,示例代码如下:

    func intSum1(x int, y ...int) int {
        fmt.Println(x, y)
        sum := x
        for _, v := range y {
            sum = sum + v
        }
        return sum
    }
    

    调用上述函数:

    ret5 := intSum1(100)
    ret6 := intSum1(100, 10)
    ret7 := intSum1(100, 10, 20)
    ret8 := intSum1(100, 10, 20, 30)
    fmt.Println(ret5, ret6, ret7, ret8) //100 110 130 160
    

    本质上,函数的可变参数是通过切片来实现的。

    三、可变长参数传入切片

    func main() {
        a := []int{1, 2, 3, 4}
    	// test4(a)  //不可以
        test(a...) //相当于打散了,对数据类型有要求,也就是a必须是int类型切片才能打散了传过去
    
    }
    func test(a ...int) {
    	//a是切片,但是不能直接传切片
    	//如果想直接传切片,可以吗?
    	fmt.Println(a)
        //查看变量a的类型(切片类型)
    	fmt.Printf("%T",a)
    
    }
    
    

    [1 2 3 4]
    []int

    由可变参数函数的定义可知,a...int 意味它可以接受 int 类型的可变参数。

    在上面程序,a作为可变参数传入 test 函数。前面我们知道,这些可变参数参数会被转换为 int 类型切片然后在传入 test 函数中。但是在这里 a 已经是一个 int 类型切片,编译器试图在 a 基础上再创建一个切片,像下面这样

    test(89, []int{nums})
    

    这里之所以会失败是因为 nums 是一个 []int类型 而不是 int类型。

    四、总结

    1. 函数参数定义

      func intSum(x int, y int) int {
          return x + y
      }
      
    2. 类型简写

      func intSum(x, y int) int {
          return x + y
      }
      
    3. 可变参数

      • 固定参数搭配可变参数使用时,可变参数要放在固定参数的后面
      • 可变参数通常要作为函数的最后一个参数
      func intSum(x ...int) int {
          fmt.Println(x) //x是一个切片
          sum := 0
          for _, v := range x {
              sum = sum + v
          }
          return sum
      }
      
    4. 可变长参数传入切片

      func main() {
          a := []int{1, 2, 3, 4}
      	// test4(a)  //不可以
          test(a...) //相当于打散了,对数据类型有要求,也就是a必须是int类型切片才能打散了传过去
      
      }
      func test(a ...int) {
      	//a是切片,但是不能直接传切片
      	fmt.Println(a)
          //查看变量a的类型(切片类型)
      	fmt.Printf("%T",a)
      }
      
      

    在当下的阶段,必将由程序员来主导,甚至比以往更甚。
  • 相关阅读:
    LeetCode对撞指针汇总
    167. Two Sum II
    215. Kth Largest Element in an Array
    2018Action Recognition from Skeleton Data via Analogical Generalization over Qualitative Representations
    题解 Educational Codeforces Round 84 (Rated for Div. 2) (CF1327)
    题解 JZPKIL
    题解 八省联考2018 / 九省联考2018
    题解 六省联考2017
    题解 Codeforces Round #621 (Div. 1 + Div. 2) (CF1307)
    题解Codeforces Round #620 (Div. 2)
  • 原文地址:https://www.cnblogs.com/randysun/p/15414311.html
Copyright © 2011-2022 走看看