go基础语法
先下载安装go，然后到vscode下载go插件
1. 基础
输入输出
package main
import "fmt"
func main(){a:=1var b=2 var c int //不给初始值得标出变量类型 c=3var d stringfmt.Scanf("%s",&d) //接收用户输入fmt.Printf("Hello World! %d,%d,%d,%s",a,b,c,d)
}
基本类型
//整数
int int8 int16 int32 int64
uint uint uint8 uint16 uint32 uint64
uintptr
byte //uint8别名
rune //int32别名
//浮点数
float32 float64
//复数
complex64 complex128
//布尔
bool
//字符串
stringfmt.Printf("hello "+"world")//hello world
标识符
标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(AZ和az)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
注意：变量一旦声明必须使用否则编译报错，可以用_来作变量名来解决这个问题。
Go 字符串格式化符号:
| 格式化符号 | 描述 | 示例 |
|---|---|---|
| 通用格式 | ||
%v | 以默认格式输出变量 | fmt.Printf("%v", 42) |
%+v | 对结构体加字段名的方式输出 | fmt.Printf("%+v", struct{A int}{A: 42}) |
%#v | 以 Go 语法格式化输出 | fmt.Printf("%#v", map[string]int{"a": 1}) |
%T | 输出值的类型 | fmt.Printf("%T", 42) |
%% | 输出百分号 | fmt.Printf("%%") |
| 布尔值 | ||
%t | 输出 true 或 false | fmt.Printf("%t", true) |
| 整数 | ||
%b | 二进制表示 | fmt.Printf("%b", 5) |
%c | Unicode 对应字符 | fmt.Printf("%c", 65) |
%d | 十进制表示 | fmt.Printf("%d", 42) |
%o | 八进制表示 | fmt.Printf("%o", 10) |
%x | 十六进制表示（小写字母） | fmt.Printf("%x", 15) |
%X | 十六进制表示（大写字母） | fmt.Printf("%X", 15) |
%U | Unicode 格式输出 | fmt.Printf("%U", 65) |
| 浮点数 | ||
%f | 十进制浮点数 | fmt.Printf("%f", 3.14) |
%e | 科学计数法（小写 e） | fmt.Printf("%e", 3.14) |
%E | 科学计数法（大写 E） | fmt.Printf("%E", 3.14) |
%g | 自动选择 %f 或 %e 的简洁表示 | fmt.Printf("%g", 3.14) |
| 字符串与字节 | ||
%s | 普通字符串 | fmt.Printf("%s", "Go") |
%q | 带双引号的字符串或字符 | fmt.Printf("%q", "Go") |
%x | 每个字节用两字符十六进制表示 | fmt.Printf("%x", "abc") |
%X | 十六进制（大写）表示 | fmt.Printf("%X", "abc") |
| 指针 | ||
%p | 指针地址 | fmt.Printf("%p", &x) |
2. 分支，选择，循环
if…else if…else
package main
import "fmt"
func main(){var a int = 100;if a>10{//if语句还可以初始化变量，比如if b:=5;a>10{}fmt.Printf("a>10\n" );} else if a>5{fmt.Printf("a>5\n" );} else {fmt.Printf("a<5\n" );}fmt.Printf("a 的值为 : %d\n", a);
}
switch
var grade string = "B"
var marks int = 90
switch marks {case 90: grade = "A"case 80: grade = "B"case 50,60,70 : grade = "C"default: grade = "D"
}
switch {case grade == "A" :fmt.Printf("优秀!\n" ) case grade == "B", grade == "C" : //多条件匹配fmt.Printf("良好\n" ) case grade == "D" :fmt.Printf("及格\n" ) case grade == "F":fmt.Printf("不及格\n" )default:fmt.Printf("差\n" );
}
for
for i:=1;i<5;i++{fmt.Println(i)
}
numbers := [6]int{1, 2, 3, 5}
for i,x:= range numbers {fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}
3. 函数
func swap(a,b int)(int ,int){return b,a
}
func sum(a int,b int,hello666 func(int)int) int{//`func(int)int`类型参数为int类型，返回值为int类型return hello666(a)+hello666(b)
}
func main(){a,b:=1,2a,b=swap(a,b)fmt.Println(a,b)//匿名函数赋值给squaresquare:=func(x int)int{return x*x;}fmt.Println(sum(1,2,square))
}
方法：一个方法就是一个包含了接受者的函数
type Point struct{//定义一个结构体X intY int
}
func (p *Point) SetPoint(x int,y int){//该method属于Point类型对象中的方法,注意要指针引用p.X=xp.Y=y
}
func main(){var p Pointp.SetPoint(3,4)//可以通过这种方式调用方法fmt.Println(p)//{3 4}
}
4. 派生类型
派生类型
//数组,长度不可变
a:=[5]int{1,2,3,4,5}//切片Slice，长度可变
a:=make([]int,0)//创建Slice，长度为0
a=append(a,1,2,3,4)//添加元素
b:=[]int{1,2,3,4}//创建Slice并赋值
b[0]=5
fmt.Println(a,b[1:4])//[1 2 3 4] [2 3 4]
//[1,4)，区间左闭右开
s[:len(s)/2]//默认下限为 0
s[len(s)/2:]//默认上限为 len(s)//集合(映射)Map
m:=map[string]int{//指定键为string类型，值为int类型"a":1,"b":2, //不要忘了逗号
}
fmt.Println(m)m:=make(map[string]int)
m["a"]=1
m["b"]=2//语言范围range
range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素
结构体
type Point struct{X intY int
}
func main(){p:=Point{1,2}q:=pz:=&pp.X=9z.Y=6fmt.Println(p)//{9 6}fmt.Println(q)//{1 2}fmt.Println(*z)//{9 6}
}
type Point struct{X intY int
}
func (p *Point) SetPoint(x int,y int){p.X=xp.Y=y
}
func main(){var p Pointp.SetPoint(3,4)fmt.Println(p)//{3 4}
}
接口
type Shape interface{Print() //无需func关键字
}
type Rectangle struct{}
type Triangle struct{}
func(r Rectangle) Print(){fmt.Println("矩形")
}
func(r Triangle) Print(){fmt.Println("三角形")
}func printShape(s Shape){s.Print()
}
func main(){printShape(Rectangle{})//矩形printShape(Triangle{})//三角形
}
nil可以表示指针，接口，切片，映射，通道，函数的零值。
5. 错误处理
_,err:=fmt.Println("dd")//变量名_可忽略变量未使用导致的编译报错
if err != nil {fmt.Println("错误执行")
}else{fmt.Println("正常执行")
}
6. 并发
Goroutines：
- Go 中的并发执行单位，类似于轻量级的线程。
- Goroutine 的调度由 Go 运行时管理，用户无需手动分配线程。
- 使用
go关键字启动 Goroutine。 - Goroutine 是非阻塞的，可以高效地运行成千上万个 Goroutine
package main
import ("fmt""time"
)
func sayHello() {for i := 0; i < 5; i++ {fmt.Println("Hello")time.Sleep(100 * time.Millisecond)}
}
func main() {go sayHello() // 启动 Goroutinefor i := 0; i < 5; i++ {fmt.Println("Main")time.Sleep(100 * time.Millisecond)}
}
/*输出是没有固定先后顺序，因为它们是两个 goroutine 在执行,同一个程序中的所有 goroutine 共享同一个地址空间。
Main
Hello
Main
Hello
Hello
Main
Main
Hello
Hello
Main
*/
Channel：
- Go 中用于在 Goroutine 之间通信的机制。
- 支持同步和数据共享，避免了显式的锁机制。
- 使用
chan关键字创建，通过<-操作符发送和接收数据。
package main
import "fmt"func sum(s []int, c chan int) {sum := 0for _, v := range s {sum += v}c <- sum // 把 sum 发送到通道 c
}
func main() {s := []int{7, 2, 8, -9, 4, 0}c := make(chan int) //声明一个通道go sum(s[:len(s)/2], c)//默认下限为 0go sum(s[len(s)/2:], c)//默认上限为 len(s)x, y := <-c, <-c // 从通道 c 中接收fmt.Println(x, y, x+y)//-5 17 12
}
