go-函数-指针-数组

函数：

go语言中定义的变量一定要用到

func eval(a, b int, op string) int{  } 

函数名在前，返回了类型在后。

函数返回一个值：

func eval(a, b int, op string) int {
    switch op{
    case "+":
    return a+b
    case "-":
    return a-b
    case "*":
    return a*b
    case "/":
    q, _ := div(a, b)    (用不到的变量可以先用下划线_ 来代替，这样可以避免出错)
    default:
    panic("unsupported operation : " + op)
  }
}

函数返回多个值：

func div(a, b int) (int, int){
  return a/b, a%b
}
func main() {
  fmt.Println(eval(3, 4, "*"))
  fmt.Println(div(13,3))
}

另一种表达：

func div(a, b int) (q, r int){
  q = a / b        （函数返回时可以起名字。仅用于非常简单的函数）
  r = a % b
return
或者  return a /b , a% b
}
func main() {
  fmt.Println(eval(3, 4, "*"))
  q, r  :=  div(13,3)
}

成功的话返回int，失败的话返回error:

func eval (a, b int , op string) (int , error) { 
  switch op{
    case "+":
    return a+b, nil
    case "-":
    return a-b, nil
    case "*":
    return a*b, nil
    case "/":
    q, _ := div(a, b)   
    return q, nil
    default:
    return 0, fmt.Errorf("unsupported operation :  %s" , op)
  }
 }

go函数式编程：
函数的参数也可以是一个函数，要调用的时候可以随时写一个匿名函数

func apply(op func(int, int)  int , a, b int)  int {
  return op(a, b)
}

可变参数列表：

（..int 表示可以传入可变的参数列表）
func sum(numbers  ...int) int {
  s := 0
  for i := range numbers {
    s += numbers[i]
  }
  return s
}

函数语法要点回顾：
1.返回值类型写在最后面
2.可返回多个值
3.函数作为参数
4.没有默认参数，可选参数

指针

go语言中指针不能运算

var a int = 2
var pa *int = &a
*pa = 3
fmt.Println(a)

go语言只有值传递一种方式

交换两个变量的值：

func swap(a, b int){
  b, a = a, b
}
func swap(a, b *int){
  *b, *a = *a, *b
}
swap(&a, &b)

数组

package main
func main() {
  var arr1 [5] int             (数量写在类型的前面)
  arr2 := [3] int{1,3,5}
  arr3 := [...]int(2,4,6,8,10)      （...表示让系统帮我们数有几个int）
  var grid [4][5]int     (二维数组)
  fmt.Println(arr1,arr2,arr3)
}

便利数组：

for i := 0; i < len(arr3); i++ {
  fmt.Println(arr3[i])
}

for i := range arr3 {                //获得键
  fmt.Println(arr3[i])
}

for i, v := range arr3 {             //同时获得键和值
  fmt.Println(i, v)
}

for _, v := range arr3 {            //获得值，用不到的变量可以用下划线 _ 先来代替
  fmt.Println(v)
}

range 是一个 go 的关键字
可通过 _ 省略变量，不仅range ，任何地方都可以通过 _ 省略变量

数组是值类型（不是引用类型的）
[10]int 和 [20]int 是不同类型
调用 func f(arr [10]int) 会 拷贝 数组
在go语言中一般不直接使用数组