函数返回多值

这个在java中是不支持的，得定义一个Tuple去接收，这个功能还是很有用的

  1. package main
  3. import "fmt"
  5. func swap(x, y string) (string, string) {
  6.    return y, x
  7. }
  9. func main() {
  10.    a, b := swap("Google", "Runoob")
  11.    fmt.Println(a, b)
  12. }

函数参数可以是值传递也可以是引用传递

值传递：值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

  1. /* 定义相互交换值的函数 */
  2. func swap(x, y int) int {
  3.    var temp int
  5.    temp = x /* 保存 x 的值 */
  6.    x = y    /* 将 y 值赋给 x */
  7.    y = temp /* 将 temp 值赋给 y*/
  9.    return temp;
  10. }
  11. swap(a, b)

引用传递：引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

  1. /* 定义交换值函数*/
  2. func swap(x *int, y *int) {
  3.    var temp int
  4.    temp = *x    /* 保持 x 地址上的值 */
  5.    *x = *y      /* 将 y 值赋给 x */
  6.    *y = temp    /* 将 temp 值赋给 y */
  7. }
  8. swap(&a, &b) 传入的是a和b的值地址

这两个取决于函数定义时的接受参数的类型是不是引用类型

函数作为另一个函数的实参

  1. package main
  3. import (
  4.    "fmt"
  5.    "math"
  6. )
  8. func main(){
  9.    /* 声明函数变量 */
  10.    getSquareRoot := func(x float64) float64 {
  11.       return math.Sqrt(x)
  12.    }
  14.    /* 使用函数 */
  15.    fmt.Println(getSquareRoot(9))
  17. }

函数作为参数传递，实现回调

  1. package main
  2. import "fmt"
  4. // 声明一个函数类型
  5. type cb func(int) int
  7. func main() {
  8.     testCallBack(1, callBack) // 这个是下面声明的callback函数
  9.     testCallBack(2, func(x int) int { // 类似java中的匿名函数
  10.         fmt.Printf("我是回调，x：%d\n", x)
  11.         return x
  12.     })
  13. }
  15. func testCallBack(x int, f cb) {
  16.     f(x)
  17. }
  19. func callBack(x int) int {
  20.     fmt.Printf("我是回调，x：%d\n", x)
  21.     return x
  22. }

闭包

Go 语言支持匿名函数，可作为闭包。匿名函数是一个”内联”语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。

以下实例中，我们创建了函数 getSequence() ，返回另外一个函数。该函数的目的是在闭包中递增 i 变量，代码如下：

  1. package main
  3. import "fmt"
  5. func getSequence() func() int {
  6.    i:=0
  7.    return func() int {
  8.       i+=1
  9.      return i  
  10.    }
  11. }
  13. func main(){
  14.    /* nextNumber 为一个函数，函数 i 为 0 */
  15.    nextNumber := getSequence()  
  17.    /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
  18.    fmt.Println(nextNumber())
  19.    fmt.Println(nextNumber())
  20.    fmt.Println(nextNumber())
  22.    /* 创建新的函数 nextNumber1，并查看结果 */
  23.    nextNumber1 := getSequence()  
  24.    fmt.Println(nextNumber1())
  25.    fmt.Println(nextNumber1())
  26. }

执行结果

  1. 1
  2. 2
  3. 3
  4. 1
  5. 2

方法

在Go语言中同时有函数和方法，函数是指不属于任何结构体、类型的方法，也就是说，函数是没有接收者的；而方法是有接收者的，我们说的方法要么是属于一个结构体，要么是属于一个新定义的类型。类比java，java是面向对象的语言，其实只有方法，没有函数这一说，要类比的话，go中的函数可能类似于java中的静态方法，而go中的方法则类似于java中的成员方法。
一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。

语法格式如下：

  1. func (variable_name variable_data_type) function_name() [return_type]{
  2.    /* 函数体*/
  3. }

方法的声明和函数类似，他们的区别是：方法在定义的时候，会在func和方法名之间增加一个参数，这个参数就是接收者，这样我们定义的这个方法就和接收者绑定在了一起，称之为这个接收者的方法。

  1. package main
  3. import (
  4.    "fmt"  
  5. )
  7. /* 定义结构体 */
  8. type Circle struct {
  9.   radius float64
  10. }
  12. func main() {
  13.   var c1 Circle
  14.   c1.radius = 10.00
  15.   fmt.Println("圆的面积 = ", c1.getArea())
  16. }
  18. //该 method 属于 Circle 类型对象中的方法
  19. func (c Circle) getArea() float64 {
  20.   //c.radius 即为 Circle 类型对象中的属性
  21.   return 3.14 * c.radius * c.radius
  22. }

Go 没有面向对象，而我们知道常见的 Java。

C++ 等语言中，实现类的方法做法都是编译器隐式的给函数加一个 this 指针，而在 Go 里，这个 this 指针需要明确的申明出来，其实和其它 OO 语言并没有很大的区别。

在 C++ 中是这样的:

  1. class Circle {
  2.   public:
  3.     float getArea() {
  4.        return 3.14 * radius * radius;
  5.     }
  6.   private:
  7.     float radius;
  8. }
  10. // 其中 getArea 经过编译器处理大致变为
  11. float getArea(Circle *const c) {
  12.   ...
  13. }

在Go中则是如下，在这样的实现中，其实就省略掉了this指针:

  1. func (c Circle) getArea() float64 {
  2.   //c.radius 即为 Circle 类型对象中的属性
  3.   return 3.14 * c.radius * c.radius
  4. }