go语言学习笔记

go语言基础知识

go语言基础知识

基础于c，具有部署简单、并发号、执行性能好的特点。与java相比，没有类和继承，相比java更加高效，相比c更加简单易编译。go对多核心优化好，可让程序员调用硬件更多性能。在很多语法现象上有从c语言简化，同时为了降低歧义和程序员语言风格对代码功能的影响，对代码书写方式和工程文件结构等做了规定。

hello world

package main    // 声明 main 包，main包是唯一的，是入口。
import (
    "fmt"       // 导入 fmt 包，打印字符串是需要用到
)
func main() {   // 声明 main 主函数，所以函数以func开头。func 函数名 (参数列表) (返回值列表)
    fmt.Println("Hello World!") // 打印 Hello World!
}

go语言以包为管理单位，每个go源文件需要声明其所属包，一目录下同级文件属于同一个包。

数据类型和变量生成

数据类型

• bool 布尔
• string 字符串
• int、int8、int16、int32、int64 整型（分别8进制、16进制、32进制等）
• uint、uint8、uint16、uint32、uint64、uintptr
• byte // uint8 的别名
• float32、float64 实型

变量赋值方式

var name type 变量声明方式

var (  //批量变量
    a int =3 //不需要“；”
    b string
    c []float32
    d func() bool
    e struct {
        x int
    }
)

a,s:=1, "abc"//简化申明和赋值
c:=a+a
ptr := &v  //指针变量
var a,b *int  //指针变量
var q [3]int = [3]int{1, 2, 3}  //数组同时赋值

全局变量在主函数之外进行声明。

GO语言容器

数组遍历

var team [3]string
team[0] = "hammer"
team[1] = "soldier"
team[2] = "mum"
for k, v := range team {  //k如计数器，从0开始。v作为桥梁，获取数组team的值
    fmt.Println(k, v)
}

切片

fmt.Println(team[1:2])  //输出数组第二和第三个的内容。相当于生成切片。
b := make([]int, 2, 10)  //使用make函数，预分配10个内存空间，但使用2个元素

var a []int
a = append(a, 1, 2, 3)  // append追加多个元素, 手写解包方式。还有copy复制切片等

map概念（python中的字典）

map是一种特殊的数据结构，是由key（索引）和value（值）两个元素组合成的无序集合。map的容量是动态的。

package main
import "fmt"
func main() {
    var mapLit map[string]int  //分别是map名、map结合值中的key的类型以及map的值的类型
    mapLit = map[string]int{"one": 1, "two": 2}
    mapCreated := make(map[string]int)
    mapCreated["key1"] = 4.5
    mapCreated["key2"] = 3.14159
    fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])
    fmt.Printf("Map created at \"key2\" is: %f\n", mapCreated["key2"])

}

scene := make(map[string]int)
scene["route"] = 66
scene["brazil"] = 4
scene["china"] = 960
delete(scene, "brazil")  //删除一组值
for k, v := range scene {  //遍历
    fmt.Println(k, v)
}

go语言程序结构

判断

if condition1 {
    // do something
} else if condition2 {
    // do something else
}else {
    // catch-all or default
}

var s = "hello"
switch {
case s == "hello":  //case 判断表达式
    fmt.Println("hello")
    fallthrough
case s != "world":
    fmt.Println("world")
}

循环

只支持for循环

sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

for key, val := range coll {  //常用语遍历的循环模式，其中key作为递增。val是只读传递数值
    ...
}

break退出本次循环。 goto可以直接跳出多层循环到标签处。

goto breakHere

breakHere:
    fmt.Println("done")

函数

一般函数声明

func typedTwoValues() (int, int) {
    return 1, 2
}
func main() {
    a, b := typedTwoValues()
    fmt.Println(a, b)
}

package main
import (
    "fmt"
)
func fire() {
    fmt.Println("fire")
}
func main() {
    var f func()  //将func函数当做一种类型，定义一个f变量
    f = fire  //调用变量，相当于无传入的函数
    f()
}

结构体

go语言没有类的概念,结构体与c语言类似。（不过我感觉c和go的结构体和java的类挺相似，因为都可以属性继承等。）

type Point struct {  //结构体定义
    X int
    Y string
}

var p Point  //实例化
p.X = 10  //调用

接口概念

虽然go没有类和继承的概念，但其通过接口的概念实现面对对象的特性（一种抽象的存在）。

type writer interface{  //定义接口名，interface是定义接口关键词。接口类型由数个方法构成，默认在接口名后面加er以便于区分
    Write([]byte) error
    方法名（参数列表） 返回值
}