go快速入门

已于 2023-05-09 23:54:20 修改
阅读量285 收藏
点赞数
分类专栏： 云原生 文章标签： golang 开发语言 后端
于 2023-02-14 00:54:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccnuacmhdu/article/details/128998138
版权

环境搭建

  • 下载go（https://studygolang.com/dl），配置环境变量，cmd输go验证
    在这里插入图片描述

  • 下载vscode（https://code.visualstudio.com/），并移至/Applications

介绍

优势

  • 编译成机器码，不依赖其他库，直接运行即部署
  • 静态类型语言，编译期检查出隐藏的大多数问题
  • 语言层面并发，充分利用多核
  • 强大的标准库，runtime系统调度机制，高效GC，丰富的标准库
  • 简单，25个关键字，C语言简洁基因，面向对象，跨OS平台
  • 性能，编译运行速度堪比C语言

不足

  • 包管理，大部分在GitHub上
  • 无泛型
  • 无Exception，都是Error
  • 不能完全兼容C，C是可以直接写ASM且完全兼容

Hello Go

hello.go

package main

import "fmt"

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

在这里插入图片描述

VSCode方式

// go.mod文件不存在问题解决
go env -w GO111MODULE=on
go mod init hello

// 下载包超时问题，安装方式Help -> Show All Commands -> Go:Install/Update
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct

在这里插入图片描述

语法

init方法

lib.go

package lib

import "fmt"

// 小写开头，包内可访问，外包不可访问
func init() {
	fmt.Println("init...")
}

// 大写开头，包内外都可访问
func Test() {
	fmt.Println("test...")
}

在这里插入图片描述

指针

package main

import "fmt"

func swap(a *int, b *int) {
	var t int = *a
	*a = *b
	*b = t
}

func main() {
	var a, b int = 1, 2
	swap(&a, &b)
	fmt.Printf("a = %d, b = %d\n", a, b)
}

defer

defer函数在return之后调用，多个defer执行顺序是弹栈顺序
在这里插入图片描述

数组与切片

长度固定

package main

import "fmt"

// 值传递
func printArr(arr [3]int) {
	for i, v := range arr {
		fmt.Printf("arr[%d]=%d\n", i, v)
	}
	arr[0] = 100
}

func main() {
	var arr1 [2]int
	arr2 := [3]int{1}

	fmt.Printf("arr1 type=%T\n", arr1)
	for i := 0; i < len(arr1); i++ {
		fmt.Printf("arr1[%d]=%d\n", i, arr1[i])
	}

	fmt.Println("============================")

	fmt.Printf("arr2 type=%T\n", arr2)
	for i, v := range arr2 {
		fmt.Printf("arr2[%d]=%d\n", i, v)
	}

	fmt.Println("============================")

	printArr(arr2)

	fmt.Println("============================")

	for i, v := range arr2 {
		fmt.Printf("arr2[%d]=%d\n", i, v)
	}

}

在这里插入图片描述
长度不定（切片）

package main

import "fmt"

// 引用传递
func printArr(arr []int) {
	for i, v := range arr {
		fmt.Printf("arr[%d]=%d\n", i, v)
	}
	arr[0] = 100
}

func main() {
	arr := []int{1, 2, 3}
	fmt.Printf("arr type=%T\n", arr)
	printArr(arr)

	fmt.Println("============================")

	for i, v := range arr {
		fmt.Printf("arr[%d]=%d\n", i, v)
	}

}

在这里插入图片描述

package main

import "fmt"

func main() {
	var slice []int
	fmt.Printf("len = %d, slice = %v\n", len(slice), slice)
	if slice == nil {
		fmt.Println("slice is nil")
	}
	// slice[0] = 1 // 越界
	slice = make([]int, 3)
	fmt.Printf("len = %d, slice = %v\n", len(slice), slice)
}

在这里插入图片描述

package main

import "fmt"

func main() {
	var slice = make([]int, 3, 5)
	fmt.Printf("len = %d, capacity = %d, slice = %v\n", len(slice), cap(slice), slice)

	slice = append(slice, 4)
	fmt.Printf("len = %d, capacity = %d, slice = %v\n", len(slice), cap(slice), slice)

	slice = append(slice, 5)
	fmt.Printf("len = %d, capacity = %d, slice = %v\n", len(slice), cap(slice), slice)

	// 会扩容一倍
	slice = append(slice, 6)
	fmt.Printf("len = %d, capacity = %d, slice = %v\n", len(slice), cap(slice), slice)

	// slice2和slice指针地址相同，修改slice2[0]等同于修改了slice[0]
	slice2 := slice[:4]
	slice2[0] = 100
	fmt.Println(slice)

	// copy
	slice3 := make([]int, 3)
	copy(slice3, slice)
	fmt.Println(slice3)

}

在这里插入图片描述

map


package main

import (
	"fmt"
)

// 引用传递
func printMap(m map[int]string) {
	for k, v := range m {
		fmt.Printf("%d -> %s\n", k, v)
	}
}

func main() {
	fmt.Println("-------------m-------------")
	var m = map[int]string{}
	fmt.Printf("len = %d, m = %v, type = %T\n", len(m), m, m)
	m[1] = "a"
	m[2] = "b"
	fmt.Printf("len = %d, m = %v, type = %T\n", len(m), m, m)

	fmt.Println("-------------m2-------------")
	m2 := map[int]string{
		1: "aa",
		2: "bb",
		3: "cc",
	}
	printMap(m2)

	fmt.Println("-------------m3-------------")
	m3 := make(map[int]string, 6)
	m3[1] = "aaa"
	m3[2] = "bbb"
	printMap(m3)

	fmt.Println("-------------m3-------------")
	delete(m3, 1)
	printMap(m3)

}

在这里插入图片描述

struct

package main

import (
	"fmt"
)

type Student struct {
	id    int
	name  string
	score int
}

// 引用传递
func addScore(stu *Student, add int) {
	stu.score += add
}

// 值传递
func addScore0(stu Student, add int) {
	stu.score += add
}

func main() {
	fmt.Println("---------stu---------")
	var stu = &Student{
		id:    1,
		name:  "Tom",
		score: 90,
	}
	fmt.Printf("stu = %v\n", stu)
	addScore(stu, 5)
	fmt.Printf("stu = %v\n", stu)

	fmt.Println("---------stu2---------")
	var stu2 Student
	stu2.id = 2
	stu2.name = "Jack"
	stu2.score = 92
	fmt.Printf("stu2 = %v\n", stu2)
	addScore0(stu2, 5) // 值传递
	// addScore(&stu2, 5) // 引用传递

	fmt.Printf("stu2 = %v\n", stu2)
}

在这里插入图片描述

面向对象

封装

package main

import (
	"fmt"
)

type Account struct {
	id   int
	name string
}

func (ac *Account) Show() {
	fmt.Printf("[Account]{id:%d, name=%s}\n", ac.id, ac.name)
}

// 引用传递
func (ac *Account) SetName(name string) {
	ac.name = name
}

func main() {
	fmt.Println("---------Account---------")
	ac := Account{id: 999, name: "Ahha"}
	ac.Show()
	ac.SetName("ahhA")
	ac.Show()
}

在这里插入图片描述

继承

package main

import (
	"fmt"
)

type Person struct {
	id   int
	name string
}

type Student struct {
	Person
	score int
}

func (person *Person) Eat() {
	fmt.Printf("Person.Eat\n")
}

func (stu *Student) Eat() {
	fmt.Printf("Student.Eat\n")
}

func (stu *Student) Score() {
	fmt.Printf("Student.Score\n")
}

func main() {
	stu := Student{
		Person: Person{id: 999, name: "abc"},
		score:  90,
	}
	stu.Eat()
	stu.Person.Eat()
	stu.Score()
}

多态

package main

import (
	"fmt"
)

// 本身已是指针
type Animal interface {
	Sleep()
	GetKind() string
}

type Cat struct {
	kind string
}

func (cat *Cat) Sleep() {
	fmt.Println("Cat is sleeping.")
}

func (cat *Cat) GetKind() string {
	return "cat"
}

type Dog struct {
	kind string
}

func (cat *Dog) Sleep() {
	fmt.Println("Dog is sleeping.")
}

func (cat *Dog) GetKind() string {
	return "dog"
}

func show(animal Animal) {
	fmt.Printf("kind = %s\n", animal.GetKind())
	animal.Sleep()
	fmt.Println()
}

func main() {
	var animal1 Animal = &Cat{kind: "cat"}
	var animal2 Animal = &Dog{kind: "dog"}

	show(animal1)
	show(animal2)
}

interface{}

package main

import (
	"fmt"
)

// interface{}是万能类型
func IsString(arg interface{}) {
	fmt.Println("arg = ", arg)
	value, ok := arg.(string)	// 断言
	if ok {
		fmt.Println("arg is string type, value =", value)
	} else {
		fmt.Printf("arg is not string type, type = %T\n", arg)
	}
	fmt.Println()
}

func main() {
	IsString(123)
	IsString("xxx")

}

在这里插入图片描述
pair

package main

import "fmt"

func main() {
	// 任何变量都内置pair<type, value>，赋给interface{}时，类型是确定的静态类型或具体类型
	s := "123"
	var anyType interface{} = s
	if _, ok := anyType.(string); ok {
		fmt.Println("s =", s)
	}
}

反射

struct反射

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Id   int    `info:"id" doc:"unique id"`
	Name string `info:"name" doc:"user name"`
	Age  int    `info:"age"`
}

func (user User) Call() int {
	fmt.Printf("user = %v", user)
	return user.Id
}

func main() {
	user := User{Id: 1, Name: "Tom", Age: 20}

	Reflect(user)
	ReflectTags(&user)
}

func Reflect(input interface{}) {
	inputType := reflect.TypeOf(input)
	fmt.Println("input type =", inputType.Name())

	inputValue := reflect.ValueOf(input)
	fmt.Println("input value =", inputValue)

	for i := 0; i < inputType.NumField(); i++ {
		field := inputType.Field(i)
		value := inputValue.Field(i).Interface()
		fmt.Printf("%s: %s = %v\n", field.Name, field.Type, value)
	}

	for i := 0; i < inputType.NumMethod(); i++ {
		method := inputType.Method(i)
		fmt.Printf("%s: %v\n", method.Name, method.Type)
	}

}

func ReflectTags(input interface{}) {
	tags := reflect.TypeOf(input).Elem()
	for i := 0; i < tags.NumField(); i++ {
		tagInfo := tags.Field(i).Tag.Get("info")
		tagDoc := tags.Field(i).Tag.Get("doc")
		fmt.Println("tag info =", tagInfo, ", doc =", tagDoc)
	}
}

在这里插入图片描述
struct标签在json中的应用

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	Id   int    `json:"id"`
	Name string `json:"name"`
	Age  int    `json:"age"`
}

func main() {
	var err error

	user := User{Id: 1, Name: "Tom", Age: 20}

	// struct转json
	jstr, err := json.Marshal(user)
	if err != nil {
		fmt.Println("json marshal error,", err)
	} else {
		// jstr = {"id":1,"name":"Tom","age":20}
		fmt.Printf("jstr = %s\n", jstr)
	}

	user2 := User{}
	// json转struct
	err = json.Unmarshal(jstr, &user2)
	if err != nil {
		fmt.Println("json unmarshal error,", err)
	} else {
		// user = {1 Tom 20}
		fmt.Println("user =", user2)

	}
}

go routine

package main

import (
	"fmt"
	"time"
)

func main() {
	go func() {
		defer fmt.Println("A.defer")

		func() {
			defer fmt.Println("B.defer")
			// runtime.Goexit() // 退出协程
			fmt.Println("B")
		}()

		fmt.Println("A")
	}()

	for {
		fmt.Println("main")
		time.Sleep(3 * time.Second)
	}
}

channel

协程通信

  • 无缓冲，存等待对方取，取等待对方存
  • 有缓冲，缓冲队列满了存才被阻塞，缓冲队列空了取才被阻塞
// 无缓冲
package main

import (
	"fmt"
)

func main() {
	c := make(chan int)

	go func() {
		c <- 999
	}()

	num := <-c	// <-c 无空格

	fmt.Println("num =", num)
}


// 有缓冲
package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int, 3)

	go func() {
		defer fmt.Println("sub end")

		for i := 0; i < 4; i++ {
			c <- i
			fmt.Println("sub running, i =", i, ", len =", len(c), ", capacity =", cap(c))
		}
	}()

	time.Sleep(time.Second * 1)

	for i := 0; i < 4; i++ {
		num := <-c
		fmt.Println("num =", num)
		time.Sleep(time.Second * 1)
	}

	fmt.Println("main end")
}

在这里插入图片描述
关闭channel

package main

import (
	"fmt"
)

func main() {
	c := make(chan int)

	go func() {
		for i := 0; i < 3; i++ {
			c <- i
		}
		close(c) // 若不关闭，会报死锁。fatal error: all goroutines are asleep - deadlock!
	}()

	// for data := range c {
	// 	fmt.Println(data)
	// }
	
	for {
		if data, ok := <-c; ok {
			fmt.Println(data)
		} else {
			break
		}
	}

	fmt.Println("main end")
}

go module

go path 不能进行版本控制，不能指定引入的第三方库的版本，所以引入了 go mod。引入第三方包后出现 go.sum 文件，校验和保证下载包是完整的，h1:哈希值（某包里所有文件一起的哈希值），go.mod h1:哈希值（某包下 mod 文件的哈希值）。
在这里插入图片描述

在这里插入图片描述

Reference

[1] https://golang.google.cn/
[2] go语言中文网
[3] 8小时转职Golang工程师
[4] Go语言后端开发如何规划学习路线？

Only you, only you!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
区块链 go语言快速入门
08-13
区块链 go语言 快速入门 Go安装包 IDE工具 代码 区块链之Go语言快速入门 ppt
golang快速入门
qq_44798545的博客
08-24 2863
golang语法精简总结，便于有其它语言基础的快速了解golang语言。
Go语言快速入门
weixin_39540280的博客
11-10 1788
​ 一. 下载GO go安装文件以及源代码 Downloads - The Go Programming Language 下载对应平台的二进制文件以及安装 环境变量 GOROOT： go的安装目录 GOPATH： src 存放源代码 pkg 存放依赖包 bin 存放可执行文件 其他常用变量： GOOS GOARCH GOPROXY
go 快速入门
拒绝熬夜啊的博客
03-27 676
go 快速入门
go语言快速入门篇
YunxiaoYuji1的博客
03-29 380
Go语言是一种并发性高、静态类型、强类型的编程语言，它的设计目的是提高程序开发的效率和可维护性。Go语言需要明确声明变量类型，可以使用关键字var来定义变量，也可以使用:=进行简短声明。Go语言的数组和切片是非常重要的数据结构。Go语言的接口是一种能力描述，可以用来描述一个类型的方法集合。Go语言的函数可以返回多个值，而且函数也可以作为参数传递。f := 3.14 // 浮点型。b := true // 布尔型。// 访问数组和切片元素。// 使用接口实现多态。// 遍历数组和切片。// 函数返回多个值。
Go语言快速入门笔记
尧fighting的博客
11-21 437
Go语言快速入门笔记
20小时快速入门go语言视频
08-30
20小时快速入门go语言视频，总共8，9个G的样子，共八天的视频
gostudy:golang基础教程-go语言快速入门
05-07
golang基础教程-快速入门go语言 教程内容 golang语言介绍，安装部署，运行第一个程序及基础介绍，工具介绍，go module，基础语法，常用数据结构，函数介绍，指针，结构体，接口，错误处理，协程，通道，通道选择器及...
Go语言快速入门.zip
04-01
Go语言快速入门
Go-Go语言快速入门
08-13
通过简单的例子，来快速入门Go语言基础编程、语法等各种语言特性，主要面向新手级别的学习者。下面所有例子均来源于网络，看文需谨慎后果自负。
Golang基础3-函数、nil相关
m0_61973596的博客
04-23 994
1.利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。函数返回值可以无名、有名，这个是方便理解的不全代码，有名res的话本质局部变量，因此defer后会可能会影响res的返回值。使用panic抛出错误，defer捕获错误，一般panic中抛出异常，defer中捕获异常，之后正常处理。因此传入指针等等，defer函数，有无名返回值均会影响main函数中接收到的最终return的值，请注意。
go自编自导自写一片协成池
qq_43022682的博客
04-26 277
go语言自撸协成池
Golang | Leetcode Golang题解之第46题全排列
weixin_66442839的博客
04-23 487
Golang | Leetcode Golang题解之第46题全排列
Golang基础7-并发编程
m0_61973596的博客
04-25 910
Golang基础-并发编程
20个 Golang 常见面试问题
sre救赎之路
04-26 174
Golang 提供了 encoding/json 包，使用 json.Marshal 和 json.Unmarshal 函数将 Go 类型编码为 JSON，并将 JSON 解码为 Go 类型。Golang 鼓励显式地将错误作为返回值返回，并提供了如 errors.New 和 fmt.Errorf 这样的函数来创建和格式化错误。Golang 提供了同步原语，如互斥锁（mutexes）和通道（channels），用于在并发场景中安全地访问和修改共享资源。Golang 中的反射允许在运行时检查类型、值和结构体。
go语言并发实战——日志收集系统(五) 基于go-ini包读取日志收集服务的配置文件
qq_73924465的博客
04-20 598
对读取配置文件就讲到这里了。下一篇文章我们就开始探寻如何初始化Kafka和tail的服务,以及介绍什么是etcd，以及它在项目中所起到的作用,下篇见！
Golang操作Redis
最新发布
weixin_57023347的博客
04-26 452
Redis是完全开源免费的，遵循BSD协议，是一个高性能的key-value数据库。
Golang context 原理分析
元宝不吃香菜
04-20 921
valueCtx 不适合视为存储介质，存放大量的 kv 数据，它的定位类似于请求头，只适合存放少量作用域较大的全局 meta 数据： 一个 valueCtx 实例只能存一个 kv 对，因此 n 个 kv 对会嵌套 n 个 valueCtx，造成空间浪费；在下面这个案例中，子协程的任务需要 2s 才能执行完，但是父协程 1s 后任务超时，开始执行取消任务的流程，通知子协程一并取消任务的执行。本质没有区别，都是 emptyCtx，更多的是语义上的区别，background 通常作为所有 ctx 链的最顶层。
Go 之 Label 使用
Looking的博客
04-23 194
对于好多其他不支持 Label 方式的语言来说，跳出多重循环是一件比较麻烦的事情。而 Go 支持 Label 方式跳转，且支持 goto 这种逆天跳转，对于多重循环跳转更是小菜一碟。
如何快速入门golang
07-11
要快速入门Go语言（Golang），可以按照以下步骤进行： 1. 安装Go语言：首先，需要在你的计算机上安装Go语言。你可以从官方网站（https://golang.org/dl/）下载适合你操作系统的安装包，并按照安装向导进行安装。 2...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值