久而旧之

Go 语言基础

2017-11-08

包、变量、函数


  • 每个 Go 程序都是由包组成的。程序运行的入口是包 main
    这个程序使用并导入了包 “fmt” 和 "math/rand"。如:

    1
    2
    3
    4
    5
    6
    package main

    import (
    "fmt"
    "math/rand"
    )
  • 变量
    var 语句定义了一个变量的列表 如:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    var c, python, java bool
    var i, j int = 1, 2

    func main() {
    var i int
    /*在函数中,`:=` 简洁赋值语句在明确类型的地方,可以用于替代 var 定义
    函数外的每个语句都必须以关键字开始(`var`、`func`、等等),`:=` 结构不能使用在函数外*/
    k := 3
    var c, python, java = true, false, "no!"
    ...
    }

  • 函数
    函数可以没有参数或接受多个参数
    在这个例子中,add 接受两个 int 类型的参数。如:

    1
    2
    3
    4
    5
    6
    7
    8
    func add(x int, y int) int {
    return x + y
    }
    ||
    func add(x , y int) int {
    return x + y
    }

流程控制语句

  • for
    Go 只有一种循环结构——for 循环
    基本的 for 循环除了没有了 ( ) 之外(甚至强制不能使用它们)。如:

    1
    2
    3
    4
    5
    6
    7
    8
    func main() {
    sum := 0
    for i := 0; i < 10; i++ {
    sum += i
    }
    fmt.Println(sum)
    }

  • if
    if 语句除了没有了 ( ) 之外(甚至强制不能使用它们)。如:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    func sqrt(x float64) string {
    if x < 0 {
    return sqrt(-x) + "i"
    }
    if v := math.Pow(x, n); v < lim {
    return v
    } else {
    fmt.Printf("%g >= %g\n", v, lim)
    }

    }

  • switch
    如:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    func main() {
    fmt.Print("Go runs on ")
    switch os := runtime.GOOS; os {
    case "darwin":
    fmt.Println("OS X.")
    case "linux":
    fmt.Println("Linux.")
    default:
    // freebsd, openbsd,
    // plan9, windows...
    fmt.Printf("%s.", os)
    }
    }

  • defer
    defer 语句会延迟函数的执行直到上层函数返回。
    延迟调用的参数会立刻生成,但是在上层函数返回前函数都不会被调用。

    1
    2
    3
    4
    5
    6
    func main() {
    defer fmt.Println("world")//延迟函数
    fmt.Println("hello") //上层函数
    }
    //hello
    //wolrd

复杂类型

  • 指针
    Go 具有指针。 指针保存了变量的内存地址

    1
    2
    3
    4
    5
    6
    7
    8
    func main() {
    i, j := 42, 2701

    p := &i /* 生成一个指向 i 的指针 */
    fmt.Println(*p) /* 通过指针 p 读取 i */
    *p = 21 /* 通过指针 p 设置 i */
    fmt.Println(i) /* 输出 i =21 */
    }
  • 结构体
    一个结构体(struct)就是一个字段的集合

    1
    2
    3
    4
    5
    6
    7
    8
    type Vertex struct {
    X int
    Y int
    }

    v := Vertex{1, 2}
    v.X = 4
    fmt.Println(v.X)
  • 数组
    类型 [n]T 是一个有 n 个类型为 T 的值的数组

    1
    2
    3
    4
    5
    6
    7
    8
    func main() {
    var a [2]string
    a[0] = "Hello"
    a[1] = "World"
    fmt.Println(a[0], a[1])
    fmt.Println(a)
    }

  • slice
    一个 slice 会指向一个序列的值,并且包含了长度信息
    s[lo:hi]表示从 lo 到 hi-1 的 slice 元素,含两端。因此
    s[lo:lo]是空的,而
    s[lo:lo+1]有一个元素。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    func main() {
    p := []int{2, 3, 5, 7, 11, 13}
    fmt.Println("p ==", p)

    for i := 0; i < len(p); i++ {
    fmt.Printf("p[%d] == %d\n", i, p[i])
    }
    }

  • map
    map 映射键到值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    type Vertex struct {
    Lat, Long float64
    }

    var m map[string]Vertex

    func main() {
    m = make(map[string]Vertex)
    m["Bell Labs"] = Vertex{
    40.68433, -74.39967,
    }
    fmt.Println(m["Bell Labs"])
    }

Tags: golang
使用支付宝打赏
使用微信打赏

欢迎点击上方按钮对我打赏,谢谢你给我吃糖果