Go 入门系列之基础篇一

Go 入门系列

基础篇一

1. 包的使用

package main
import "fmt"

func main() {
	//...
}

• go run 只能运行 main 包下有 main 函数的 go 文件
• 包名和文件夹名称没有直接关系, 但是同一个文件夹下只能有唯一的一个包名

2. 行分隔符

在 Go 中, 一行代表一个语句结束! 无需 ; 结尾.

如果执意要写多个语句在一行, 需要;分隔.

3. 注释

注释不会被编译. 和 Java 类似, 也有 单行编译和多行编译.

// 单行注释
/*
 我是多行注释
*/

4. 标识符

标识符用于命名变量, 类型等程序实体.

abc, kumar, i, _temp, my001

5. 值

package main
import "fmt"
func main() {
	fmt.Println("Google" + " Runner")
	fmt.Println("Hello, World!" + "abc")
	// 打印
	// emem =  2 5
	fmt.Println("emem = ", 1 + 1,  2 + 3)
	
	// 7.0/3.0 = 2.3333333333333335
	fmt.Println("7.0/3.0 =", 7.0/3.0)
	
}

6. 变量

在 Go 中，变量 被显式声明，并被编译器所用来检查函数调用时的类型正确性

package main
import "fmt"
func main() {
	// 定义一个名为 str 的字符串变量, 其值初始化为 init value
	var str string = "init value"
	//  两个 int 变量 并赋予初始值 1, 2
	var i, j int = 1, 2
	// 自动推到 b 的类型
	var b = true
	// 相当于 var c int = 3
    c := 3
}

声明变量如果没有给出对应的初始值时, 变量将会初始化为零值
int 对应 0
bool 对应 false
string 对应 空串

7. 常量

Go 支持 字符, 字符串, 布尔 和 数值 常量

package main
import "fmt"
import "math"
const  s string = "constant value"
func main() {
	fmt.Println(s)
	const n = 500000000
	
	const d = 3e20 / n
	fmt.Println(d)
	// 这里 Sin 函数需要 float64 参数, 数值型常量可以直接给定过去
	fmt.Println(math.Sin(n))
}

8. For 循环

for 是 Go 中唯一的循环结构

package main
import "fmt"
func main () {
   i := 1
   for i <= 5 {
       fmt.Println(i)
       i ++
   }
   for i = 1; i < 3; i++ {
       fmt.Println("for-Two:", i)
   }
   for {
       fmt.Println("loop")
       break
   }
}

9. 分支结构

一个基本的 if/else

package main
import "fmt"
func main() {
	var i int = 5
    if i % 2 == 0 {
        fmt.Println("enter if block")
    } else if i <= 3 {
        fmt.Println("enter else if block")
    } else {
        fmt.Println("enter else block")
    }
}

Go 中 可以不使用 圆括号, 但是花括号是必须要的

一个基本的 switch

package main

import "fmt"
import "time"

const  s string = "constant value"

func main() {
    i := 99
    fmt.Println("write", i, "as")

    switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("Two")
    case 3:
        fmt.Println("Three")
    default:
        fmt.Println("default")
    }

    t := time.Now()
    switch  {
    case t.Hour() < 12:
        fmt.Println("it's before noon")
    default:
        fmt.Println("it's after noon")
    }
	// case 可以放置多个条件
	k := time.Now().Weekday()
	switch k {
	case time.Saturday, time.Sunday:
        fmt.Println("it's the weekend")
    default:
        fmt.Println("it's a weekday")
	}
}

10. 数组

在Go 中 数组 是一个固定长度的数列

// 省略开头
func main() {
    var a[5] int

    fmt.Println("emp", a)
    a[4] = 100
    fmt.Println("emp", a)
    // 申明一个二维数组
    var b[2][3] int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            b[i][j] = i + j
        }
    }
    // 使用内置函数 len 取得数组长度
    fmt.Println(b, "len =", len(b[0]))
}

11. Slice (切片)

Slice 是 Go 中一个关键的数据结构, 比数组更加强大 的序列接口

• make () 创建 slice
• append() 添加新元素并返回新的 slice
• len() 返回 slice 的长度
• copy() 复制

func main() {
	// make 函数创建一个长度为3, 类型是 string 的 slice(默认空值)
    s := make([]string, 3)
    fmt.Println("emp:", s)
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("after update:", s)
    fmt.Println("len = ", len(s))
	// append 函数 添加新元素并返回新的 slice
    s = append(s, "d", "e")
    fmt.Println("new slice: ", s)

    var c []string = make([]string, len(s)-2)
    copy(c, s)
    fmt.Println(c)
	// 切片(截取) 操作
    l := s[2:5]
    fmt.Println(l)
    l = s[2:]
    fmt.Println(l)
    l = s[:3]
    fmt.Println(l)

    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(twoD)
}

12. 关联数组

map 是 Go 内置 关联数据类型. (在 Java 中称为 哈希)

• 创建一个空的 Map

m := make(map[string]int)
m["k1"] = 7

• 获取 map 大小

len(m)

• 通过 key 删除映射

delete(m, "k2")
_, prs := m["k2"]
// prs: false, 可选的第二返回值 指示这个键是否在 map 中. 以避免歧义
fmt.Println("prs:", prs)

13. Range 遍历

range 迭代各种各样的数据结构

package main
import "fmt"
func main() {
	nums := []int{2, 3, 4}
	sum := 0
	// 使用 空值定义符_ 来忽略索引
	for _, num := range nums {
		sum += num
	}
	fmt.Println("sum:", sum)
	// 不忽略索引
	for i, num := range nums {
		// ...
	}
	// 遍历  map 类型
	kvs := map[string]string{"a":"apple", "b":"banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
	// 遍历字符串
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}