常用标准库 #

fmt.Print("Hello")
fmt.Println("Hello")
fmt.Printf("Hello %s\n", "World")

s := fmt.Sprintf("Hello %s", "World")
fmt.Println(s)  // Hello World

var name string
fmt.Scan(&name)
fmt.Scanf("%s", &name)

file, err := os.Open("file.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

file, err := os.Create("file.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

data, err := os.ReadFile("file.txt")
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))

err = os.WriteFile("file.txt", []byte("Hello"), 0644)
if err != nil {
    log.Fatal(err)
}

entries, err := os.ReadDir(".")
if err != nil {
    log.Fatal(err)
}
for _, entry := range entries {
    fmt.Println(entry.Name())
}

fmt.Println(os.Getenv("PATH"))
os.Setenv("MY_VAR", "value")

fmt.Println(os.Args)

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

_, err := io.Copy(dst, src)

data, err := io.ReadAll(reader)

r, w := io.Pipe()
go func() {
    w.Write([]byte("Hello"))
    w.Close()
}()
io.Copy(os.Stdout, r)

data, err := ioutil.ReadFile("file.txt")

err := ioutil.WriteFile("file.txt", []byte("Hello"), 0644)

entries, err := ioutil.ReadDir(".")

dir, err := ioutil.TempDir("", "prefix")

file, err := ioutil.TempFile("", "prefix")

reader := bufio.NewReader(os.Stdin)
line, _ := reader.ReadString('\n')
fmt.Println(line)

scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

writer := bufio.NewWriter(os.Stdout)
writer.WriteString("Hello\n")
writer.Flush()

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello %s", r.URL.Path[1:])
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

resp, err := http.Get("https://example.com")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))

resp, err := http.Post("https://example.com", "application/json", bytes.NewReader(data))

req, _ := http.NewRequest("GET", "https://example.com", nil)
req.Header.Set("Authorization", "Bearer token")

client := &http.Client{}
resp, _ := client.Do(req)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

user := User{Name: "Alice", Age: 25}
data, _ := json.Marshal(user)
fmt.Println(string(data))

var user User
json.Unmarshal([]byte(`{"name":"Alice","age":25}`), &user)
fmt.Println(user)

encoder := json.NewEncoder(os.Stdout)
encoder.Encode(user)

decoder := json.NewDecoder(resp.Body)
decoder.Decode(&user)

now := time.Now()
fmt.Println(now)

fmt.Println(now.Format("2006-01-02 15:04:05"))

t, _ := time.Parse("2006-01-02", "2024-01-01")

later := now.Add(24 * time.Hour)
diff := later.Sub(now)

timer := time.NewTimer(time.Second)
<-timer.C

ticker := time.NewTicker(time.Second)
for t := range ticker.C {
    fmt.Println(t)
}

log.Println("Hello")
log.Printf("Hello %s", "World")
log.Fatal("Fatal error")  // 退出程序
log.Panic("Panic")        // panic

logger := log.New(os.Stdout, "PREFIX: ", log.LstdFlags)
logger.Println("Hello")