go-基本使用

定义变量

// 定义变量, 后面的类型可写可不写
var name 
var nameWithType string
// 不适用var 的方式定义. 此时的name 不能再之前定义过. 否则会报错
name := "Nirvana"
// 数组的定义
var ages = [3]int{1,2,3}
var emails = [...]{"", "", ""}
var names [5]string
names[0] = "a"
names[1] = "b"

变量的地址

var age = 20
fmt.Println("内存地址: ", &age)

常量的使用

// 常量的定义
const age = 10
const name string = "Nirvana"

指针的使用

var a = 10
var ptr *int = &a
// 这边修改的是具体的值, 即a 和 *ptr 都会被修改
*ptr = 11
fmt.Println(*ptr)

结构体的使用

type Books struct {
    title string
    author string
    subject string
    bookId int
}
func main() {
    // 构造方法1
    var book = Books{"三国", "罗贯中", "文科", 10}
    fmt.Println(book)
    // 构造方法2
    var b2 = Books{title: "西游", author: "吴承恩"}
    fmt.Println(b2)
    // 如果不添加构造函数的参数, 直接填充需要赋值的值。会提示错误
    // ./hello.go:19:27: too few values in Books literal
    // 访问结构体成员
    fmt.Println(b2.title)
}

切片

切片的功能是针对数组的确定而产生的。数组固定的长度, go语言定义切片是动态的数组。

import "fmt"
func main() {
    var list = make([]int, 2)
    list[0] = 1
    list[1] = 2
    // 给2 赋值会提示超出指定的索引
    // list[2] = 3
    // 这里不需要添加var. 因为 := 赋值的方式就是定义变量并初始化
    listInit :=[] int {1,2,3}
    listFormArray := listInit[:]
    // 这边修改了listInit。 导致listFormArray 跟着一起变动. 
    listInit[2] = 10
    // 追加元素
    listFormArray = append(listFormArray, 11)
    fmt.Println(list)
    fmt.Println(listInit)
    fmt.Println(listFormArray)
    fmt.Println(len(listInit), cap(listInit))
    // fmt.Println("Hello Go")
}

Range 的使用

类似遍历数组、切片、集合等等的情况

import "fmt"
func main() {
    nums := []int {1,2,3,4,5}
    sum := 0
    for i, num := range nums {
        sum += num
        fmt.Println("i = ", i)
    }
    if sum == 15 {
        fmt.Println("哈哈哈哈")
    }
    fmt.Println(sum)
}

Map 集合的使用

是一种无序的键值对

import "fmt"
func main() {
    scores := map[string]int{"语文": 12, "数学": 13}
    fmt.Println(scores["语文"])
    fmt.Println(scores)
    // 遍历
    for key, val := range scores {
        fmt.Println("key: ", key, " value: ", val)
    }
    // 手动创建
    names := make(map[string]string)
    names["name"] = "Nirvana"
    names["age"] = "12"
    fmt.Println(names)
    // 删除元素
    delete(names, "age")
}

并发编程

轻量级线程, 通过go 来开启goroutine。

import (
    "fmt"
    "time"
)
func say(s string) {
    for i :=0; i < 5; i++ {
        time.Sleep(100*time.Millisecond)
        fmt.Println(s)
    }
}
func main() {
    go say("thread-1")
    say("thread-2")
}

通道

用于线程间传递数据而是用的。

import "fmt"
func sum(nums []int, ch chan int)  {
    sum := 0
    for _, num := range nums{
        sum +=num
    }
    ch <- sum
}
func main() {
    nums := []int {1,2,3,4,5,6,7,8,9,10}
    ch := make(chan int)
    _1nums := nums[:len(nums)/2]
    _2nums := nums[len(nums)/2:]
    fmt.Println(_1nums)
    fmt.Println(_2nums)
    go sum(_1nums, ch)
    go sum(_2nums, ch)
    // 相当于将两个结果放到ch 中。
    x, y := <-ch, <-ch
    fmt.Println(x, y, x+y)
}