GO+WSL环境配置及基础语法｜青训营笔记这是我参与「第五届青训营」伴学笔记创作活动的第 3 天开发环境（VSc

这是我参与「第五届青训营」伴学笔记创作活动的第 3 天

开发环境（VScode+WSL2+go）

linux版：

为了方便后续开发，且自身操作系统为win10而且不想下载VM等软件，所以使用WSL2+VSCODE+Ubuntu20.04+go作为开发环境

vscode安装wsl插件

vscode扩展安装即可

wsl2的安装

安装 WSL | Microsoft Learn

注销原有子系统

vscode终端（当然也可以是powershell）

wsl --list

注销Ubuntu

wsl --unregister Ubuntu

检查，注销成功

安装新的子系统

建议手动安装，根据此链接安装选择Ubuntu20.04

安装go

建议手动下载go安装包，然后在windows下解压，我建立了Go1.18Wsl文件夹用于存放go目录和go项目目录 tar zxf go1.18.10.linux-amd64.tar.gz解压到当前文件夹并且建立goProject目录作为项目目录

设置环境变量

打开wsl终端，在/etc/profile文件下加入

export GOROOT=/mnt/d/Go1.18Wsl/go
export GOPATH=/mnt/d/Go1.18Wsl/goProject
export PATH=$PATH:$GOPATH/bin:$GOROOT/bin
export GOPROXY="https://goproxy.io"//设置代理

如果出现错误

Failed to save 'profile': Unable to write file 'vscode-remote://wsl+ubuntu-20.04/etc/profile' (NoPermissions (FileSystemError): Error: EACCES: permission denied, open '/etc/profile'

则是权限不够，sudo chown -R lee(用户名) /etc(路径) 然后source /etc/profile,当然也可以直接wsl终端中输入上述指令

基础语法

hello world

package main

import (
	"fmt"
)

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

package：代表程序所属包坐标
import{}：导入标准库
fmt：格式化输入输出库
函数：func foo(){}
编译：go build path
运行：go run path

变量定义

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 = 500000000
	const i = 3e20 / h
	fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}

go中字符串是内置类型，可以通过+运算符拼接
变量声明
- 声明方法1： var name = val；如var a = "initial"；go一般会自动推导变量类型，如果有需要也可以显式定义变量类型如var b, c int = 1, 2
- 声明方法2：name := val
常量声明
- const name = val；go会根据上下文自动确定常量类型

条件语句

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")
	}
}

不同于C/C++，if后表达式不加括号

循环

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中只有for循环
for后表达式不需要括号

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分支不需要加break
go的switch可以使用任意数据类型

数组

package main

import "fmt"

func main() {

	var a [5]int
	a[4] = 100
	fmt.Println("get:", a[2])
	fmt.Println("len:", len(a))

	b := [5]int{1, 2, 3, 4, 5}
	fmt.Println(b)

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

数组声明
- var name [num]type；如var a [5]int
- name := [num]type{val1,val2,...,valnum}；如b := [5]int{1, 2, 3, 4, 5}

切片slice

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()方法：
- 切片可以像数组一样创建，也有自己的make（）方法；name := make([]type,num)；如s := make([]string, 3)即可创建一个长度为3的字符串切片
切片增加元素-append（）方法：
- 不同于数组一旦创建就固定长度，切片可以通过append方法增加元素；slice = append（slice，val）可以给slice切片增加值为val的元素；如s := make([]string, 3)；注意append必须赋值给原数组
slice存储：

slice底层存储了slice的长度，slice的容量以及指向底层数组的指针，增加元素时容量不够会触发扩容
切片
- slice[start:end]

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(m["one"])    // 1
	fmt.Println(m["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创建-make方法
- map = make(map[keytype]valtype);如m := make(map[string]int)
delete方法
- delete(map,keyval)可以删除map中对应keyval的k-v对;如delete(m, "one")
判断map中是否存在某keyval
- r, ok := m["unknow"]

range-快速遍历slice或者map

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
		}
	}
	fmt.Println(sum) // 9

	m := map[string]string{"a": "A", "b": "B"}
	for k, v := range m {
		fmt.Println(k, v) // b 8; a A
	}
	for k := range m {
		fmt.Println("key", k) // key a; key b
	}
}

数组的返回return index,val
map返回return key,val

函数

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
}

go中函数一般返回多个值，分别是计算结果和错误信息

指针

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指针功能有限，一般只是对参数进行修改

结构体-带类型的字段的集合

package main

import "fmt"

type user struct {
	name     string
	password string
}

func main() {
	a := user{name: "wang", password: "1024"}
	b := user{"wang", "1024"}
	c := user{name: "wang"}
	c.password = "1024"
	var d user
	d.name = "wang"
	d.password = "1024"

	fmt.Println(a, b, c, d)                 // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
	fmt.Println(checkPassword(a, "haha"))   // false
	fmt.Println(checkPassword2(&a, "haha")) // false
}

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

func checkPassword2(u *user, password string) bool {
	return u.password == password
}

初始化结构体
- name := structname{seg1:val1,seg2:val2....}；如a := user{name: "wang", password: "1024"}
- 也可以不显式调用字段名：name :=structname{val1,val2}；如b := user{"wang", "1024"}
- 也可以使用.运算符初始化：name.seg1=val1；如c.password = "1024"
结构体也能作为参数

结构体方法-类似于类成员函数

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
}

func (s structname) foo(parameter type)returntype{}；此处相当于实例化了structname
两种传递方式
- 复制传递： func (u user) checkPassword(password string) bool { return u.password == password}，这里的u作为形参，函数返回后即释放
- 引用传递: func (u *user) resetPassword(password string) { u.password = password}，这里u是指向user，直接修改其值

错误处理

package main

import (
	"errors"
	"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, errors.New("not found")
}

func main() {
	u, err := findUser([]user{{"wang", "1024"}}, "wang")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(u.name) // wang

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

使用返回值处理错误

字符串操作

package main

import (
	"fmt"
	"strings"
)

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.HasSuffix(a, "llo"))              // true
	fmt.Println(strings.Index(a, "ll"))                   // 2
	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
}

字符串格式化

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 := 3.141592653
	fmt.Println(f)          // 3.141592653
	fmt.Printf("%.2f\n", f) // 3.14
}

go中使用%v打印任意变量，%+v，%#v打印更加详细的信息

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.Marshal(a)
强制类型转换string()就能打印出字符串
反序列化json.Unmarshal(buf, &b)
jsontag可以改变json中的字段名Age int `json:"age";即可把Age显示为age

进程信息

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_x8l62t_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
}

os.Args获取命令行参数
os.Getenv("PATH")获取环境变量
os.Setenv("AA", "BB")写入环境变量

GO+WSL环境配置及基础语法 ｜ 青训营笔记