go基础语法

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

标识符

标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A_Z和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
}