Go语言是一门简洁、高效且现代化的编程语言，广受开发者欢迎。本文将全面介绍Go语言的基础语法和常用特性，为初学者提供一个深入的入门指南。
1. Hello, Go!
让我们从传统的"Hello, World!"程序开始：
package main
import "fmt"
func main() {
fmt.Println("Hello, Go!")
}
package main：每个Go程序都包含一个main包，它是可执行程序的入口。import "fmt"：导入fmt包，用于格式化和输出。func main()：定义程序的主函数，程序从这里开始执行。fmt.Println("Hello, Go!")：使用fmt包的Println函数输出文本。
2. 变量和数据类型
Go语言是静态类型语言，变量在声明时需要指定数据类型：
package main
import "fmt"
func main() {
var age int = 25
var name string = "Alice"
fmt.Printf("%s is %d years old.\n", name, age)
}
Go还支持类型推断：
package main
import "fmt"
func main() {
age := 25
name := "Alice"
fmt.Printf("%s is %d years old.\n", name, age)
}
3. 控制流和循环
Go语言提供了常见的控制流语句和循环结构：
package main
import "fmt"
func main() {
num := 7
if num%2 == 0 {
fmt.Println("Even")
} else {
fmt.Println("Odd")
}
for i := 0; i < 5; i++ {
fmt.Println(i)
}
fruits := []string{"apple", "banana", "cherry"}
for _, fruit := range fruits {
fmt.Println(fruit)
}
}
4. 数组、切片和映射
Go支持多种数据结构，包括数组、切片和映射：
package main
import "fmt"
func main() {
// 数组
var numbers [5]int
numbers[0] = 1
numbers[1] = 2
// 切片
primes := []int{2, 3, 5, 7, 11}
// 映射
ages := map[string]int{
"Alice": 25,
"Bob": 30,
}
fmt.Println(numbers)
fmt.Println(primes)
fmt.Println(ages)
}
5. 函数和方法
Go语言支持函数和方法的定义与调用：
package main
import "fmt"
func add(x, y int) int {
return x + y
}
type Rectangle struct {
width float64
height float64
}
func (r Rectangle) area() float64 {
return r.width * r.height
}
func main() {
sum := add(3, 5)
fmt.Println("Sum:", sum)
rect := Rectangle{width: 10, height: 5}
fmt.Println("Area:", rect.area())
}
6. 并发和Go协程
Go语言天生支持并发编程，通过Go协程可以轻松实现并发操作：
package main
import (
"fmt"
"time"
)
func printNumbers() {
for i := 0; i < 5; i++ {
fmt.Println(i)
time.Sleep(time.Millisecond * 500)
}
}
func printLetters() {
for char := 'a'; char < 'e'; char++ {
fmt.Println(string(char))
time.Sleep(time.Millisecond * 400)
}
}
func main() {
go printNumbers()
go printLetters()
time.Sleep(time.Second * 3)
}
7. 包和模块
Go语言使用包（package）来组织代码，使代码模块化和可重用：
// geometry.go
package geometry
import "math"
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
goCopy code
// main.go
package main
import (
"fmt"
"geometry"
)
func main() {
circle := geometry.Circle{Radius: 5}
fmt.Printf("Circle Area: %.2f\n", circle.Area())
}
8. 接口和多态
Go语言通过接口实现了多态性，使得不同类型的对象可以共享相同的行为：
package main
import "fmt"
type Shape interface {
Area() float64
}
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return 3.14 * c.Radius * c.Radius
}
type Rectangle struct {
Width float64
Height float64
}
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
func printArea(s Shape) {
fmt.Printf("Area: %.2f\n", s.Area())
}
func main() {
circle := Circle{Radius: 5}
rectangle := Rectangle{Width: 4, Height: 6}
printArea(circle)
printArea(rectangle)
}
9. 错误处理
Go语言中的错误处理是通过返回值来实现的，常用error类型表示错误：
package main
import (
"fmt"
"errors"
)
func divide(x, y float64) (float64, error) {
if y == 0 {
return 0, errors.New("division by zero")
}
return x / y, nil
}
func main() {
result, err := divide(10, 2)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
}
10. 并发与通道
Go语言的并发模型基于通道（channel），用于在协程之间传递数据：
package main
import (
"fmt"
"time"
)
func worker(id int, jobs <-chan int, results chan<- int) {
for job := range jobs {
fmt.Printf("Worker %d started job %d\n", id, job)
time.Sleep(time.Second)
fmt.Printf("Worker %d finished job %d\n", id, job)
results <- job * 2
}
}
func main() {
jobs := make(chan int, 5)
results := make(chan int, 5)
for i := 1; i <= 3; i++ {
jobs <- i
}
close(jobs)
for w := 1; w <= 2; w++ {
go worker(w, jobs, results)
}
for a := 1; a <= 3; a++ {
<-results
}
}
笔记覆盖了基础语法和常用特性，包括变量、控制流、数据结构、函数、方法、并发、包和模块、接口、错误处理以及并发与通道等。
