go变量 - 简书

:= 语句是申明并初始化变量的简写，例如这个例子中的 var f string = "short"。

for j := 7; j <= 9; j++ {
        fmt.Println(j)
    }

注意，在 Go 中，你可以不适用圆括号，但是花括号是需要的。
Go 里没有三目运算符，所以即使你只需要基本的条件判断，你仍需要使用完整的 if 语句。

 i := 2
    fmt.Print("write ", i, " as ")
    switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    }

// 切片slice

package main
 
import "fmt"
 
func main () {
    s := make([]string, 0)
    s = append(s, "a", "b", "c", "d", "e", "f")

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    l := s[2:5]
    fmt.Println("sl1:", l)

    l = s[:5]
    fmt.Println("sl2:", l)

    l = s[2:]
    fmt.Println("sl3:", l)

// 要创建一个空 map，需要使用内建的 `make`:
    // `make(map[key-type]val-type)`.
    m := make(map[string]int)

    // 使用典型的 `make[key] = val` 语法来设置键值对。
    m["k1"] = 7
    m["k2"] = 13

    // 使用例如 `Println` 来打印一个 map 将会输出所有的
    // 键值对。
    fmt.Println("map:", m)

    // 使用 `name[key]` 来获取一个键的值
    v1 := m["k1"]
    fmt.Println("v1: ", v1)

    // 当对一个 map 调用内建的 `len` 时，返回的是键值对
    // 数目
    fmt.Println("len:", len(m))

    // 内建的 `delete` 可以从一个 map 中移除键值对
    delete(m, "k2")
    fmt.Println("map:", m)

    // 当从一个 map 中取值时，可选的第二返回值指示这个键
    // 是在这个 map 中。这可以用来消除键不存在和键有零值，
    // 像 `0` 或者 `""` 而产生的歧义。
    _, prs := m["k2"]
    fmt.Println("prs:", prs)

    // 你也可以通过这个语法在同一行申明和初始化一个新的
    // map。
    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)
}

//Range 遍历

package main
import "fmt"
func main() {
这里我们使用 range 来统计一个 slice 的元素个数。数组也可以采用这种方法。

    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)
range 在数组和 slice 中都同样提供每个项的索引和值。上面我们不需要索引，所以我们使用 空值定义符_ 来忽略它。有时候我们实际上是需要这个索引的。

    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
range 在 map 中迭代键值对。

    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
range 在字符串中迭代 unicode 编码。第一个返回值是rune 的起始字节位置，然后第二个是 rune 自己。

    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

$ go run range.go 
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111

//函数

package main
import "fmt"
这里是一个函数，接受两个 int 并且以 int 返回它们的和

func plus(a int, b int) int {
Go 需要明确的返回值，例如，它不会自动返回最后一个表达式的值

    return a + b
}
func main() {
正如你期望的那样，通过 name(args) 来调用一个函数，

    res := plus(1, 2)
    fmt.Println("1+2 =", res)
}
$ go run functions.go 
1+2 = 3

结构体：Go 的结构体是各个字段字段的类型的集合。这在组织数据时非常有用。

package main
import "fmt"
这里的 person 结构体包含了 name 和 age 两个字段。

type person struct {
    name string
    age  int
}
func main() {
使用这个语法创建了一个新的结构体元素。

    fmt.Println(person{"Bob", 20})
你可以在初始化一个结构体元素时指定字段名字。

    fmt.Println(person{name: "Alice", age: 30})
省略的字段将被初始化为零值。

    fmt.Println(person{name: "Fred"})
& 前缀生成一个结构体指针。

    fmt.Println(&person{name: "Ann", age: 40})
使用点来访问结构体字段。

    s := person{name: "Sean", age: 50}
    fmt.Println(s.name)
也可以对结构体指针使用. - 指针会被自动解引用。

    sp := &s
    fmt.Println(sp.age)
结构体是可变的。

    sp.age = 51
    fmt.Println(sp.age)
}
$ go run structs.go
{Bob 20}
{Alice 30}
{Fred 0}
&{Ann 40}
Sean
50
51

排序：
Go 的 sort 包实现了内置和用户自定义数据类型的排序功能。我们首先关注内置数据类型的排序。

package main
import "fmt"
import "sort"
func main() {
排序方法是正对内置数据类型的；这里是一个字符串的例子。注意排序是原地更新的，所以他会改变给定的序列并且不返回一个新值。

    strs := []string{"c", "a", "b"}
    sort.Strings(strs)
    fmt.Println("Strings:", strs)
一个 int 排序的例子。

    ints := []int{7, 2, 4}
    sort.Ints(ints)
    fmt.Println("Ints:   ", ints)
我们也可以使用 sort 来检查一个序列是不是已经是排好序的。

    s := sort.IntsAreSorted(ints)
    fmt.Println("Sorted: ", s)
}
运行程序，打印排序好的字符串和整形序列以及我们 AreSorted测试的结构 true。

$ go run sorting.go
Strings: [a b c]
Ints:    [2 4 7]
Sorted:  true

时间time

package main
import "fmt"
import "time"
func main() {
    p := fmt.Println
得到当前时间。

    now := time.Now()
    p(now)
通过提供年月日等信息，你可以构建一个 time。时间总是关联着位置信息，例如时区。

    then := time.Date(
        2009, 11, 17, 20, 34, 58, 651387237, time.UTC)
    p(then)
你可以提取出时间的各个组成部分。

    p(then.Year())
    p(then.Month())
    p(then.Day())
    p(then.Hour())
    p(then.Minute())
    p(then.Second())
    p(then.Nanosecond())
    p(then.Location())
输出是星期一到日的 Weekday 也是支持的。

    p(then.Weekday())
这些方法来比较两个时间，分别测试一下是否是之前，之后或者是同一时刻，精确到秒。

    p(then.Before(now))
    p(then.After(now))
    p(then.Equal(now))
方法 Sub 返回一个 Duration 来表示两个时间点的间隔时间。

    diff := now.Sub(then)
    p(diff)
我们计算出不同单位下的时间长度值。

    p(diff.Hours())
    p(diff.Minutes())
    p(diff.Seconds())
    p(diff.Nanoseconds())
你可以使用 Add 将时间后移一个时间间隔，或者使用一个 - 来将时间前移一个时间间隔。

    p(then.Add(diff))
    p(then.Add(-diff))
}
$ go run time.go
2012-10-31 15:50:13.793654 +0000 UTC
2009-11-17 20:34:58.651387237 +0000 UTC
2009
November
17
20
34
58
651387237
UTC
Tuesday
true
false
false
25891h15m15.142266763s
25891.25420618521
1.5534752523711128e+06
9.320851514226677e+07
93208515142266763
2012-10-31 15:50:13.793654 +0000 UTC
2006-12-05 01:19:43.509120474 +0000 UTC