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

1.变量

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

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

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

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

    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 =
常数表达式可以执行任意精度的运算

    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 :=
    for i <=  {
        fmt.Println(i)
        i = i +
    }
经典的初始化/条件/后续形式 for 循环。

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

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

range循环

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

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

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

4.条件

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

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

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

    if num := ; num <  {
        fmt.Println(num, "is negative")
    } else if num <  {
        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 :=
     fmt.Print("write ", i, " as ")
     switch i {
     case :
         fmt.Println("one")
     case :
         fmt.Println("two")
     case :
         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() < :
         fmt.Println("it's before noon")
     default:
         fmt.Println("it's after noon")
     }
 }

6.数组

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

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

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

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

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

     var twoD [][]int
     for i := ; i < ; i++ {
         for j := ; j < ; 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, )
     fmt.Println("emp:", s)
 我们可以和数组一样设置和得到值

     s[] = "a"
     s[] = "b"
     s[] = "c"
     fmt.Println("set:", s)
     fmt.Println("get:", s[])
 如你所料，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[], s[],s[] 的 slice。

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

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

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

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

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

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