Go 的基础语法

1 Hello World

 package main
 
 import{
     "fmt"
 }
 
 func main(){
     fmt.Println("hello world")
 }

刚刚我们已经跟大家讲述了如何配置开发环境。接下来我们来通过一些小例子教大家快速学习一下go源代码的一些基础语法。我们先来看一下go语言的里面的helloword，helloworld代码大概长这样子。

第一行 package main代表这个文件属于main包的一部分，main包也就是程序的入口包。

第三行导入了标准库里面的FMT包。这个包主要是用来往屏幕输入输出字符串、格式化字符串。import 下面是main函数，main函数的话里面调用了fmt.Printin 输出 helloword

要运行这个程序的话，我们就直接go run helloword.go。如果我们想编译成二进制的话，可以在go build来编译。编译完成之后直接.／helloword就可以运行。

在FMT包里面还有很多的函数来做不同的输入输出格式化工作。大家可以在编辑器里面把鼠标悬浮在你的代码上，就可以看到每一个函数的文档。

你也可以进入 pkg.go.dev，后面加你的包名比如FMT然后就能看到这个包的在线文档，可以从里面去挑选你需要的函数来使用。

2 变量

 package main
 
 import {
     "fmt"
     "math"
 }
 
 func main(){
     var a = "initial"
     var b,c int = 1,2
     var d = true
     var e float64
     f := float32(e)
     
     g := a + "foo"
     fmt.Println(a,b,c,d,e,f)//initial 1 2 true 0 0 
     fmt.Println(g)//initialapple
     
     const s string = "constant"
     const h = 50000
     const l = 3e20/h
     fmt.Println(s,h,i,math.Sin(h),math.Sin(i))
 }

下面我们来看第二个例子，关于变量类型。 go语言是一门强类型语言，每一个变量都有它自己的变量类型。常见的变量类型包括字符串整数浮点型、布尔型等。

go 语言的字符串是内置类型，可以直接通过加号拼接，也能够直接用等于号去比较两个字符串。在go语言里面，大部分运算符的使用和优先级都和C或者C＋＋类似，这里就不再概述。

Go是后置类型语言。。。

下面讲述go语言里面的变量的声明，在go语言里面变量的声明有两种方式，

一种是通过 var name string＝“”这种方式来声明变量，声明变量的时候，一般会自动去推导变量的类型。如果有需要，你也可以显示写出变量类型。

另一种声明变量的方式是：使用变量冒号：＝等于值。

下面来讲说常量。常量的话就是把var 改成const，值在一提的是go语言里面的常量，它没有确定的类型，会根据使用的上下文来自动确定类型。

3 if else

 package main
 
 import "fmt"
 
 func main(){
     if 7 % 2 == 0{
         fmt.Println("7 is even")
     }else{
         fmt.Println("7 is odd")
     }
     
     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")
     }
 }

接下来介绍 go语言里面的 if else。 go语言里面的 if else 写法和 C 或者 C++类似。

第一个不同点是 if 后面没有括号。如果你写括号的话，那么在保存的时候你的编辑器会自动帮你去掉。

第二个不同点是 Golang 里面的 if 必须后面接大括号，就是你不能像 C 或者 C++一样，直接把 if 里面的语句同一行。

4 循环

 package main
 import "fmt"
 
 func main(){
     i := 1
     for {
         fmt.Println("loop")
         break
     }
     for j := 7; j < 9; j++{
         fmt.Println(j)
     }
     
     for(n := 0; n < 5; n++){
         if n%2 == 0{
             continue
         }
         fmt.Println(n)
     }
     for i <= 3{
         fmt.Println(i)
         i = i + 1
     }
 }

下面讲述go语言里面的循环，在go里面没有while循环、do while 循环，只有唯一的一种for循环。

最简单的for 循环就是在for 后面什么都不写，代表一个死循环。

循环途中你可以用break跳出，

也可以使用经典的C循环，就是for i等于0，i小于N, i加加。这中间三段，任何一段都可以省略。在循环里面，你可以用break 或者 continue 来跳出或者继续循环。

5 switch

 package main
 
 import{
     "fmt"
     "time"
 }
 func main(){
     a := 2
     switch a {
     case 1 :
         fmt.Println("one")
     case 2 :
         fmt.Println("two")
     case 3 :
         fmt.Println("three")
     case 4,5 :
         fmt.Println("four or five")
     default:
         fmt.Println("other")
     }
     t := time.Now()
     switch{
     case t.Hour() < 12:
         fmt.Println("It\s before noon")
     default:
         fmt.Println("It`s after noon")
     }
 }

下面是关于switch分支结构，go语言里面的switch分支结构。看起来也C或者C＋＋比较类似。同样的在switch后面的那个变量名，并不是要括号。

这里有个很大的一点不同的是，在c＋＋里面，switch case 如果不不显示加 break的话会然后会继续往下跑完所有的case，在go语言里面的话是不需要加break的。

相比C或者C＋＋，go语言里面的switch 功能更强大。可以使用任意的变量类型，甚至可以用来取代任意的if else 语句。你可以在switch后面不加任何的变量，然后在case里面写条件分支。这样代码相比你用多个 if else 代码逻辑会更为清晰。

6 数组

 package main
 
 import "fmt"
 
 func main(){
     var a [5]int
     a[4] = 100
     fmt.Println(a[4], len(a))
     
     b := [5]int{1,2,3,4,5}
     fmt.Println(b)
     
     var twoD [2][3]int
     for i := 0; i <3; i++{
         for j := 0; j < 3;j++{
             twoD[i][j] = i + j
         }
     }
     dmt.Println("2d:",twoD)
 }

下面我们来介绍一下数组。数组就是一个具有编号且长度固定的元素序列。比如这里的话是一个可以存放5个int元素的数组A。

对于一个数组，可以很方便地取特定索引的值或者往特定索引取存储值，然后也能够直接去打印一个数组。不过，在真实业务代码里面，我们很少直接使用数组，因为它长度是固定的，我们用的更多的是切片。

7 切片

 package main
 
 import "fmt"
 
 func main(){
     s := make([]string,3)
     s[0] = "a"
     s[1] = "b"
     s[2] = "c"
     fmt.Println("get:",s[2])//c
     fmt.Println("len:",len(s)) //3
     
     s = append(s,"d")
     s = append(s,"e","f")
     fmt.Println(s)//[a b c d e f]
     
     c := make([]string,len(s))
     copy(c,s)
     fmt.Println(c)//[a b c d e f]
     
     fmt.Println(s[2:5])// [c d e]
     fmt.Println(s[:5]) //[a b c d e]
     fmt.Println(s[2:]) //[c d e f]
     
     good := []string{"g","o","o","d"}
     fmt.Println(good) // [g o o d]
 }

切片不同于数组可以任意更改长度，然后也有更多丰富的操作。比如说我们可以用make来创建一个切片，可以像数组一样去取值，使用append来追加元素。注意append的用法的话，你必须把append的结果赋值为原数组。

因为slice的原理实际上是它有一个它存储了一个长度和一个容量，加一个指向一个数组的指针，在你执行 append操作的时候，如果容量不够的话，会扩容并且返回新的slice。slice 此初始化的时候也可以指定长度。

slice 拥有像python一样的切片操作，比如这个代表取出第二个到第五个位置的元素，不包括第五个元素。不过不同于python，这里不支持负数索引。

8 map

 package main
 
 import "fmt"
 
 func main(){
     m := make(map[string]int)
     m["one"] = 1
     m["two"] = 2
     fmt.Println(m)//map[one:1 two:2]
     fmt.Println(len(m))//2
     fmt.Println("one")//1
     fmt.Println("unknow")//0
     
     r,ok := m["unknow"]
     fmt.Println(r,ok)//0 false
     
     delete(m,"one")
     
     m2 := map[string]int{"one":1,"two":2}
     var m3 = map[string]int {"one":1,"two":2}
     fmt.Println(m2,m3)
 }

下面我们介绍map，在其他编程语言里面，它可能可以叫做哈希或者字典。map是实际使用过程中最频繁用到的数据结构。

我们跟我们可以用make来创建一个空map，这里会需要两个类型，第一个是那个key的类型，这里是string另一个是value的类型，这里是int。我们可以从里面去存储或者取出键值对。可以用delete从里面删除键值对。golang的map是完全无序的，遍历的时候不会按照字母顺序，也不会按照插入顺序输出，而是随机顺序。

9 range

package main

import "fmt"

func main(){
    nums := []int{2,3,4}
    sum := 0
    for i,num := range nums{
        sum += num
        if num == 2{
            fmt.Println("index:",i,"num:",num)//index: 0 num:2
        }
    }
    dmt.Println(sum) //9
    
    m := map[string]string{"a":"A","b":"B"}
    for k,v := range m{
        fmt.Println(k,v)//b B ;a A
    }
    for k := range m{
        fmt.Println("key",k)//key a;key b
    }
}

下面来介绍range。对于一个slice或者一个map的话，我们可以用range来快速遍历，这样代码能够更加简洁。range 遍历的时候，对于数组会返回两个值，第一个是索引，第二个是对应位置的值。如果我们不需要索引的话，我们可以用下划线来忽略。

10 函数

package main

import "fmt"

func add(a int ,b int)int{
    return a + b
}

func add2(a,b int)int{
    return a + b
}

func exists(m map[string]string,k string)(v string, ok bool){
    v,ok = m[k]
    return v,ok
}
func main(){
    res := add(1,2)
    fmt.Println(res)//3
    
    v,ok := exists(map[string]string{"a":"A"},"a")
    fmt.Println(v,ok) // A True
}

这个是Golang里面一个简单的实现两个变量相加的函数。Golang和其他很多语言不一样的是，变量类型是后置的。

Golang里面的函数原生支持返回多个值。在实际的业务逻辑代码里面几乎所有的函数都返回两个值，第一个是真正的返回结果，第二个值是一个错误信息。

11 指针

package main

import "fmt"

func add2(n int){
    n += 2
}

func add2ptr(n *int){
    *n += 2
}

func main(){
    n := 5
    add2(n)
    fmt.Println(n)//5
    add2ptr(&n)
    fmt.Println(n)//7
}

go里面也支持指针。当然，相比C和C＋＋里面的指针，支持的操作很有限。指针的一个主要用途就是对于传入参数进行修改。

我们来看这个函数。这个函数试图把一个变量＋2。但是单纯像上面这种写法其实是无效的。因为传入函数的参数实际上是一个拷贝，那也说这个＋2，是对那个拷贝进行了＋2，并不起作用。如果我们需要起作用的话，那么我们需要把那个类型写成指针类型，那么为了类型匹配，调用的时候会加一个＆符号。

12 结构体方法

package main

import "fmt"

type user struct{
    name string
    password string
}

func (u user) checkPassword(password string)bool{
    return u.password == password
}

func (u *user)resetPassword(password string){
    u.password = password
}
func main(){
    a := user{name:"wang",password:"1024"}
    a.resetPassword("2048")
    fmt.Println(a.checkPassword("2048"))//true
}

在Golang里面可以为结构体去定义一些方法。会有一点类似其他语言里面的类成员函数。比如这里，我们把上面一个例子的checkPassword的实现，从一个普通函数，改成了结构体方法。这样用户可以像 a.checkPassword（＂xx＂）这样去调用。具体的代码修改，就是把第一个参数，加上括号，写到函数名称前面。

在实现结构体的方法的时候也有两种写法，一种是带指针，一种是不带指针。这个它们的区别的话是说如果你带指针的话，那你那么你就可以对这个结构体去做修改。如果你不带指针的话，那你实际上操作的是一个拷贝，你就无法对结构体进行修改。

13 错误处理

package main

import{
    "erroes"
    "fmt"
}

type user struct{
    name string
    password string
}

func findUser(users []user,name string)(v *user,err error){
    for _, u := range users{
        if u.name == name{
        	return &u,nil   
        }
    }
    return nil,error.New("not found")
}

func main(){
    u,err := findUser([]user{{"wnag","1024"}},"li");err != nil{
        fmt.Println(err)//not found
        return
    }else {
        fmt.Println(u.name)
    }
}

错误处理在go语言里面符合语言习惯的做法就是使用一个单独的返回值来传递错误信息。

不同于Java 自家家使用的异常。go语言的处理方式，能够很清晰地知道哪个函数返回了错误，并且能用简单的 if else来处理错误。在函数里面，我们可以在那个函数的返回值类型里面，后面加一个error，就代表这个函数可能会返回错误。

那么在函数实现的时候，return需要同时return两个值，要么就是如果出现错误的话，那么可以return nil和一个error。如果没有的话，那么返回原本的结果和nil。

14 字符串操作

package main

import(
	"fmt"
    "string"
)

func main(){
    a := "hello"
    fmt.Println(strings.Contains(a,"ll"))//true
    fmt.Println(strings.Count(a,"l")) //2
    fmt.Println(strings.HasPrefix(a,"he"))//true
    fmt.Println(strings.Index(a,"llo"))//true
    fmt.Println(strings.Join([]string{"he","llo"},"-"))//he-llo
    fmt.Println(strings.Repeat(a,2))//hellohello
    fmt.Println(strings.Replace(a,"e","E",-1))//hEllo
    fmt.Println(strings.Split("a-b-c","-"))//[a,b,c]
    fmt.Println(strings.ToLower(a))//hello
    fmt.Println(strings.ToUpper(a))//HELLO
    fmt.Println(len(a))//5
    b := "你好"
    fmt.Println(len(b))//6
}

下面我们来看一下go语言里面的字符串操作。在标准库 strings包里面有很多常用的字符串工具函数，比如 contains 判断一个字符串里面是否有包含另一个字符串，count字符串计数，index查找某个字符串的位置。join 连接多个字符串 repeat重复多个字符串 replace 替换字符串。

15 字符串格式化

 package main
 
 import "fmt"
 
 type point struct{
     x,y int
 }
 
 func main(){
     s := "hello"
     n := 123
     p := point(1,2)
     fmt.Println(s,n) //hello 123
     fmt.Println(p) //{1,2}
     
     fmt.Printf("s = %v\n",s) //s = hello
     fmt.Printf("n = %v\n",n) //n = 123
     fmt.Printf("p = %v\n",p) //p = {1,2}
     fmt.Printf("p = %+v\n",p)//p = {x:1,y:2}
     fmt.Printf("p=%#v\n",p)//p = main.point{x:1,y:2}
     
     f := 4.141592653
     fmt.Println(f)//3.141592653
     fmt.Println("%.2f\n",f)//3.14
 }

字符串格式化。在标准库的FMT包里面有很多的字符串格式相关的方法，比如 printf这个类似于C语言里面的printf函数。不同的是，在go语言里面的话，你可以很轻松地用％v来打印任意类型的变量，而不需要区分数字字符串。你也可以用％＋v打印详细结果，％＃v则更详细。

16 JSON 处理

 package main
 import(
     "encoding/json" 
     "fmt"
 )
 type userInfo struct{ 
     Name string 
     Age int 'json:"age"` 
     Hobby []string
 }
 func main(){
     a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang","TypeScript"}} 
     buf,err :=json.Marshal(a)
     if err!=nil{ 
         panic(err) 
     }
     fmt.Println(buf)//[123 34 78 97...]
     fmt.Println(string(buf)) // {"Name":"wang", "age":18, "Hobby":["Golang","TypeScript"]} 
     
     buf,err =json.MarshalIndent(a,"","\t")
     if err!=nil{ 
         panic(err) 
     }
     fmt.Println(string(buf)) 
     
     var b userInfo
     err = json.Unmarshal(buf,&b) 
     if err !=nil{
         panic(err) 
     }
     fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang","TypeScript"}}
 }

下面我们来看一下JSON操作，go语言里面的JSON 操作非常简单，对于一个已有的结构体，我们可以什么都不做，只要保证每个字段的第一个字母是大写，也就是是公开字段。那么这个结构体就能用JSON.marshaler去序列化，变成一个JSON的字符串。序列化之后的字符串也能够用 JSON.unmarshaler 去反序列化到一个空的变量里面。

这样默认序列化出来的字符串的话，它的风格是大写字母开头，而不是下划线。我们可以在后面用json tag 等语法来去修改输出 JSON 结果里面的字段名。

17 时间处理

 package main
 import( "fmt" "time" )
 func main(){
     now:= time.Now()
     fmt.Println(now)//2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933 
     t:=time.Date(2022,3,27,1,25,36,0, time.UTC)
     t2:= time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC) 
     fmt.Println(t)// 2022-03-27 01:25:36 +0000 UTC 
     fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
     fmt.Println(t.Format("2006-01-02 15:04:05"))// 2022-03-27 01:25:36 
     diff:=t2.Sub(t)
     fmt.Println(diff)// 1h5mOs 
     fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
     t3, err := time.Parse("2006-01-02 15:04:05","2022-03-27 01:25:36") 
     if err != nil{
         panic(err)
     }
     fmt.Println(t3==t)// true 
     fmt.Println(now.Unix()) //1648738080 
 }

下面是时间处理，在go语言里面最常用的就是 time.now() 来获取当前时间，然后你也可以用 time.date 去构造一个带时区的时间，构造完的时间。上面有很多方法来获取这个时间点的年月日小时分钟秒，然后也能用点 sub 去对两个时间进行减法，得到一个时间段。时间段又可以去得到它有多少小时，多少分钟、多少秒。在和某些系统交互的时候，我们经常会用到时间戳。那您可以用 .UNIX 来获取时间戳。 time.format time.parse

18 数字解析

 package main
 
 import(
     "fmt"
     "strconv"
 )
 
 func main(){
     f, _ := strconv.ParseFloat("1.234",64)
     fmt.Println(f) //1.234
     
     n,_ := strconv.ParseInt("111",10,64)
     fmt.Println(n) // 111
     
     n,_ := strconv.ParseInt("0x1000",0,64)
     fmt.Println(n) //4096
     
     n2,_ := strconv.Atoi("123")
     fmt.Println(n2)//123
     
     n2,err := strconv.Atoi("AAA")
     fmt.Println(n2,err)//0 strconv.Atoi:parsing "AAA":invalid syntax
 }

下面我们来学习一下字符串和数字之间的转换。在 go 语言当中，关于字符串和数字类型之间的转换都在 STR conv 这个包下，这个包是 string convert 这两个单词的缩写。我们可以用 parseInt 或者 parseFloat 来解析一个字符串。 parseint 参数我们可以用 Atoi 把一个十进制字符串转成数字。可以用 itoA 把数字转成字符串。如果输入不合法，那么这些函数都会返回error

19 进程信息

 package main
 
 import{
     "fmt"
     "os"
     "os/exec"
 }
 
 func main(){
     //go run example/20-env/main.go a b c d
     fmt.Println(os.Args)//[/var/folders/8p/n34xxfnx38dg8bv_x8162t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
     fmt.Println(os.Getenv("PATH"))// /usr/local/go/bin..
     fmt.Println(os.Setenv("AA","BB"))
     
     buf,err := exec.Command("grep","127.0.0.1","/etc/hosts").CombinedOutput()
     if err != nil{
         panic(err)
     }
     fmt.Println(string(buf)) //127.0.0.1 localhost
 }

在 go 里面，我们能够用 os.argv 来得到程序执行的时候的指定的命令行参数。比如我们编译的一个二进制文件，command。后面接 abcd 来启动，输出就是 os.argv 会是一个长度为 5 的 slice ,第一个成员代表二进制自身的名字。我们可以用 so.getenv来读取环境变量。 exec

Go基础语法 ｜ 青训营笔记