go语言基础

变参

package main
import (
    "fmt"
)
func myfunc(arg ...int) {
    for _, n := range arg {
        fmt.Print(n)
    }
}
func main() {
    myfunc(1, 2, 3, 4, 5)
}

if 作用域

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。
该语句声明的变量作用域仅在 if 之内。下面return v 是未定义的。

在 if 的条件语句中声明的变量同样可以在任何对应的 else 块中使用。

func pow(x, n, lim float64) float64 {
        if v := math.Pow(x, n); v < lim {
                return v
        }
        return v
}

switch 语句

Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。
自带break；

##case+++   自带break switch条件表达
    switch os := runtime.GOOS; os {
    case "darwin":
        fmt.Println("OS X.")
    case "linux":
        fmt.Println("Linux.")
    default:
        // freebsd, openbsd,
        // plan9, windows...
        fmt.Printf("%s.\n", os)
    }

##case+++     case 非常量
    today := time.Now().Weekday()
    switch time.Saturday {
    case today + 0:
        fmt.Println("Today.")
    case today + 1:
        fmt.Println("Tomorrow.")
    case today + 2:
        fmt.Println("In two days.")
    default:
        fmt.Println("Too far away.")
    }

##case+++  f()不会被调用
    switch i {
      case 0:
      case f():
    }

defer 关键字

1.defer 语句会将函数推迟到外层函数返回之后执行。
2.推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。
3.推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

go结构体传参

#go 是用{} 大括号传参的。。

package main
import "fmt"

type Vertex struct {
    X int
    Y int
}

func main() {
    fmt.Println(Vertex{1, 2})
}

go函数

函数

####case1 值传递
  var a int = 100
  var b int = 100
  var ret int 
  ret = max(a, b)
/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
   /* 定义局部变量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}
##### case2 引用传递
ret = swap(&a,$b)
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保持 x 地址上的值 */
   *x = *y      /* 将 y 值赋给 x */
   *y = temp    /* 将 temp 值赋给 y */
}

函数作为值

package main

import (
   "fmt"
   "math"
)

func main(){
   /* 声明函数变量 */
   getSquareRoot := func(x float64) float64 {
      return math.Sqrt(x)
   }

   /* 使用函数 */
   fmt.Println(getSquareRoot(9))

}

闭包

##### case1 初级闭包  只要函数存在，则func()内部保存了i值。
package main
import "fmt"
func getSequence() func() int {
   i:=0
   return func() int {
      i+=1
     return i  
   }
}
func main(){
   /* nextNumber 为一个函数，函数 i 为 0 */
   nextNumber := getSequence()  

   /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   
   /* 创建新的函数 nextNumber1，并查看结果 */
   nextNumber1 := getSequence()  
   fmt.Println(nextNumber1())
   fmt.Println(nextNumber1())
}
###result 
1
2
3
1
2

##### case2  内部保存了参数x1 x2  和 i 
package main

import "fmt"
func main() {
    add_func := add(1,2)
    fmt.Println(add_func())
    fmt.Println(add_func())
    fmt.Println(add_func())
}

// 闭包使用方法
func add(x1, x2 int) func()(int,int)  {
    i := 0
    return func() (int,int){
        i++
        return i,x1+x2
    }
}
###result 
1 3
2 3
3 3

##### case3  第一次传入的x1 x2  i 保存 后来传入的是x3 x4
package main
import "fmt"
func main() {
    add_func := add(1,2)
    fmt.Println(add_func(1,1))
    fmt.Println(add_func(0,0))
    fmt.Println(add_func(2,2))
} 
// 闭包使用方法
func add(x1, x2 int) func(x3 int,x4 int)(int,int,int)  {
    i := 0
    return func(x3 int,x4 int) (int,int,int){ 
       i++
       return i,x1+x2,x3+x4
    }
}
###result 
1 3 2
2 3 0
3 3 4

函数方法

Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。语法格式如下：

func (variable_name variable_data_type) function_name() [return_type]{
   /* 函数体*/
}
##### Circle 结构的方法集
package main
import (
   "fmt"  
)

/* 定义结构体 */
type Circle struct {
  radius float64
}

func main() {
  var c1 Circle
  c1.radius = 10.00
  fmt.Println("圆的面积 = ", c1.getArea())
}

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

go 数组

类型 [n]T 表示拥有 n 个 T 类型的值的数组。

package main
import "fmt"

func main() {
    var a [2]string
    a[0] = "Hello"
    a[1] = "World"
    fmt.Println(a[0], a[1])
    fmt.Println(a)

    primes := [6]int{2, 3, 5, 7, 11, 13}
    fmt.Println(primes)

切片

1. []T 表示一个元素类型为 T 的切片。
2. 切片并不存储任何数据，它只是描述了底层数组中的一段。
3. 更改切片的元素会修改其底层数组中对应的元素。
4. 切片的零值是 nil。nil 切片的长度和容量为 0 且没有底层数组。
5. 切片拥有 长度 和 容量。
   切片的长度就是它所包含的元素个数。
   切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数

6.make 可以创建动态数组。
7.切片可包含任何类型，甚至包括其它的切片

8. 支持append操作

    var s []int = primes[1:4]
    fmt.Println(s)
    a := make([]int, 5)  // len(a)=5

    board := [][]string{
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
    } 

#append操作
func append(s []T, vs ...T) []T

Range使用

for range ：

1. i 是下标。v 是元素值副本。
2. 可以将下标或值赋予 _ 来忽略它。
3. 若你只需要索引，去掉 , value 的部分即可。

package main
import "fmt"

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
    for i, v := range pow {
        fmt.Printf("2**%d = %d\n", i, v)
    }
}

package main
import "fmt"

func main() {
    pow := make([]int, 10)
    for i := range pow {
        pow[i] = 1 << uint(i) // == 2**i
    }
    for _, value := range pow {
        fmt.Printf("%d\n", value)
    }
}

映射

两种写法

type Vertex struct {
    Lat, Long float64
}
######case1
m = make(map[string]Vertex)
m["Bell Labs"] = Vertex{40.68433, -74.39967,}
######case2
var m = map[string]Vertex{
    "Bell Labs": {40.68433, -74.39967},
    "Google":    {37.42202, -122.08408},
}

看到这里了mark
https://tour.go-zh.org/moretypes/22