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语言内置包的资料请关注好代码网其它相关文章！
