• Go语言if判断语句

    golang

    跟 for 语句 一样， if 语句条件表达式不需要括号包围，但花括号却不能省略。我们来看一个例子：

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

    package main

import (
    "fmt"
    "math"
)

func sqrt(x float64) string {
    if x < 0 {
        return sqrt(-x) + "i"
    }
    return fmt.Sprint(math.Sqrt(x))
}

func main() {
    fmt.Println(sqrt(2), sqrt(-4))
}

    sqrt 函数计算平方根，并以字符串形式返回。如果对负数求根（第 9 行），将以虚数形式返回。

    阅读全文

  • Go语言switch语句

    golang

    switch 语句也是一种经典控制语句，可以看做是 if-else 语句链的简写。

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

    package main

import (
    "fmt"
    "runtime"
)

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.\n", os)
    }
}

    Go 语言 switch 结构跟 C 、 C++ 、 Java 、 JavaScript 以及 PHP 等类似，不同的是，Go 只执行匹配的 case 代码体，不包括下面的。

    阅读全文

  • Go语言defer语句

    golang

    defer 语句将函数执行推迟到调用函数（包含函数）退出。函数调用参数还是立马求值，只是执行推迟而已。

    1
2
3
4
5
6
7
8
9

    package main

import "fmt"

func main() {
    defer fmt.Println("world")

    fmt.Println("hello")
}

    对，就是这么简单！

    阅读全文

  • Go语言指针入门

    golang

    Go 语言也有 指针（ pointer ），指针用于保存一个值的内存地址。

    类型 *T 就是类型 T 的指针类型。 指针的 零值（ zero value ）是： nil 。

    1

    var p *int

    操作符（ operator ） & 用来取 被操作数（ operand ）的指针（内存地址）：

    1
2

    i := 42
p = &i
    阅读全文

  • Go语言结构体入门

    golang

    Go 语言也有 结构体（ struct ）——由若干 字段（ field ）组成的集合。

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

    package main

import "fmt"

type Vertex struct {
    X int
    Y int
}

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

    这个例子定义了一个名为 Vertex 的结构体，用于表示一个顶点。 结构体包含两个字段 X 和 Y ，类型都是 int ，分别表示顶点的横坐标和纵坐标。

    阅读全文

  • Go语言数组入门

    golang

    Go 也有 数组（ array ）， [n]T 就表示一个由 n 个类型 T 元素组成的数组类型。

    下面这个表达式，申明了一个由 10 个整数组成的数组变量：

    1

    var a [10]int

    数组的长度是类型的一部分（长度不同意味着类型不同），所以数组没有办法调整尺寸。这看上去很有局限性；然而并不用太担心， Go 提供的方案也很方便。

    阅读全文

  • Go语言切片入门

    golang

    数组 长度是固定的，而 切片（ slice ）是一个数组元素的弹性视图，长度可以是动态的。实际上，切片比数组更为常用。

    类型 []T 就是一个由类型 T 元素组成的切片。

    切片通过两个索引下标定义，一个表示 下边界（ low bound ），一个表示 上边界（ high bound ），以冒号（ : ）分隔：

    1

    a[low : high]

    这表示一个 半开半闭 区间，包括第一个元素，但不包括最后一个。

    以下表达式创建一个包含元素 1 到元素 3 的切片（不包括元素 4 ）：

    1

    a[1:4]
    阅读全文

  • Go语言映射表入门

    golang

    映射表（ map ）是一种将 键（ key ）映射到 值（ value ）的数据结构。

    映射表的零值是 nil 。 一个 nil 映射表不包含任何键值数据，而且也不能添加新数据。

    映射表同样可以通过 make 函数来创建并初始化：

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

    package main

import "fmt"

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"])
}
    阅读全文

  • Go语言函数值

    golang

    Go 语言中的函数也是一种值，可以被传递，跟 C++ 函数对象、 Python 函数类似。

    跟其他普通值一样，函数也可以作为 参数 传递或作为 返回值 返回。

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

    package main

import (
    "fmt"
    "math"
)

func compute(fn func(float64, float64) float64) float64 {
    return fn(3, 4)
}

func main() {
    hypot := func(x, y float64) float64 {
        return math.Sqrt(x*x + y*y)
    }
    fmt.Println(hypot(5, 12))

    fmt.Println(compute(hypot))
    fmt.Println(compute(math.Pow))
}
    阅读全文

  • Go语言类型方法简介

    golang

    Go 语言没有类的概念，但是你可以为某个类型定义 方法（ method ）。

    方法 是一个带 接收者参数 的特殊函数。接收者参数位于 func 关键字与方法名之间，以括号包围。

    下面这个例子中， Abs 方法有一个 Vertex 类型的接收者参数 v ：

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

    package main

import (
    "fmt"
    "math"
)

type Vertex struct {
    X, Y float64
}

func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    v := Vertex{3, 4}
    fmt.Println(v.Abs())
}
    阅读全文