Go 语言基础｜青训营Go 简介优势高性能、高并发语法简单、学习路线平缓丰富标准库完善的工具链静态链接快

Go 简介

优势

高性能、高并发
语法简单、学习路线平缓
丰富标准库
完善的工具链
静态链接
快速编译
跨平台
垃圾回收

采用原因

Python 的虚拟问题
C++ 的不适合
早期非 Java 的需要
Go 性能好、部署简单、学习成本低、RPC 及 HTTP 框架推广

开发环境

安装 Golang

配置集成开发环境 IDE

基本命令

go run <file>

go build <file>

基础语法

hello world

func main() {
        fmt.Println("Hello, World!")
}

变量

可以使用 var 或者 := 符号声明变量

可以使用 const 声明常量

Go 中存在默认变量类型推断，赋予初始值的变量可以不声明其类型

var (
	num int
	str string
)

func main() {
	println(str, num)

	var b bool

	println(b)

	const n = 3

	println(n)

	var c = 'c'

	println(c)

	var s = "ssss"

	println(s)

	bb, nn, cc, ss := b, n, c, s

	println(bb, nn, cc, ss)

	var n1 int64 = 10
	var n2 = float64(n1)
	var n3 = 10e6
	println(n1, n2, n3)

	println(strconv.Atoi("1"))
	println(strconv.Itoa(1))
	println(strconv.ParseFloat("3.14", 64))
	println(strconv.FormatFloat(3.1415926, 'f', 2, 64))

	var i interface{} = "Hello, World"
	str, ok := i.(string)
	println(str, ok)
}

if-else

可以省略条件的括号

func main() {
	if 7 % 2 == 0 {
		println("7 is even")
	} else {
		println("7 is odd")
	}

	if num:= 9; num < 0 {
		println(num, "is negative")
	} else if num < 10 {
		println(num, "has 1 digit")
	} else {
		println(num, " has multiple digits")
	}
}

循环

可以省略条件的括号

func main() {
	for i := 0; i < 10; i++ {
		println(i)
	}

	i := 0
	for i < 10 {
		println(i)
		i++
	}

	for {
		println("loop")
		break
	}
	
	for n := 0; n < 5; n++ {
		if n % 2 == 1 {
			continue
		}
		println(n)
	}
}

switch

Go 中的 switch 分支表达式支持任意表达式而非仅仅是常量

func main() {
	a := 2
	
	switch a {
	case 1:
		println("one")
	case 2, 3:
		println("two or three")
	default:
		println("unknown")
	}

	switch {
	case a < 0:
		println("negative")
	case a == 0:
		println("positive")
	case a > 0:
		println("positive")
	default:
		println("unknown")
	}
}

数组

func printArray(arr [5]int) {
	for i := 0; i < len(arr); i++ {
		fmt.Printf("arr[%d] = %d\n", i, arr[i])
	}
}

func main() {
	var arr = [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr)
	println(arr[0], arr[1])
	arr[0] = 9
	println(arr)

	var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	fmt.Println(a)
	println(a[0], a[1])

	var aa = [5]int{0: 2, 4: 5}
	fmt.Println(aa)
	println(aa[0], aa[1])

	var aaa = [3][3]int{
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9},
	}
	fmt.Println(aaa)
	println(aaa[0][0], aaa[1][1], aaa[2][2])

	printArray(arr)
}

切片

func main() {
	s0 := make([]int, 10, 100)
	s1 := []int{1, 2, 3, 4, 5}

	fmt.Println(s0)
	fmt.Println(s1)

	s2 := s1[2:3]
	s3 := s1[3:]
	s4 := s1[:3]
	fmt.Println(s2)
	fmt.Println(s3)
	fmt.Println(s4)

	println(len(s0))
	println(cap(s0))

	s5 := append(s1, 10)
	fmt.Println(s5)

	copy(s0, s1)
	fmt.Println(s0)
}

map

func main() {
	m := map[string]int{
		"a": 1,
		"b": 2,
	}
	fmt.Println(m)

	mm := make(map[int]int, 10)
	fmt.Println(mm)

	println(m["a"])
	println(m["c"])

	m["b"] = 9
	fmt.Println(m)

	println(len(m))

	for k, v := range m {
		fmt.Printf("key=%s, value=%d\n", k, v)
	}

	delete(m, "a")
	fmt.Println(m)
}

range

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

var alpha = map[string]string {
	"a": "A",
	"b": "B",
}

func main() {
	for k, v := range pow {
		fmt.Printf("2^%d = %d\n", k, v)
	}

	for k, v := range alpha {
		fmt.Printf("%s : %s", k, v)
	}
}

函数

func max(n1, n2 int) int {
	var res int

	if n1 > n2 {
		res = n1
	} else {
		res = n2
	}

	return res
}

func swap(a, b string) (string, string) {
	return b, a
}

func Swap(a *int, b *int) {
	t := *a
	*a = *b
	*b = t
}

func create() func() int {
	i := 0

	next := func() int {
		i += 1
		return i
	}

	return next
}

func factorial(n uint64) uint64 {
	if n > 0 {
		return n * factorial(n-1)
	} else {
		return 1
	}
}

func fibonacci(n int) int {
	if n < 2 {
		return n
	} else {
		return fibonacci(n-1) + fibonacci(n-2)
	}
}

func main() {
	println(max(3, 4))
	println(max(5, 4))

	println(swap("1", "2"))
	a, b := 12, 23
	Swap(&a, &b)
	println(a, b)

	next := create()
	println(next())
	println(next())
	println(next())
	println(next())
	println(next())

	println(factorial(10))
	println(fibonacci(10))
}

指针

func main() {
	var ptr *int
	println(ptr)

	var n = 10
	ptr = &n
	println(ptr)
	println(*ptr)

	ptr = nil
	println(ptr)

	var arr = [3]int{1, 2, 3}
	var p [3]*int
	for i := 0; i < 3; i++ {
		p[i] = &arr[i]
		fmt.Printf("arr[%d] = %d\n", i, *p[i])
	}

	var pp **int
	println(pp)

	ptr = &n
	pp = &ptr
	println(pp)
	println(*pp)
	println(**pp)
}

结构体

代表具有一组变量集合的数据结构

type book struct {
	id    int
	title string
}

func (b book) toString() string {
	return fmt.Sprintf("id=%d title=\"%s\"", b.id, b.title)
}

func (b *book) toPrimate() error {
	return errors.New(fmt.Sprintf("[ERROR]: %d %s", b.id, b.title))
}

func main() {
	b0 := book{0, "test 0"}
	b1 := book{
		id:    1,
		title: "test 1",
	}
	b2 := book{
		title: "test 2",
	}

	fmt.Println(b0)
	fmt.Println(b1)
	fmt.Println(b2)

	fmt.Println(b0.title)
	fmt.Println(b1.title)
	fmt.Println(b2.title)

	fmt.Println(b0.toString())
	fmt.Println(b1.toString())
	fmt.Println(b2.toString())

	fmt.Println(b0.toPrimate())
	fmt.Println(b1.toPrimate())
	fmt.Println(b2.toPrimate())

	fmt.Println(getId(b0))
	fmt.Println(getTitle(&b0))
	fmt.Println(getId(b1))
	fmt.Println(getTitle(&b1))
	fmt.Println(getId(b2))
	fmt.Println(getTitle(&b2))

	p0 := &b0

	fmt.Println(&p0)
	fmt.Println(p0.title)

	fmt.Println(p0.toString())
}

func getId(book book) int {
	return book.id
}

func getTitle(book *book) string {
	return book.title
}

接口

代表具有一组方法集合的数据结构

type Base interface {
	getId() int
}

type Book struct {
	id int
}

func (b Book) getId() int {
	return b.id
}

func main() {
	var book Base = new(Book)
	println(book.getId())

	var b = book.(*Book)
	b.id = 10
	println(book.getId())
}

错误处理

func sqrt(f float64) (float64, error) {
	if f < 0 {
		return 0, errors.New("invalid param")
	} else {
		return math.Sqrt(f), nil
	}
}

func main() {
	result, error := sqrt(-1)
	println(result, error)
	
	if (error != nil) {
		println("SUCCESS")
	} else {
		println("ERROR")
	}

	res, err := sqrt(1)
	println(res, err)
	
	if (err != nil) {
		println("SUCCESS")
	} else {
		println("ERROR")
	}
}

字符串操作

func main() {
	s := "hello"

	fmt.Println(strings.Contains(s, "l"))
	fmt.Println(strings.Count(s, "l"))
	fmt.Println(strings.HasPrefix(s, "h"))
	fmt.Println(strings.HasSuffix(s, "o"))
	fmt.Println(strings.Index(s, "l"))
	fmt.Println(strings.Join([]string{"h", "e", "l", "l", "o"}, "-"))
	fmt.Println(strings.Repeat(s, 2))
	fmt.Println(strings.Replace(s, "h", "H", -1))
	fmt.Println(strings.Split("a-b-c", "-"))
	fmt.Println(strings.ToLower(s))
	fmt.Println(strings.ToUpper(s))
	fmt.Println(len(s))
}

字符串格式化

type Point struct {
	x, y int
}

func main() {
	fmt.Printf("code = %d %% %x %% %o %% %b & date = %s & value = %f \n", 123, 123, 123, 123, "2023-12-31", 12.3456789)

	str := fmt.Sprintf("code = %d %% %x %% %o %% %b & date = %s & value = %f \n", 123, 123, 123, 123, "2023-12-31", 12.3456789)
	fmt.Print(str)

	point := Point{1, 2}
	fmt.Printf("point=%v\n", point)
	fmt.Printf("point=%+v\n", point)
	fmt.Printf("point=%#v\n", point)
}

JSON处理

type User struct {
	Name string
	Age int
	Languages []string `json:"languages"`
}

func main() {
	u := User{Name: "x", Age: 6, Languages: []string{"JavaScript", "TypeSScript"}}

	buf, err := json.Marshal(u)
	if err != nil {
		panic(err)
	}
	fmt.Println(buf)
	fmt.Println(string(buf))

	var b User
	err = json.Unmarshal(buf, &b)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", b)
}

时间处理

func main() {
	now := time.Now()
	fmt.Println(now)
	fmt.Println(now.Unix())

	t := time.Date(2022, 4, 5, 23, 23, 45, 0, time.UTC)
	fmt.Println(t)
	fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())

	fmt.Println(t.Format("2012-05-06 12:45:23"))

	tt, err := time.Parse("2012-05-06 12:45:23", "2012-05-16 12:45:23")
	if err != nil {
		panic(err)
	}
	fmt.Println(tt == t)

	diff := tt.Sub(t)
	fmt.Println(diff)
	fmt.Println(diff.Hours(), diff.Minutes(), diff.Seconds())
}

Go 语言基础｜ 青训营

Go 简介

优势

采用原因

开发环境

基本命令

基础语法

变量

if-else

循环

switch

数组

切片

map

range

函数

指针

结构体

接口

错误处理

字符串操作

字符串格式化

JSON处理

时间处理

Go 语言基础｜青训营