值得拥有的Go语言常用内置包如何使用示例

Go语言内置包 Go 语言作为一门快速、简洁的编程语言,拥有丰富的内置包,这些包覆盖了从文件处理到网络通信的各个领域。 fmt 包:格式化输入输出 os 包:操

Go语言内置包

Go 语言作为一门快速、简洁的编程语言,拥有丰富的内置包,这些包覆盖了从文件处理到网络通信的各个领域。

fmt 包:格式化输入输出

os 包:操作系统功能

net/http 包:HTTP 服务器和客户端

time 包:时间和日期操作

encoding/json 包:JSON 数据的编解码

sync 包:并发安全的同步原语

sort 包:排序切片和用户自定义排序

strconv 包:字符串和基本数据类型之间的转换

regexp 包:正则表达式

io 包:输入输出操作

math 包:数学函数和常量

strings 包:字符串操作

bufio 包:带缓冲的 I/O 操作

1. fmt 包:格式化输入输出

fmt包提供了类似 C 语言 printf 和 scanf 的格式化输入输出函数

package main
import "fmt"
func main() {
    name := "Go语言"
    fmt.Printf("Hello, %s!\n", name)
}

2. os 包:操作系统功能

os包提供了与操作系统进行交互的功能,例如文件操作、环境变量等。

package main
import (
    "fmt"
    "os"
)
func main() {
    hostname, err := os.Hostname()
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Hostname:", hostname)
    }
}

3. net/http 包:HTTP 服务器和客户端

net/http包提供了 HTTP 服务器和客户端的功能,可以用于构建 Web 应用程序。

package main
import (
    "fmt"
    "net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, Go HTTP server!")
}
func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

4. time 包:时间和日期操作

time包提供了时间和日期的操作,可以用于处理各种时间相关的任务。

package main
import (
  "fmt"
  "time"
)
func main() {
  // 获取当前时间
  now := time.Now()
  fmt.Println("Current Time:", now)
  // 格式化时间
  formattedTime := now.Format("2006-01-02 15:04:05")
  fmt.Println("Formatted Time:", formattedTime)
  // 解析时间
  timeStr := "2023-10-12 10:30:00"
  parsedTime, _ := time.Parse("2006-01-02 15:04:05", timeStr)
  fmt.Println("Parsed Time:", parsedTime)
  // 计算时间差
  duration := parsedTime.Sub(now)
  fmt.Println("Time Difference:", duration)
}

5. encoding/json 包:JSON 数据的编解码

encoding/json包提供了 JSON 数据的编码(序列化)和解码(反序列化)功能。

package main
import (
    "encoding/json"
    "fmt"
)
type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
}
func main() {
    person := Person{
        Name:  "Alice",
        Age:   30,
        Email: "alice@example.com",
    }
    // 编码为JSON
    jsonData, err := json.Marshal(person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("JSON Data:", string(jsonData))
    // 解码JSON
    var decodedPerson Person
    err = json.Unmarshal(jsonData, &decodedPerson)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Decoded Person:", decodedPerson)
}

6. sync 包:并发安全的同步原语

sync包提供了各种同步原语,用于在多个 goroutine 之间进行安全的数据共享和通信。

package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    counter := 0
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()
            counter++
            mu.Unlock()
        }()
    }
    wg.Wait()
    fmt.Println("Counter Value:", counter)
}

7. sort 包:排序切片和用户自定义排序

sort包提供了对切片进行排序的功能,同时也支持自定义排序规则。

package main
import (
    "fmt"
    "sort"
)
func main() {
    numbers := []int{4, 2, 7, 1, 9, 5}
    // 排序切片
    sort.Ints(numbers)
    fmt.Println("Sorted Numbers:", numbers)
    // 自定义排序规则
    fruits := []string{"apple", "banana", "orange", "grape"}
    sort.Slice(fruits, func(i, j int) bool {
        return len(fruits[i]) < len(fruits[j])
    })
    fmt.Println("Sorted Fruits by Length:", fruits)
}

8. strconv 包:字符串和基本数据类型之间的转换

strconv包提供了字符串和基本数据类型(例如 int、float64 等)之间的相互转换功能。

package main
import (
    "fmt"
    "strconv"
)
func main() {
    // 字符串转整数
    numStr := "123"
    num, err := strconv.Atoi(numStr)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Parsed Integer:", num)
    }
    // 整数转字符串
    num = 456
    numStr = strconv.Itoa(num)
    fmt.Println("Integer to String:", numStr)
    // 字符串转浮点数
    floatStr := "3.14"
    floatNum, err := strconv.ParseFloat(floatStr, 64)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Parsed Float:", floatNum)
    }
    // 布尔值转字符串
    boolValue := true
    boolStr := strconv.FormatBool(boolValue)
    fmt.Println("Boolean to String:", boolStr)
}

9. regexp 包:正则表达式

regexp包提供了正则表达式的功能,可以用于字符串的匹配和替换。

package main
import (
    "fmt"
    "regexp"
)
func main() {
    text := "Hello, 12345 and 67890"
    pattern := "[0-9]+"
    re := regexp.MustCompile(pattern)
    matches := re.FindAllString(text, -1)
    fmt.Println("Matches:", matches)
}

10. io 包:输入输出操作

io包提供了基本的输入输出接口和函数,用于处理各种输入输出操作,包括文件、网络、内存等。

package main
import (
    "fmt"
    "io/ioutil"
    "os"
    "strings"
)
func main() {
    // 写入文件
    data := []byte("Hello, Go IO!")
    err := ioutil.WriteFile("output.txt", data, 0644)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    // 读取文件
    fileContent, err := ioutil.ReadFile("output.txt")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("File Content:", string(fileContent))
    // 字符串读写
    r := strings.NewReader("Hello, Go IO!")
    content, err := ioutil.ReadAll(r)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Read String:", string(content))
    // 标准输入输出
    fmt.Print("Enter your name: ")
    var name string
    fmt.Scanln(&name)
    fmt.Println("Hello,", name)
}

11. math 包:数学函数和常量

math包提供了各种数学函数和常量,包括三角函数、对数函数、常见常量等。

package main
import (
    "fmt"
    "math"
)
func main() {
    // 计算正弦值
    angle := math.Pi / 4
    sinValue := math.Sin(angle)
    fmt.Println("Sin(π/4):", sinValue)
    // 计算自然对数
    x := 2.0
    logValue := math.Log(x)
    fmt.Println("ln(2):", logValue)
    // 圆周率和平方根
    fmt.Println("π:", math.Pi)
    fmt.Println("√2:", math.Sqrt(2))
}

12. strings 包:字符串操作

strings 包提供了对字符串的各种操作,包括拼接、切割、替换、查找等。

package main
import (
    "fmt"
    "strings"
)
func main() {
    // 字符串拼接
    str1 := "Hello"
    str2 := "Go"
    result := strings.Join([]string{str1, str2}, " ")
    fmt.Println("Joined String:", result)
    // 字符串切割
    sentence := "Hello, Go Language"
    words := strings.Split(sentence, " ")
    fmt.Println("Words:", words)
    // 字符串替换
    text := "Hello, World!"
    newText := strings.Replace(text, "World", "Go", -1)
    fmt.Println("Replaced Text:", newText)
    // 字符串查找
    contains := strings.Contains(text, "Go")
    fmt.Println("Contains 'Go':", contains)
}

13. bufio 包:带缓冲的 I/O 操作

bufio 包提供了带缓冲的 I/O 操作,可以提高读写文件的效率。

package main
import (
    "bufio"
    "fmt"
    "os"
)
func main() {
    // 写入文件
    file, err := os.Create("output.txt")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer file.Close()
    writer := bufio.NewWriter(file)
    writer.WriteString("Hello, bufio!")
    writer.Flush()
    // 读取文件
    reader := bufio.NewReader(file)
    content, _ := reader.ReadString('\n')
    fmt.Println("Read from File:", content)
}

以上就是值得拥有的Go语言常用内置包使用示例的详细内容,更多关于Go语言内置包的资料请关注好代码网其它相关文章!

标签: Go 内置包