每天5分钟入门Go语言：高级数据结构与并发编程-优快云博客

每天5分钟入门Go语言：高级数据结构与并发编程

切片 (Slices)

切片是动态数组的抽象，允许灵活地处理序列数据。

例子：

package main

import "fmt"

func main() {
  languages := []string{"C", "Lisp", "C++", "Java", "Python", "JavaScript", "Ruby", "Go", "Rust"}
  classics := languages[:3]
  modern := languages[3:7]
  newLangs := languages[7:]
  
  fmt.Printf("Classic languages: %v\n", classics)  // Classic languages: [C Lisp C++]
  fmt.Printf("Modern languages: %v\n", modern)      // Modern languages: [Java Python JavaScript Ruby]
  fmt.Printf("New languages: %v\n", newLangs)        // New languages: [Go Rust]
}

实际应用场景：学生成绩管理

package main

import "fmt"

func main() {
  var studentScores = []float64{82.5, 90.0, 78.6, 88.4, 74.3}
  
  var passingScores []float64
  for _, score := range studentScores {
    if score >= 60.0 {
      passingScores = append(passingScores, score)
    }
  }
  
  fmt.Printf("Passing scores: %v\n", passingScores)
}

在这个应用场景中，我们使用切片来存储和处理学生的成绩，筛选出通过的成绩，并打印出来。

结构体 (Structs)

结构体是自定义数据类型，由字段组成。

例子：

package main

import "fmt"

type stack struct {
  index int
  data  [5]int
}

func (s *stack) push(k int) {
  s.data[s.index] = k
  s.index++
}

func (s *stack) pop() int {
  s.index--
  return s.data[s.index]
}

func main() {
  s := new(stack)
  s.push(23)
  s.push(14)
  fmt.Printf("stack: %v\n", *s) // stack: {2 [23 14 0 0 0]}
}

应用场景：图书库存管理

package main

import "fmt"

type Book struct {
  Title  string
  Author string
  ISBN   string
  Price  float32
}

func main() {
  var books = []Book{
    {"The Go Programming Language", "Alan A. A. Donovan", "978-0134190440", 49.99},
    {"Clean Code", "Robert C. Martin", "978-0132350884", 34.99},
  }
  
  fmt.Println("Library Books:")
  for _, book := range books {
    fmt.Printf("%s by %s, ISBN: %s, Price: %.2f\n", book.Title, book.Author, book.ISBN, book.Price)
  }
}

在这个应用场景中，我们定义了一个Book结构体来存储图书的信息，并创建了一个图书切片，打印出图书馆中的所有图书信息。

指针 (Pointers)

指针用于存储变量的内存地址。

例子：

package main

import "fmt"

func main() {
  var number int = 42
  var address *int = &number // address stores the memory address of number
  value := *address         // dereferencing the value
  
  fmt.Printf("address: %p\n", address) // address: 0xc0000140e0
  fmt.Printf("value: %d\n", value)     // value: 42
}

应用场景：内存优化的学生信息管理

package main

import "fmt"

type Student struct {
  ID      int
  Name    string
  Age     int
  Average float32
}

func main() {
  var alice = Student{ID: 1, Name: "Alice", Age: 20, Average: 88.5}
  
  fmt.Printf("Student ID: %d, Name: %s, Average: %.2f\n", alice.ID, alice.Name, alice.Average)
  
  // 使用指针传递学生信息，减少内存复制
  printStudent(&alice)
}

func printStudent(student *Student) {
  fmt.Printf("Student ID: %d, Name: %s, Average: %.2f\n", student.ID, student.Name, student.Average)
}

在这个应用场景中，我们定义了一个Student结构体来存储学生的信息，并使用指针来优化学生信息的传递，减少内存使用。

并发编程 (Concurrency)

Go的并发模型基于Goroutines和Channels。

例子：

package main

import (
  "fmt"
)

func main() {
  c := make(chan int)
  for i := 0; i < 5; i++ {
    go cookingGopher(i, c)
  }
  
  for i := 0; i < 5; i++ {
    gopherID := <-c
    fmt.Println("gopher", gopherID, "finished the dish")
  }
}

func cookingGopher(id int, c chan int) {
  fmt.Println("gopher", id, "started cooking")
  c <- id // Send a value back to main
}

应用场景：并发的网页爬虫

package main

import (
  "fmt"
  "net/http"
  "sync"
)

func main() {
  var wg sync.WaitGroup
  urls := []string{
    "http://example.com",
    "http://golang.org",
    "http://godoc.org",
  }
  
  wg.Add(len(urls))
  for _, url := range urls {
    go fetchURL(url, &wg)
  }
  
  wg.Wait()
  fmt.Println("All URLs have been fetched.")
}

func fetchURL(url string, wg *sync.WaitGroup) {
  defer wg.Done()
  resp, err := http.Get(url)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Printf("URL: %s - Status: %s\n", url, resp.Status)
  resp.Body.Close()
}