Go语言介绍
Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。
Go文件创建
package main
import "fmt"
func main() {
fmt.Println("Hello World!")
}
-
package main定义包名，如果包名为main，其应该包含func main() {}否则不该包含。 -
import有两种用法：import "fmt"import ( "fmt" "time" )
1 基础语法
1.1 定义变量
1.1.1 var定义变量
var a int // var 定义变量
var a int = 10 // var 设置初值
var a = 10 // var 自动解析类型 (但不能解析为 int8 等)
var a, b int = 1, 2 // var 定义同类型多变量
var (
a int
s string
) // var 定义多变量
var (
a, b int = 1, 2
s, ss string
pi = 3.1415926535 // float64
)
1.1.2 := 自动变量
a := 1 // var a int = 1
s := "Hello World!" // var s string = "Hello World!"
b, ss := 2, "No Way Home."
注意：自动变量不可用于全局变量的定义。
1.1.3 匿名变量
- 匿名变量 _ 伪接受数值，数值将直接被丢弃，不可访问其数值。
- 匿名变量 _ 可以使用 = 与 :=。（其他变量重定义将出错）
func getData() (int, int) {
return 10, 20
}
func main() {
a, _ := getData() // 10, _
_, a = getData() // _, 20
}
2. 常用特性解析
2.1 控制结构（Control Structures）
- 条件语句：Go 语言的条件语句与其他语言类似，但 Go 不需要括号。
go
if x > 0 {
fmt.Println("Positive")
} else {
fmt.Println("Non-positive")
}
- 循环语句：Go 只有一个
for循环，它可以用作while、for或for-range的替代。
for i := 0; i < 10; i++ {
fmt.Println(i)
}
for-range 循环用于遍历数组、切片、字符串和映射。
for index, value := range arr {
fmt.Println(index, value)
}
2.2 数组和切片（Arrays and Slices）
- 数组：数组的大小是固定的，声明时需要指定长度。
var arr [3]int
arr[0] = 1
arr[1] = 2
arr[2] = 3
- 切片：切片是 Go 中更加灵活的数组，长度和容量是动态的。
slice := []int{1, 2, 3}
slice = append(slice, 4) // 添加元素
fmt.Println(slice) // [1, 2, 3, 4]
2.3 映射（Map）
映射类似于哈希表或字典，通过键值对存储数据。
var m = map[string]int{"apple": 5, "banana": 3}
m["pear"] = 2
fmt.Println(m) // map[apple:5 banana:3 pear:2]
2.4 结构体（Struct）
Go 中的结构体允许你将多个数据项组合成一个单一的复合数据类型。
type Person struct {
Name string
Age int
}
p := Person{"John", 30}
fmt.Println(p.Name) // John
2.5 接口（Interface）
接口定义了一组方法，但不需要实现细节。只要某个类型实现了接口中所有方法，它就隐式地实现了这个接口。
type Speaker interface {
Speak() string
}
type Dog struct{}
func (d Dog) Speak() string {
return "Woof!"
}
func say(speaker Speaker) {
fmt.Println(speaker.Speak())
}
d := Dog{}
say(d) // Woof!
2.6 并发（Concurrency）
Go 内置了对并发的支持，主要通过 Goroutine 和 Channel。
- Goroutine：使用
go关键字创建一个新的轻量级线程。
go func() {
fmt.Println("Running in a Goroutine!")
}()
- Channel：用于 Goroutine 之间的通信。
ch := make(chan int)
go func() {
ch <- 42 // 发送数据到 channel
}()
result := <-ch // 从 channel 接收数据
fmt.Println(result) // 42
2.7 错误处理（Error Handling）
Go 语言不使用异常机制，而是通过返回值来表示错误。
func divide(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf("division by zero")
}
return a / b, nil
}
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
Go 的优势
- 简洁易学：Go 语言的语法简洁，去除了许多冗余的语法特性，容易上手。
- 并发支持：Go 提供了强大的并发编程支持，能够轻松处理并发任务，适合构建高并发系统。
- 高效：Go 编译为机器码，执行速度接近 C 语言，并且具有垃圾回收功能，内存管理方便。
- 标准库丰富：Go 提供了大量标准库，支持网络编程、文件操作、加密算法等功能，能够快速开发各种应用。
- 跨平台：Go 编译后的二进制文件是平台独立的，支持 Windows、Linux、macOS 等操作系统。
总结
Go 语言是一种现代化的编程语言，提供了高效、简洁、强大的功能，特别适用于需要高并发和网络通信的场景。通过以上内容，你应该对 Go 语言的基础语法和常用特性有了初步的了解。你可以通过更多的实践和项目开发来深入掌握 Go 语言的各种特性。
