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

 1 package main
 2 import "fmt"
 3 import "time"
 4 func main() {
 5 一个基本的 switch。
 6 
 7     i := 2
 8     fmt.Print("write ", i, " as ")
 9     switch i {
10     case 1:
11         fmt.Println("one")
12     case 2:
13         fmt.Println("two")
14     case 3:
15         fmt.Println("three")
16     }
17 在一个 case 语句中，你可以使用逗号来分隔多个表达式。在这个例子中，我们很好的使用了可选的default 分支。
18 
19     switch time.Now().Weekday() {
20     case time.Saturday, time.Sunday:
21         fmt.Println("it's the weekend")
22     default:
23         fmt.Println("it's a weekday")
24     }
25 不带表达式的 switch 是实现 if/else 逻辑的另一种方式。这里展示了 case 表达式是如何使用非常量的。
26 
27     t := time.Now()
28     switch {
29     case t.Hour() < 12:
30         fmt.Println("it's before noon")
31     default:
32         fmt.Println("it's after noon")
33     }
34 }

View Code

6.数组

 1 package main
 2 import "fmt"
 3 func main() {
 4 这里我们创建了一个数组 a 来存放刚好 5 个 int。元素的类型和长度都是数组类型的一部分。数组默认是零值的，对于 int 数组来说也就是 0。
 5 
 6     var a [5]int
 7     fmt.Println("emp:", a)
 8 我们可以使用 array[index] = value 语法来设置数组指定位置的值，或者用 array[index] 得到值。
 9 
10     a[4] = 100
11     fmt.Println("set:", a)
12     fmt.Println("get:", a[4])
13 使用内置函数 len 返回数组的长度
14 
15     fmt.Println("len:", len(a))
16 使用这个语法在一行内初始化一个数组
17 
18     b := [5]int{1, 2, 3, 4, 5}
19     fmt.Println("dcl:", b)
20 数组的存储类型是单一的，但是你可以组合这些数据来构造多维的数据结构。
21 
22     var twoD [2][3]int
23     for i := 0; i < 2; i++ {
24         for j := 0; j < 3; j++ {
25             twoD[i][j] = i + j
26         }
27     }
28     fmt.Println("2d: ", twoD)
29 }

View Code

7.切片

 1 package main
 2 import "fmt"
 3 func main() {
 4 不像数组，slice 的类型仅由它所包含的元素决定（不像数组中还需要元素的个数）。要创建一个长度非零的空slice，需要使用内建的方法 make。这里我们创建了一个长度为3的 string 类型 slice（初始化为零值）。
 5 
 6     s := make([]string, 3)
 7     fmt.Println("emp:", s)
 8 我们可以和数组一样设置和得到值
 9 
10     s[0] = "a"
11     s[1] = "b"
12     s[2] = "c"
13     fmt.Println("set:", s)
14     fmt.Println("get:", s[2])
15 如你所料，len 返回 slice 的长度
16 
17     fmt.Println("len:", len(s))
18 作为基本操作的补充，slice 支持比数组更多的操作。其中一个是内建的 append，它返回一个包含了一个或者多个新值的 slice。注意我们接受返回由 append返回的新的 slice 值。
19 
20     s = append(s, "d")
21     s = append(s, "e", "f")
22     fmt.Println("apd:", s)
23 Slice 也可以被 copy。这里我们创建一个空的和 s 有相同长度的 slice c，并且将 s 复制给 c。
24 
25     c := make([]string, len(s))
26     copy(c, s)
27     fmt.Println("cpy:", c)
28 Slice 支持通过 slice[low:high] 语法进行“切片”操作。例如，这里得到一个包含元素 s[2], s[3],s[4] 的 slice。
29 
30     l := s[2:5]
31     fmt.Println("sl1:", l)
32 这个 slice 从 s[0] 到（但是包含）s[5]。
33 
34     l = s[:5]
35     fmt.Println("sl2:", l)
36 这个 slice 从（包含）s[2] 到 slice 的后一个值。
37 
38     l = s[2:]
39     fmt.Println("sl3:", l)
40 我们可以在一行代码中声明并初始化一个 slice 变量。
41 
42     t := []string{"g", "h", "i"}
43     fmt.Println("dcl:", t)
44 Slice 可以组成多维数据结构。内部的 slice 长度可以不同，这和多位数组不同。
45 
46     twoD := make([][]int, 3)
47     for i := 0; i < 3; i++ {
48         innerLen := i + 1
49         twoD[i] = make([]int, innerLen)
50         for j := 0; j < innerLen; j++ {
51             twoD[i][j] = i + j
52         }
53     }
54     fmt.Println("2d: ", twoD)
55 }

View Code

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