2026-05-15

关闭自动补全

ctrl+Alt+s

在设置窗口中，导航到：Editor → General → Code Completion。

inline最上方关闭

strconv

用于字符串和基本数据类型之间进行相互转换

package main

import (
	"fmt"
	"strconv"
)

func main() {
	s := strconv.Itoa(123)//"123"
	n, err := strconv.Atoi("456")//456
	fmt.Println(n, err, s)
}

带初始化语句的if写法

import "fmt"

func main() {

	if score := 85; score >= 90 {
		fmt.Println("good")
	} else if score >= 60 {
		fmt.Println("bad")
	}
}

给score赋值85，然后进if判断，这个score变量作用域只在if判断内部，外界无法访问

Fields

把字符串按空白字符（空格，换行符，制表符）分割成一个字符串切片

package main

import (
	"fmt"
	"strings"
)

func main() {
	words := strings.Fields("go  is  fun")
	fmt.Println(words)
}

//[go is fun]

fmt.PrintIn打印字符串类型不加引号

要想显示引号用

1 2	fmt.Printf("%q\n", words)//["go" "is" "fun"] fmt.Printf("%#v\n", words)//[]string{"go", "is", "fun"}

%q给字符串加引号，安全转义

%#v输出值的Go语法表示

运算时必须强制类型转换

否则报错

1	invalid operation: a + b (mismatched types int and float64)

func main() {
	a := 10
	b := 3.5

	sum := float64(a) + b
	fmt.Println(sum)

	numStr := strconv.Itoa(a)

	num, err := strconv.Atoi("42")

	if err == nil {
		fmt.Printf("字符串\"%s\"转为数字\"%d\"", numStr, num)
	}

}

13.5
字符串"10"转为数字"42"
Process finished with the exit code 0

for循环与切片

import (
	"fmt"
	"strings"
)

func main() {
	sentence := "go is fun and go is powerful and go is interesting"
	words := strings.Fields(sentence)

	fmt.Printf("%q", words)

	freq := make(map[string]int)
	for _, word := range words {
		freq[word]++
	}

	fmt.Println("单词频率统计：")
	for word, count := range freq {
		fmt.Printf("%s:%d\n", word, count)
	}

	nums := []int{1, 2, 3, 4, 5}
	fmt.Println("OriginalCutPrice:", nums)
	nums = append(nums, 6)
	fmt.Println("appended:", nums)
	fmt.Println("a part of:", nums[2:4])
}

["go" "is" "fun" "and" "go" "is" "powerful" "and" "go" "is" "interesting"]单词频率统计：
is:3
fun:1
and:2
powerful:1
interesting:1
go:3
OriginalCutPrice: [1 2 3 4 5]
appended: [1 2 3 4 5 6]
a part of: [3 4]

Process finished with the exit code 0

for循环遍历切片words，每次循环返回两个值（索引和元素值）

range基本上都返回两个值

空标识符忽略索引，用word接收当前遍历到的单词

freq是一个映射或字典，键是单词，值是出现次数

freq[word]++

我不理解

函数与错误处理

1	for index , value :=range nums 会返回索引和元素值

func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, fmt.Errorf("除数不为零")

	}
	return a / b, nil
}

func sum(nums ...int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}
func makeAdder(x int) func(int) int {
	return func(y int) int {
		return x + y
	}
}

func main() {
	result, err := divide(10, 2)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("10/2 = ", result)
	}

	fmt.Println("可变参数可传多值", sum(1, 2, 3, 4))

	add5 := makeAdder(5)
	fmt.Println(add5(3))

	defer fmt.Println("最后执行")
	fmt.Println("先执行")
}

闭包

看不懂定义，我觉得闭包就是函数的返回值依旧是函数，像一个带记忆的自动机器

func counter() func() int {
	count := 0
	return func() int {
		count++
		return count
	}
}

func main() {
	c := counter()
	fmt.Println(c())
	fmt.Println(c())
}

1
2

1
2

数组，切片映射

func main() {
	var arr [3]int = [3]int{1, 2, 3}
	fmt.Println("赋值前", arr)
	arr[1] = 10
	fmt.Println("数组", arr)

	slice := []int{4, 5, 6}
	slice = append(slice, 7)
	fmt.Println("切片", slice)

	sub := slice[1:3]
	fmt.Println(sub)

	scores := map[string]int{
		"小明":     90,
		"julien": 60,
	}

	scores["xiaogang"] = 88
	fmt.Println(scores)
	delete(scores, "julien")
	fmt.Println(scores)

	for name, score := range scores {
		fmt.Printf("%s:%d\n", name, score)
	}
}

赋值前 [1 2 3]
数组 [1 10 3]
切片 [4 5 6 7]
[5 6]
map[julien:60 xiaogang:88 小明:90]
map[xiaogang:88 小明:90]
xiaogang:88
小明:90

他还会自动排个序

结构体与方法

type Rectangle struct {
	Width, Height float64
}

func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}
//指针修改原始值
func (r *Rectangle) Scale(factor float64) {
	r.Width *= factor
	r.Height *= factor

}
func main() {
	rect := Rectangle{Width: 10, Height: 5}
	fmt.Println("area:", rect.Area())

	rect.Scale(2)
	fmt.Println("缩放后宽高：", rect.Height, rect.Width)

}

接口

接口定义了一组方法签名，定义了方法名称，参数类型，返回值类型，但不包含具体实现

隐式实现意味着不需要像java一样显式声明那个接口

只要一个类型拥有接口要求的所有方法，它就自动实现了该接口。这称为鸭子类型（“如果它走路像鸭子，叫声像鸭子，那它就是鸭子”）。

type Speaker interface {
	Speak() string
}//定义一个接口speaker，要求实现一个speak（）方法

type Dog struct {
}

func (d Dog) Speak() string {
	return "wangwnag"
}

type Cat struct {
}

func (c Cat) Speak() string {
	return "miaomiao"
}

func makeSound(s Speaker) {
	fmt.Println(s.Speak())

}//函数makeSound接收一个Speaker接口类型的参数，可以传入任何实现了apeaker类型的值
//makeSound就像原本接着speaker的皮套，然后在主函数调用的时候把皮套的另一端接上cat和dog，speaker和dog好cat中间用speak() string贯通
func main() {
	dog := Dog{}
	cat := Cat{}
	makeSound(dog)//dog被自动转换为Speaker接口，输出wangwang
	makeSound(cat)

	var anything any = "hello"
	fmt.Println(anything)
	anything = 42
	fmt.Println(anything)
}

多态：一个接口变量可以持有不同类型的值

错误处理

func checkAge(age int) error {
	if age < 0 {
		return errors.New("年龄非负")
	} else if age < 18 {
		return fmt.Errorf("年龄%d太小,不能投票", age)
	}
	return nil
}
func main() {
	err := checkAge(-5)
	if err != nil {
		fmt.Println("错误：", err)
	}

	err = checkAge(16)
	if err != nil {
		fmt.Println("错误：", err)
	} else {
		fmt.Println("可以投票")
	}
}

指针

*T 表示指向 T 的指针类型

& 取地址，* 解引用

指针允许函数修改外部变量

零值为 nil

func zeroVal(Val int) {
	Val = 0
}
func zeroPtr(ptr *int) {
	*ptr = 0
}

func main() {
	x := 100
	zeroVal(x)
	fmt.Println("x=", x)

	zeroPtr(&x)
	fmt.Println("x = ", x)

	var p *int
	if p == nil {
		fmt.Println("p是空指针")
	}
}

并发

go 关键字启动一个轻量级线程（goroutine）

channel用于goroutine间通信 ch:=make(chan type)

goroutine是GO运行时管理的用户态线程，比操作系统线程轻量得多

Goroutine

func sayHello() {
	for i := 0; i < 5; i++ {
		fmt.Println("hello ")
		time.Sleep(100 * time.Millisecond)
	}
}

func main() {
	go sayHello()
	for i := 0; i < 5; i++ {
		fmt.Println("Main")
		time.Sleep(100 * time.Millisecond)
	}
	//go sayHello()
}

slice[low:high]      // 从 low 索引开始，到 high-1 索引结束，长度为 high-low
slice[low:]          // 从 low 到末尾
slice[:high]         // 从开头到 high-1
slice[:]             // 整个切片（复制引用）

func say(s string) {
	for i := 0; i < 3; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	go say("world")
	say("hello")
}

两个 say 函数几乎同时运行。go 关键字让函数在独立 goroutine 中异步执行。

channel有发送和接收操作，用于goroutine之间安全地传递数据

channel

的range只接受一个值

1 2	c chan int //c是一个能发送和接收int值的通道

1 2	make(chan int) //创建一个无缓冲的，传递int类型的通道

1 2	make(chan int,100) //通道内部有一个容量为100的队列

通道缓冲区

用于临时存储数据的一段内存空间，当缓冲区大小为0时，发送和接收必须同时就绪，否则阻塞，是同步通信

没缓冲区的发完必须马上写一个接收的动作，有缓冲区的发完一个可以再发一个，直到填满缓冲区容量，然后一次性接收

func worker(id int, jobs <-chan int, result chan<- int) { //jobs只从channel读，results只从channel写
	for job := range jobs { //不断从jobs通道接受任务
		fmt.Printf("  工人%d开始处理任务%d \n", id, job)
		time.Sleep(time.Second)
		result <- job * 2 //将结果（任务编号*2），然后发送到result通道
	}
}
func main() {
	const numJobs = 5
	jobs := make(chan int, numJobs)
	results := make(chan int, numJobs)

	for w := 1; w <= 3; w++ {
		go worker(w, jobs, results)
	}

	for j := 1; j <= numJobs; j++ {
		jobs <- j
	}
	close(jobs)

	for r := 1; r <= numJobs; r++ {
		result := <-results
		fmt.Println("  得到结果：  ", result)
	}
}

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum
}

func main() {
	s := []int{1, 3, 5, 6, 3, 5}

	c := make(chan int)

	go sum(s[:len(s)/2], c)
	go sum(s[len(s)/2:], c)

	x, y := <-c, <-c

	fmt.Println(x, y, x+y)
}

go遍历通道与关闭通道

1 2	cap(x) //返回一个数组，切片和通道的容量

func fibonacci(n int, c chan int) {
	x, y := 0, 1
	for i := 0; i < n; i++ {
		c <- x
		x, y = y, x+y
	}
	close(c)
}

func main() {
	c := make(chan int, 10)
	go fibonacci(cap(c), c)
	for i := range c {
		fmt.Println(i)
	}
}

select

用于处理多个通道操作的控制结构，每个case必须是一个通道的发送或接受操作

用于同时等待多个 channel 操作，类似于 switch 但专门用于 channel。

WaitGroup

等待·一组goroutine完成

启动5个goroutine，每个打印自己的序号，确保主函数等待所有goroutine完成

func main() {
	var wg sync.WaitGroup
	for i := 1; i <= 5; i++ {
		wg.Add(1)  //增加一个goroutine
		go func(id int) {
			defer wg.Done()  //defer延迟执行
			fmt.Printf("%d say hello \n", id)
		}(i)  //将i的当前值作为参数传入for循环里面的匿名函数
	}
	wg.Wait()
}

使用无缓冲channel实现两个goroutine交替打印1-10

func main() {
	ch := make(chan int)
	done := make(chan bool)

	go func() {
		for i := 1; i <= 10; i += 2 {
			fmt.Println("A: ", i)
			ch <- i  //将i发到ch通道里
			<-ch  //等待从ch接收一个值，此时会阻塞
		}
		done <- true
	}()

	go func() {
		for i := 1; i <= 10; i += 2 {
			<-ch  //先等待从ch接收一个值，收到后打印B
			fmt.Println("B: ", i)
			ch <- i
		}
		done <- true
	}()

//G1和G2通过无缓冲通道ch进行交替同步

	<-done
	<-done
}

1 2	x:= <-ch //接收并赋值给x <-ch //接收，没有值可付，丢弃

带缓冲channel实现简单队列

创建容量为3的缓冲channel，启动3个worker从channel中消费整数并打印，主线程发送10个数字后关闭channel

func woker(id int, jobs <-chan int, wg *sync.WaitGroup) {

	defer wg.Done() //确保函数退出时将计数器减一
	for job := range jobs { 
		fmt.Printf("Worker %d processed job %d \n", id, job)
	}
}

func main() {
	jobs := make(chan int, 3) //jobs接收缓冲容量为3的通道
	var wg sync.WaitGroup  //声明wg让线程等待所有工人线程处理完任务后退出

	for i := 1; i <= 3; i++ {
		wg.Add(1)//调用函数前先开启一个线程
		go woker(i, jobs, &wg)//函数开始工作
	}

	for j := 10; j <= 10; j++ {
		jobs <- j //主线程发送10个任务到job
	}
	close(jobs)//关闭job通道

	wg.Wait() //主线程阻塞，各worker线程开始工作，range读取job
}

使用Mutex保护共享计数器

100个goroutine同时对一个共享变量加1，每个加1000次，最终结果应为100000，用互斥锁保证正确性

func main() {
	var wg sync.WaitGroup
	var mu sync.Mutex
	var count int

	for i := 1; i <= 100; i++ {
		wg.Add(1) //1启动子线程并发进行
		go func() {
			defer wg.Done()//3子线程进行完成
			for j := 1; j <= 1000; j++ {
				mu.Lock()
				count++
				mu.Unlock()
			}
		}()
	}

	wg.Wait() //2主线程等待

	fmt.Println("Counter: ", count)
}

select实现超时控制

模拟一个可能执行很久的操作，如果2秒内未完成则输出超时

func main() {
	done := make(chan string)

	go func() {
		time.Sleep(1999 * time.Millisecond)
		done <- "finish"
	}()

	select {
	case res := <-done:
		fmt.Println("result: ", res)

	case <-time.After(2 * time.Second):
		fmt.Println("timeout")

	}
}

依然回显timeout

研究一下

原因有

线程启动延迟
Windows默认时钟精度为15ms time.Sleep(1999ms)实际可能向上取整
通道发送阻塞，finish在写入done前要res先准备好接收，所以有延迟

验证一下

代码前后打上时间戳

func main() {
	done := make(chan string)
	start := time.Now()

	go func() {
		fmt.Println("goroutin started at", time.Since(start))
		time.Sleep(1999 * time.Millisecond)
		fmt.Println("goroutin finished at:", time.Since(start))
		done <- "finish"
	}()

	select {
	case res := <-done:
		fmt.Printf("result: %s,time:%s\n", res, time.Since(start))

	case <-time.After(2 * time.Second):
		fmt.Println("timeout", time.Since(start))

	}
}

和一位，这会结果又是finish，重复几次还是finish

goroutin started at 507.8µs
goroutin finished at: 1.9998115s
result: finish,time:1.9998115s

Process finished with the exit code 0

goroutin started at 0s
goroutin finished at: 2.0001881s
result: finish,time:2.0001881s

Process finished with the exit code 0

这超过了还是判断为finish

还是太闲了

Context（控制线程的生命周期）取消线程

启动一个监控线程不断打印working。。。

主程序3秒后通过context取消

sync包

atomic包

Context

函数和方法

函数和方法居然不是同一个东西

方法是绑定了结构体的函数

制作端口扫描小工具

1 2	time.Duriation //表示两个时刻之间经过的时间

1 2	timeout time.Duriation //这个变量接收类型为time.Duriation的值，用于表示某项操作应该等待多久后超时

1	net.JoinHostPost()

可执行程序必须使用package

any

类型别名，完全等同于 interface{}。

表示可以是任何类型

defer func() { _ = recover() }()

Go 内置函数，用于捕获 panic，只在 defer 函数中有效。

// 完整示例
func DangerousFunction() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到 panic:", r)
        }
    }()
    
    panic("something went wrong")  // 触发 panic
    fmt.Println("这行不会执行")
}

func main() {
    DangerousFunction()
    fmt.Println("程序继续运行")  // 会执行
}

go学习