go基础语法

先下载安装go，然后到vscode下载go插件

1. 基础

输入输出

package main
import "fmt"
func main(){
    a:=1
    var b=2 
    var c int //不给初始值得标出变量类型 
    c=3
    var d string
    fmt.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
//字符串
string
	fmt.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,2
    a,b=swap(a,b)
    fmt.Println(a,b)
    
    //匿名函数赋值给square
    square:=func(x int)int{
        return x*x;
    }
    fmt.Println(sum(1,2,square))
}

方法：一个方法就是一个包含了接受者的函数

type Point struct{//定义一个结构体
    X int
    Y int
}
func (p *Point) SetPoint(x int,y int){//该method属于Point类型对象中的方法,注意要指针引用
    p.X=x
    p.Y=y
}
func main(){
	var p Point
    p.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 int
    Y int
}
func main(){
    p:=Point{1,2}
	q:=p
	z:=&p
	p.X=9
	z.Y=6
	fmt.Println(p)//{9 6}
	fmt.Println(q)//{1 2}
	fmt.Println(*z)//{9 6}
}

type Point struct{
    X int
    Y int
}
func (p *Point) SetPoint(x int,y int){
    p.X=x
    p.Y=y
}
func main(){
	var p Point
    p.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() // 启动 Goroutine
        for 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 := 0
    for _, 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)//默认下限为 0
    go sum(s[len(s)/2:], c)//默认上限为 len(s)
    x, y := <-c, <-c // 从通道 c 中接收

    fmt.Println(x, y, x+y)//-5 17 12
}