第六届字节跳动青训营后端第一课 Go的基础语法和使用｜豆包MarsCode AI 刷题什么是 Go 语言高性能、高并

什么是 Go 语言

高性能、高并发：Go语言内建了高并发的支持，而不需要第三方库来开发高并发应用
语法简单、学习曲线平缓：Go语言语法类似于C语言，但语法复杂度远比C语言小。学习曲线也远不如C/C++如此陡峭
丰富的标准库：Go语言有媲美python语言的极多优秀标准库，降低使用成本
完善的工具链：编译、代码格式化、包管理、错误检查、单元测试等，Go语言都有合适的工具来确保代码运行的稳定性。
静态链接：所有编译结果默认都是静态链接的，只需要拷贝编译后的可执行文件，就可以部署运行。
快速编译：Go语言拥有静态语言里面几乎最快的编译速度。在更改代码后能够增量编译，而不用类似C/C++的全量编译
跨平台：能够在MacOS、Linux、Windows等平台上运行，也能够开发移动端软件
垃圾回收：写代码的时候无需考虑内存分配释放，可以专注于业务逻辑

使用 Go 语言的公司

字节跳动、腾讯、美团、滴滴、微博、百度、金山、谷歌、脸书、七牛云、哔哩哔哩、平凯星辰

该语言主要涉及云计算、微服务领域，有非常高的市场占有率。几乎所有的云原生组件都是用 Go 语言实现

字节选择 Go 语言的原因

上手难度与Python近似，但在处理Web业务的性能上优于Python
C++性能高，但不适合在线Web业务
早期没有完备的Java开发经验背景
性能较高
部署简单、学习成本低
内部基于 Golang 的 RPC 和 HTTP 框架的推广

基本语法

程序主体

// 该程序属于main包的一部分，main包是程序的入口包，程序执行时会先执行main包的代码
package main
// 导入format包，fmt包是Go语言标准库中的一个包，提供了格式化输入输出的功能，包数量大于等于1时可以加小括号
import (
	"fmt"
)
//main函数
func main() {
	fmt.Println("Hello World")
}
//go run 文件名 可直接运行
//go build 文件名 编译文件生成可执行文件
//Go语言不需要加分号表示结束语句

变量声明

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)
	fmt.Println(g)
	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 变量名 = 值] 此时变量声明的类型为值的类型
//2.手动设置 [var 变量名 类型名 = 值] 此时变量名由程序员手动设置
//3.快速声明，用于在函数内声明并同时赋值某一变量，使用符号:=，无需显式添加var关键字，此种声明方法只能用于函数内部，且不能对已经声明的变量用该赋值符号
//Go语言是强类型语言，在使用前必须显式或者隐式（自动）地声明变量的类型
//如果用const关键字替换var，则意味着声明常量类型，const会自动判断类型，不需要显式指定类型

选择分支

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语句与for语句类似，表达式外无需小括号（），大括号{}不能另起一行，也不能省略大括号{}
//在同一行执行多个语句要显式地使用分号隔开

循环语句

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没有while和do...while循环。

多分支

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")
	}
}
//Go语言的switch功能强大，能够支持很多类型
//switch的参数也不需要加小括号
//case语句不需要加break中断
//可以不加入switch的参数，直接在case中对外部变量或者常量执行条件判断语句决定是否执行该分支

数组操作

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 < 2; i++ {
		for j := 0; j < 3; j++ {
			twoD[i][j] = i + j
		}
	}
	fmt.Println("2d: ", twoD)
}
//Go语言数组的声明长度是在类型声明之前的，数组的长度是数组类型的一部分，因此[3]int和[4]int是两种不同的数组类型
//可以用len函数获取数组的长度
//Go语言可以直接用Println打印整个数组而无需循环
//Go语言数组长度是固定的，正式的业务场景不常用数组，多用切片实现

切片操作

package main

import "fmt"
func main() {
	s := make([]string, 3)
	s[0] = "a"
	s[1] = "b"
	s[2] = "c"
	fmt.Println("get:", s[2])
	fmt.Println("len:", len(s))
	s = append(s, "d")
	s = append(s, "e", "f")
	fmt.Println(s)
	c := make([]string, len(s))
	copy(c, s)
	fmt.Println(c)
	fmt.Println(s[2:5])
	fmt.Println(s[:5])
	fmt.Println(s[2:])
	good := []string{"g", "o", "o", "d"}
	fmt.Println(good)
}
//make可以用于创建切片，指定切片存储类型和初始长度
//切片可以用append动态添加元素，但结果必须赋值回原数组才会更新，因为其底层机制会为了获得足够空间而改变数组指针
//切片也能用切片索引取出指定索引内的值（左闭右开），但切片索引不支持负数操作
//可以用copy复制数组

Map操作

package main
import "fmt"
func main() {
	m := make(map[string]int)
	m["one"] = 1
	m["two"] = 2
	fmt.Println(m)
	fmt.Println(len(m))
	fmt.Println(m["one"])
	fmt.Println(m["two"])
	r, oj:= m["unknown"]
	fmt.Println(r, oj)
	delete(m, "one")
	m2 := map[string]int{"one": 1, "two": 2}
	var m3 = map[string]int{"one": 1, "two": 2}
	fmt.Println(m2, m3)
}
//Go的map是无序的
//make也能创建map哈希表，格式为make(map[keyType]valueType)
//也可以直接用中括号来初始化创建map
//map的赋值操作类似C++的下标操作，map[key] = value
//当用两个变量接收map对应键的值时，如果map中不存在这个键，第二个变量会返回false，反之返回true
//delele可以删除map中的键值对

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)
		}
	}
	fmt.Println(sum)
	m := map[string]string{"a": "A", "b": "B"}
	for k, v := range m {
		fmt.Println(k, v)
	}
	for k := range m {
		fmt.Println("key:", k)
	}
}
//可以不指定长度直接用中括号初始化数组
//可以用range实现迭代功能，且用两个变量接收值，第一个变量为下标，第二个变量为值, 如果只有一个变量，则会优先接收值，也可以直接用下划线替代i忽略下标
//用两个变量接收map的元素时，第一个为key，第二个为value

函数定义

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)
	v, ok := exists(map[string]string{"a" : "A"}, "a")
	fmt.Println(v, ok)
}
//Go语言的类型声明在名称的后面，函数也是，返回类型在函数名的后面，也就是先写函数名再指定返回类型
//Go语言的函数可以一次返回多个值
//Go语言函数的参数也可以先写多个名称，然后统一指定名称的类型
//即Go语言是类型后置语言
//Go语言的函数不必声明在main函数前，可以在main函数后定义

指针操作

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)
	add2ptr(&n)
	fmt.Println(n)
}
//Golang指针用途比较有限
//主要用途是对函数外部变量的修改，也是用*号声明指针类型和解引用，以及&作为取地址符

结构体定义

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)
	fmt.Println(checkPassword(a, "haha"))
	fmt.Println(checkPassword2(&a, "haha"))
}
func checkPassword(u user, password string) bool {
	return u.password == password
}
func checkPassword2(u *user, password string) bool {
	return u.password == password
}
//结构体的定义和C语言类似，不过类型后置，而且要加type关键字
//可以显式地输入字段名定义一个结构体变量的值，
//但是不显式定义的话，输入的值和顺序要与结构体内的字段类型一致
//也可以直接使用成员运算符.来访问结构体的成员
//注意结构体指针访问成员不需要额外操作，直接使用.即可获得其值

结构体函数

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"))
}
//结构体函数类似于C/C++语言的成员函数，只不过是在函数名前加了一个括号，括号内是结构体类型的变量

错误处理

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("user not found")
}
func main() {
	u, err := findUser([]user{{"wang","1024"}}, "wang")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(u.name)
	if u, err := findUser([]user{{"wang","1024"}}, "li"); err != nil {
		fmt.Println(err)
		return
	} else {
		fmt.Println(u.name)
	}
}
//Go语言有errors包支持错误处理
//errors生成的对象类型为error，在编程中较为清晰

字符串操作

package main
import (
	"fmt"
	"strings"
)
func main() {
	a := "hello"
	fmt.Println(strings.Contains(a, "ll"))
	fmt.Println(strings.Count(a, "l"))
	fmt.Println(strings.HasPrefix(a, "he"))
	fmt.Println(strings.HasSuffix(a, "llo"))
	fmt.Println(strings.Index(a, "ll"))
	fmt.Println(strings.Join([]string{"he", "llo"}, "-"))
	fmt.Println(strings.Repeat(a, 2))
	fmt.Println(strings.Replace(a, "e", "E", -1))
	fmt.Println(strings.Split("a-b-c","-"))
	fmt.Println(strings.ToUpper(a))
	fmt.Println(strings.ToLower(a))
	fmt.Println(len(a))
	b := "你好"
	fmt.Println(len(b))
}
//导入strings包可以使用一系列字符串操作函数
//Contains用于判断字符串中是否有某个子串
//Count用于计算字符串中给定子串的数量
//HasPrefix用于判断子串是否为字符串前缀
//HasSuffix用于判断子串是否为字符串后缀
//Index返回子串在字符串的起始位置下标
//Join用于连接多个字符串
//Repeat指定次数重复字符串
//Replace用于替换指定子串，参数n为替换的数量，-1为替换全部相同的子串
//Split用于根据给定字符分割字符串为切片类型
//ToUpper表示将所有英文字符转换成大写，反之，ToLower表示转换小写

字符串格式化

package main
import "fmt"
type point struct {
	x, y int
}
func main() {
	s := "hello"
	n := 123
	p := point{1, 2}
	fmt.Println(s, n)
	fmt.Println(p)
	fmt.Printf("s=%v\n", s)
	fmt.Printf("p=%v\n", n)
	fmt.Printf("p=%v\n", p)
	fmt.Printf("p=%+v\n", p)
	fmt.Printf("p=%#v\n", p)
	f := 3.141592653
	fmt.Println(f)
	fmt.Printf("%.2f\n", f)
}
//Printf用于格式化输出，与C语言极为相似，但有一些区别。
//%v表示值的默认格式，适用于任意类型
//%+v类似%v，但输出结构体时会添加字段名
//%#v表示值的Go语法表示，会进一步详细描述值的具体类型
//%.2f表示浮点数，保留小数点后两位

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)
	fmt.Println(string(buf))

	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)
}
//处理json数据要导入encoding/json包
//只要结构体的每个字段都是大写开头，那么这个结构体就能用json.Marshal进行序列化。
//json.Marshal返回的结果是一个byte类型的切片，需要用string函数转换成字符串。
//json.MarshalIndent函数可以将序列化的结果进行缩进，方便阅读。
//json.Unmarshal函数可以将序列化的结果进行反序列化，即转换为原始格式。
//在结构体中使用`json:"新字段"`可以指定序列化后的字段名。

时间戳操作

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)                           // 1h5m0s
	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
}
//处理时间数据要导入time包
//用time.Now()获取当前时间
//用time.Date()获取指定时间
//用time.Parse()解析时间字符串
//Sub方法计算时间差
//可以用.Year()、.Month()、.Day()等方法获取时间的年、月、日等信息
//Unix()方法获取时间戳

字符转换

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)
}
//strconv用于将字符串转换为指定类型数值
//bitSize 参数可以设置解析为几位（8、16、32、64）整数或浮点数，0表示自动推导
//base 参数可以设置进制

进程操作

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方法可以获取命令行参数，返回一个字符串切片
//Getenv方法可以获取环境变量，返回一个字符串
//Setenv方法可以设置环境变量，返回一个字符串
//exec的Command方法可以执行命令，返回一个Cmd结构体

第六届字节跳动青训营后端第一课 Go的基础语法和使用｜ 豆包MarsCode AI 刷题

什么是 Go 语言

使用 Go 语言的公司

字节选择 Go 语言的原因

基本语法

程序主体

变量声明

选择分支

循环语句

多分支

数组操作

切片操作

Map操作

Range操作

函数定义

指针操作

结构体定义

结构体函数

错误处理

字符串操作

字符串格式化

JSON操作

时间戳操作

字符转换

进程操作

第六届字节跳动青训营后端第一课 Go的基础语法和使用｜豆包MarsCode AI 刷题