go语言学习——变量、常量、循环、条件、switch、数组和切片

1.变量

package main
import "fmt"
func main() {
var 声明 1 个或者多个变量。

    var a string = "initial"
    fmt.Println(a)
你可以申明一次性声明多个变量。

    var b, c int = 1, 2
    fmt.Println(b, c)
Go 将自动推断已经初始化的变量类型。

    var d = true
    fmt.Println(d)
声明变量且没有给出对应的初始值时，变量将会初始化为零值 。例如，一个 int 的零值是 0。

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

    f := "short"
    fmt.Println(f)
}

2.常量

package main
import "fmt"
import "math"
const 用于声明一个常量。

const s string = "constant"
func main() {
    fmt.Println(s)
const 语句可以出现在任何 var 语句可以出现的地方

    const n = 500000000
常数表达式可以执行任意精度的运算

    const d = 3e20 / n
    fmt.Println(d)
数值型常量是没有确定的类型的，直到它们被给定了一个类型，比如说一次显示的类型转化。

    fmt.Println(int64(d))
当上下文需要时，一个数可以被给定一个类型，比如变量赋值或者函数调用。举个例子，这里的 math.Sin函数需要一个 float64 的参数。

    fmt.Println(math.Sin(n))
}

3.循环

普通循环

package main
import "fmt"
func main() {
最常用的方式，带单个循环条件。

    i := 1
    for i <= 3 {
        fmt.Println(i)
        i = i + 1
    }
经典的初始化/条件/后续形式 for 循环。

    for j := 7; j <= 9; j++ {
        fmt.Println(j)
    }
不带条件的 for 循环将一直执行，直到在循环体内使用了 break 或者 return 来跳出循环。

    for {
        fmt.Println("loop")
        break
    }
}

range循环

arr := [3]int{1, 4, 5}
fmt.Println(arr)
for _, v := range arr {
    fmt.Println(v)
}

对数组使用range会自动迭代，并在每次迭代返回两个值，第一个是索引，第二个是值，但是在go语言中，只要定义的变量就必须使用，而且我们常常用不到索引，那么怎么办呢？

用单下划线来替代索引，这样就省略了变量的定义。

4.条件

package main
import "fmt"
func main() {
这里是一个基本的例子。

    if 7%2 == 0 {
        fmt.Println("7 is even")
    } else {
        fmt.Println("7 is odd")
    }
你可以不要 else 只用 if 语句。

    if 8%4 == 0 {
        fmt.Println("8 is divisible by 4")
    }
在条件语句之前可以有一个语句；任何在这里声明的变量都可以在所有的条件分支中使用。

    if num := 9; num < 0 {
        fmt.Println(num, "is negative")
    } else if num < 10 {
        fmt.Println(num, "has 1 digit")
    } else {
        fmt.Println(num, "has multiple digits")
    }
}

5.switch

package main
import "fmt"
import "time"
func main() {
一个基本的 switch。

    i := 2
    fmt.Print("write ", i, " as ")
    switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    }
在一个 case 语句中，你可以使用逗号来分隔多个表达式。在这个例子中，我们很好的使用了可选的default 分支。

    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("it's the weekend")
    default:
        fmt.Println("it's a weekday")
    }
不带表达式的 switch 是实现 if/else 逻辑的另一种方式。这里展示了 case 表达式是如何使用非常量的。

    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("it's before noon")
    default:
        fmt.Println("it's after noon")
    }
}

6.数组

package main
import "fmt"
func main() {
这里我们创建了一个数组 a 来存放刚好 5 个 int。元素的类型和长度都是数组类型的一部分。数组默认是零值的，对于 int 数组来说也就是 0。

    var a [5]int
    fmt.Println("emp:", a)
我们可以使用 array[index] = value 语法来设置数组指定位置的值，或者用 array[index] 得到值。

    a[4] = 100
    fmt.Println("set:", a)
    fmt.Println("get:", a[4])
使用内置函数 len 返回数组的长度

    fmt.Println("len:", len(a))
使用这个语法在一行内初始化一个数组

    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("dcl:", b)
数组的存储类型是单一的，但是你可以组合这些数据来构造多维的数据结构。

    var twoD [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

7.切片

package main
import "fmt"
func main() {
不像数组，slice 的类型仅由它所包含的元素决定（不像数组中还需要元素的个数）。要创建一个长度非零的空slice，需要使用内建的方法 make。这里我们创建了一个长度为3的 string 类型 slice（初始化为零值）。

    s := make([]string, 3)
    fmt.Println("emp:", s)
我们可以和数组一样设置和得到值

    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])
如你所料，len 返回 slice 的长度

    fmt.Println("len:", len(s))
作为基本操作的补充，slice 支持比数组更多的操作。其中一个是内建的 append，它返回一个包含了一个或者多个新值的 slice。注意我们接受返回由 append返回的新的 slice 值。

    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)
Slice 也可以被 copy。这里我们创建一个空的和 s 有相同长度的 slice c，并且将 s 复制给 c。

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)
Slice 支持通过 slice[low:high] 语法进行“切片”操作。例如，这里得到一个包含元素 s[2], s[3],s[4] 的 slice。

    l := s[2:5]
    fmt.Println("sl1:", l)
这个 slice 从 s[0] 到（但是包含）s[5]。

    l = s[:5]
    fmt.Println("sl2:", l)
这个 slice 从（包含）s[2] 到 slice 的后一个值。

    l = s[2:]
    fmt.Println("sl3:", l)
我们可以在一行代码中声明并初始化一个 slice 变量。

    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)
Slice 可以组成多维数据结构。内部的 slice 长度可以不同，这和多位数组不同。

    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

https://www.cnblogs.com/liuzhongchao/p/9159896.html 这个博客讲的好