Go语言基础语法

一、创建工程

说明：
（1）go.mod文件是go项目依赖管理文件，相当于前端的package.json，也就是Java项目中的Maven的pom.xml。

二、打印数据到控制台

（1）引入fmt
（2）使用fmt.Sprintf，参数为打印的变量（非必须）
（3）用Println()打印
例如：

package mainimport(
"fmt"
)func main(){
//%d表示整型数字，%s表示字符串
var stockcode=123
var enddate="2020-12-31"
var url="Code=%d&endDate=%s"
var target_url=fmt.Sprintf(url,stockcode,enddate)
fmt.Println(target_url)//输出结果为"Code=123&endDate=2020-12-31"
}

Go字符串格式化符号：
%v ：按值的本来值输出
%+v：在%v的基础上，对结构体字段名和值进行展开
%#v：输出Go语言语法格式的值
%T：输出Go语言语法格式的类型和值
%%：输出%本体
%b：类型以二进制方式显示
%o：类型以八进制的方式显示
%d：类型以十进制的方式显示
%x：类型以十六进制的方式显示
%X：整数以十六进制、字母大写方式显示
%U：Unicode字符
%f：浮点数
%p：指针，十六进制方式显示

三、Go语言的变量

3.1 变量类型

3.1.1 基本类型

整型：int8、int16、int32、int64、uint8、uint16、uint32、uint64
浮点型：float32、float64
复数型：complex64、complex128
其他常用数字类型：byte(uint8)、int[32|64]、
字节类型：rune(int32)，类似与其他语言里的char，可以表示任何Unicode字符，包括ASCII字符、中文字符、特殊符号等
字符串型：string（默认值为""）
布尔型：bool，值为true或false（默认值为false）

3.1.2 派生类型

指针：

var a=10;var b *int = & a;

数组和切片：
定义数组：

var arr [2]int = [2]int{2, 3, 4}

定义切片：var sli []int = []int{}（定义了一个变量sli，类型为切片slice的整型切片）
映射（字典）：map
例如：

var a map[String]int//声明了一个变量a，类型为map，键类型为字符串，值类型为整型

结构体：

type User struct {Id intUsername stringAge byte}var user Useruser.Id = 20

3.2 变量声明

3.2.1 完整声明

Go语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
声明变量的一般形式是使用var关键字。
语法：
var <变量名> <类型>;
可以一次声明多个变量：
var <变量名1>,<变量名2> <类型>;
例如：

var a string = "ABC"
var b,c int = 1, 2

注意：如果没有初始化，则变量默认值为零。

3.2.2 根据值自动判定变量类型

var d = true

上述例子的var有些多余，可以用赋值操作符：来简写，称之为“初始化声明”：

b := true

注意：初始化声明只能被用在函数体内，而不可以用于全局变量的声明和赋值。

3.3 Go语言常量

使用关键字const替代var，常量的数据类型只能是基本类型，可以省略数据类型。

const b string="abc"
const b = "abc"

3.4 关键字go

go关键字用来启动一个新的goroutine。

package mainimport ("fmt""time"
)func hello() {fmt.Println("Hello world goroutine")
}func main() {go hello() // 启动新的 Goroutinefmt.Println("Hello main goroutine")time.Sleep(1 * time.Second) // 等待新的 Goroutine 执行完成
}

执行结果如下：

3.5 Go的通道chan

在 Go 语言中，chan 关键字用于创建通道（channel），通道是一种用于在 goroutine 之间进行通信的类型化管道。通过通道，你可以在不同的 goroutine 之间安全地传递数据。
（1）使用make函数来创建通道
通道的类型由其传递的数据类型决定。
（2）发送和接受数据
发送数据：通道 <- 值
接收数据：值 := <-通道
例如：

ch := make(chan int)  // 在一个 goroutine 中发送数据  
go func() {  ch <- 42  
}()  // 在主 goroutine 中接收数据  
value := <-ch  
fmt.Println(value) // 输出: 42

（3）带缓冲的通道
默认情况下，通道是无缓冲的，这意味着发送操作会阻塞，直到另一方准备好接收数据。你可以通过提供一个缓冲区大小来创建一个带缓冲的通道。
例如：

ch := make(chan int, 2) // 创建一个带缓冲区的通道，可以存储 2 个整数

带缓冲的通道在缓冲区未满时不会阻塞发送操作，在缓冲区为空时不会阻塞接收操作。
（4）关闭通道
你可以使用 close 函数来关闭一个通道。关闭通道后，无法再向通道发送数据，但可以继续从通道接收数据，直到通道为空。
例如：

ch := make(chan int)  go func() {  ch <- 42  close(ch)  
}()  value, ok := <-ch  
if ok {  fmt.Println(value) // 输出: 42  
} else {  fmt.Println("通道已关闭")  
}

3.6 range关键字

在 Go 语言中，range 关键字具有多重用途，主要用于遍历数组、切片（slice）、映射（map）、字符串以及通道（channel）。下面分别介绍这些用法：

遍历数组和切片
对于数组和切片，range 会返回两个值：索引和对应位置的元素值。

numbers := []int{1, 2, 3, 4, 5}  
for index, value := range numbers {  fmt.Println(index, value)  
}

在上面的例子中，index 是元素的索引，而 value 是对应索引的元素值。

遍历映射
对于映射，range 会返回两个值：键和对应的值。

scores := map[string]int{"Alice": 90, "Bob": 85}  
for key, value := range scores {  fmt.Println(key, value)  
}

在这个例子中，key 是映射的键，而 value 是与键关联的值。

遍历字符串
对于字符串，range 会返回两个值：字符的索引（字节位置）和对应的 Unicode 码点（rune）。

str := "Hello, 世界"  
for index, runeValue := range str {  fmt.Printf("%#U starts at byte position %d\n", runeValue, index)  
}

注意，对于非 ASCII 字符（如中文），一个字符可能会占用多个字节。因此，这里的索引是指字节在字符串中的位置，而不是字符在字符串中的位置（对于多字节字符，后者可能更有用，但 Go 的 range 在字符串上不提供这种索引）。

遍历通道
对于通道，range 会持续地从通道中接收数据，直到通道被关闭。

ch := make(chan int)  
go func() {  for i := 0; i < 5; i++ {  ch <- i  }  close(ch)  
}()  for value := range ch {  fmt.Println(value)  
}

在这个例子中，range 会阻塞，直到从通道 ch 中接收到数据。当通道被关闭且没有更多数据可读时，range 循环会结束。

注意事项
当使用 range 遍历映射时，遍历的顺序是随机的，每次运行程序时可能会得到不同的顺序。
在遍历数组、切片或字符串时，如果你只需要索引或值中的一个，可以使用下划线 _ 来忽略另一个。
在遍历通道时，确保通道最终会被关闭，否则 range 循环将永远阻塞。

• range 在内部使用了值拷贝，因此遍历过程中修改元素的值（对于数组和切片）不会影响原始数组或切片。然而，如果你传递的是一个指向元素的指针（例如，切片中的元素是指针类型），则可以通过指针修改原始数据。

3.7 Go语言select语句

select 语句允许你在多个通道操作上进行等待。select 会阻塞，直到其中一个 case 可以运行。如果有多个 case 都准备好了，select 会随机选择一个执行。如果所有的通道都没有准备好，就会执行default块中的代码。

ch1 := make(chan string)  
ch2 := make(chan string)  go func() {  ch1 <- "来自 ch1 的消息"  
}()  go func() {  ch2 <- "来自 ch2 的消息"  
}()  for i := 0; i < 2; i++ {  select {  case msg1 := <-ch1:  fmt.Println("收到:", msg1)  case msg2 := <-ch2:  fmt.Println("收到:", msg2)  default://代码}  
}

执行结果;

四、Go语言的特点

（1）并发支持
内置轻量级的并发机制，称为goroutine,可以通过goroutine和通道，方便地编写并发程序。
（2）高性能
通过优化编译器和运行时环境，以及并发机制地支持，提供了出色地性能。
（3）内存安全
具有内置地垃圾回收机制，避免了常见的内存错误。
（4）跨平台
编译器可以将Go代码编译为机器码，支持多种操作系统和体系结构。
（5）丰富的标准库
涵盖了网络编程、文件操作、加密解密并发编程等各个方面。