func Print(a ...interface{}) (n int, err error) 
func Printf(format string, a ...interface{}) (n int, err error) 
func Println(a ...interface{}) (n int, err error)

func main() { 
    fmt.Print("Hello, ", "world") 
    name := "Alice" 
    age := 30 
    fmt.Printf("Hello, %s. You are %d years old.\n", name, age) 
    fmt.Println("Hello, world") 
    }

func Fprint(w io.Writer, a ...interface{}) (n int, err error) 
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) 
func Fprintln(w io.Writer, a ...interface{}) (n int, err error)

func main() { 
    // 向标准输出写入内容 
    fmt.Fprintln(os.Stdout, "向标准输出写入内容") 
    fileObj, err := os.OpenFile("./output.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644) 
    if err != nil { 
        fmt.Println("打开文件出错，err:", err) 
        return 
        } 
        name := "jarvis" // 向打开的文件句柄中写入内容 
        fmt.Fprintf(fileObj, "往文件中写如信息：%s", name) 
        }

func Sprint(a ...interface{}) string 
func Sprintf(format string, a ...interface{}) string 
func Sprintln(a ...interface{}) string

func main() { 
    s1 := fmt.Sprint("jarvis") 
    name := "jarvis" 
    age := 18 
    s2 := fmt.Sprintf("name:%s,age:%d", name, age) 
    s3 := fmt.Sprintln("jarvis") 
    fmt.Println(s1, s2, s3) 
    }

func Errorf(format string, a ...interface{}) error

err := fmt.Errorf("这是一个错误")

func main() { 
    fmt.Printf("%v\n", 100) 
    fmt.Printf("%v\n", false) 
    o := struct{ name string }{"jarvis"} 
    fmt.Printf("%v\n", o) 
    fmt.Printf("%#v\n", o) 
    fmt.Printf("%T\n", o) 
    fmt.Printf("100%%\n") }

n := 65 
fmt.Printf("%b\n", n) 
fmt.Printf("%c\n", n) 
fmt.Printf("%d\n", n) 
fmt.Printf("%o\n", n) 
fmt.Printf("%x\n", n) 
fmt.Printf("%X\n", n)

f := 12.34 
fmt.Printf("%b\n", f) 
fmt.Printf("%e\n", f) 
fmt.Printf("%E\n", f) 
fmt.Printf("%f\n", f) 
fmt.Printf("%g\n", f) 
fmt.Printf("%G\n", f)

s := "jarvis" 
fmt.Printf("%s\n", s) 
fmt.Printf("%q\n", s) 
fmt.Printf("%x\n", s) 
fmt.Printf("%X\n", s)

a := 18 
fmt.Printf("%p\n", &a) 
fmt.Printf("%#p\n", &a)

n := 88.88 
fmt.Printf("%f\n", n) 
fmt.Printf("%9f\n", n) 
fmt.Printf("%.2f\n", n) 
fmt.Printf("%9.2f\n", n) 
fmt.Printf("%9.f\n", n)

 s := 123
 fmt.Printf("8%d8\n", s)
 fmt.Printf("8%5d8\n", s)
 fmt.Printf("8%-5d8\n", s)
 fmt.Printf("8%5.4d8\n", s)
 fmt.Printf("8%05d8\n", s)
 fmt.Printf("8%+d8\n", -s)

 s1 := 123.45
 fmt.Printf("8%f8\n", s1)
 fmt.Printf("8%.2f8\n", s1)
 fmt.Printf("8%15f8\n", s1)
 fmt.Printf("8%15.2f8\n", s1)
 fmt.Printf("8%015.2f8\n", s1)

 

 s2 := "abc"
 fmt.Printf("8%08s8\n", s2)
 fmt.Printf("8% x8\n", s2)

func Scan(a ...interface{}) (n int, err error)

package main
import "fmt"
func main() { 
    var name string 
    var age int
    fmt.Print("Enter your name: ") 
    fmt.Scan(&name) 
    fmt.Print("Enter your age: ") 
    fmt.Scan(&age)
    fmt.Printf("Name: %s, Age: %d\n", name, age) 
    }

func Scanln(a ...interface{}) (n int, err error)

func Scanf(format string, a ...interface{}) (n int, err error)

package main
import "fmt"
func main() { 
    var name string 
    var age int
    fmt.Print("Enter your name and age: ") 
    fmt.Scanf("%s %d", &name, &age)
    fmt.Printf("Name: %s, Age: %d\n", name, age) }

func bufioDemo() { 
    reader := bufio.NewReader(os.Stdin) // 从标准输入生成读对象 
    fmt.Print("请输入内容：") 
    text, _ := reader.ReadString('\n') // 读取直到换行符 
    text = strings.TrimSpace(text) 
    fmt.Printf("%#v\n", text) 
    }

func Fscan(r io.Reader, a ...interface{}) (n int, err error) 
func Fscanln(r io.Reader, a ...interface{}) (n int, err error)
func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)

package main
import ( "fmt" "strings" )
func main() { 
    input := "42 John" 
    reader := strings.NewReader(input) // 从字符串生成读对象
    var age int 
    var name string
    n, err := fmt.Fscanf(reader, "%d %s", &age, &name) 
    if err != nil { 
        fmt.Println("Error:", err) 
        return 
        }
    fmt.Printf("Read %d values: Age: %d, Name: %s\n", n, age, name) 
    }

func Sscan(str string, a ...interface{}) (n int, err error) 
func Sscanln(str string, a ...interface{}) (n int, err error)
func Sscanf(str string, format string, a ...interface{}) (n int, err error)

package main
import ( "fmt" )
func main() { 
    input := "Alice 30" 
    var name string 
    var age int
    n, err := fmt.Sscanf(input, "%s %d", &name, &age) 
    if err != nil { 
        fmt.Println("Error:", err) 
        return 
        }
    fmt.Printf("Read %d values: Name: %s, Age: %d\n", n, name, age) }

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

package main

import (
 "fmt"
 "io"
 "os"
)

func main() {
 f, err := os.Open("test.txt")
 if err != nil {
  panic(err)
 }
 defer f.Close()
 buf := make([]byte, 4) // 实例化一个长度为4的[]byte
 i := 0
 for {
  i++
  n, err := f.Read(buf)
  fmt.Printf("第 %d 次读取, ", i)
  fmt.Printf("返回行数：%d，error 信息：%v ", n, err)
  if n == 0 || err == io.EOF {
   fmt.Println("文件以读取完毕")
   break
  }
  fmt.Printf("读取内容：%s \n", string(buf[:n]))
 }
}

第 1 次读取, 返回行数：4，error 信息：<nil> 读取内容：ludu 
第 2 次读取, 返回行数：4，error 信息：<nil> 读取内容：oe

第 3 次读取, 返回行数：3，error 信息：<nil> 读取内容：qwe
第 3 次读取, 返回行数：0，error 信息：EOF 文件以读取完毕

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

package main 
import ( 
    "fmt" 
    "os" 
) 
func main() { 
    file, err := os.Create("file.txt") 
    if err != nil { 
        panic(err) 
        } 
        defer file.Close() 
        data := []byte("luduoxin's blog") 
        n, err := file.Write(data) 
        if err != nil { 
            panic(err) 
        } 
        fmt.Printf("%d bytes written", n) 
        }

type Closer interface { Close() error }

import ( 
    "os" 
) 
func main() { 
    file, err := os.Create("file.txt") 
    if err != nil { 
        panic(err) 
    } // 在文件使用结束后，需要调用 Close 方法释放资源。 
    defer file.Close() // 文件读写操作... 
    }

type Seeker interface { Seek(offset int64, whence int) (int64, error) }

package main 
import ( 
    "fmt" 
    "io" 
    "os" 
) 
func main() { 
    file, err := os.Create("file.txt") 
    if err != nil { 
        panic(err) 
        } 
    defer file.Close() // 写入数据到文件中... 
    file.Write([]byte("hello world")) // 将文件指针移动到文件头 
    file.Seek(0, io.SeekStart) // 从文件中读取数据到切片中 
    buf := make([]byte, 5) 
    file.Read(buf) 
    fmt.Println(string(buf)) // 输出 hello // 将文件指针移动文件末尾 
    file.Seek(0, io.SeekEnd) // 在文件末尾进行写入操作 
    file.Write([]byte("golang")) }

func (rw *RWMutex) RLock() //读锁，当有写锁时，无法加载读锁，当只有读锁或者没有锁时，可以加载读锁，读锁可以加载多个，所以适用于“读多写少”的场景。
func (rw *RWMutex) RUnlock() //读锁解锁，RUnlock 撤销单次RLock调用，它对于其它同时存在的读取器则没有效果。若rw并没有为读取而锁定，调用RUnlock就会引发一个运行时错误。

func (rw *RWMutex) Lock() //写锁，如果在添加写锁之前已经有其他的读锁和写锁，则Lock就会阻塞直到该锁可用，为确保该锁最终可用，已阻塞的Lock调用会从获得的锁中排除新的读取锁，即写锁权限高于读锁，有写锁时优先进行写锁定。
func (rw *RWMutex) Unlock() //写锁解锁，如果没有进行写锁定，则就会引起一个运行时错误。

package main

import (
 "fmt"
 "sync"
 "time"
)

var rwMutex *sync.RWMutex
var wg *sync.WaitGroup

func main() {
 rwMutex = new(sync.RWMutex)
 wg = new(sync.WaitGroup)

 //wg.Add(2)

 //多个同时读取
 // go readData(1)
 // go readData(2)

 wg.Add(3)
 go writeData(1)
 go readData(2)
 go writeData(3)

 wg.Wait()
 fmt.Println("main..over...")
}

func writeData(i int) {
 defer wg.Done()
 fmt.Println(i, "开始写：write start。。")
 rwMutex.Lock() //写操作上锁
 fmt.Println(i, "正在写：writing。。。。")
 time.Sleep(3 * time.Second)
 rwMutex.Unlock()
 fmt.Println(i, "写结束：write over。。")
}

func readData(i int) {
 defer wg.Done()

 fmt.Println(i, "开始读：read start。。")

 rwMutex.RLock() //读操作上锁
 fmt.Println(i, "正在读取数据：reading。。。")
 time.Sleep(3 * time.Second)
 rwMutex.RUnlock() //读操作解锁
 fmt.Println(i, "读结束：read over。。。")
}

func (m *Mutex) Lock()
func (m *Mutex) Unlock()

wg := &sync.WaitGroup{}

for i := 0; i < 8; i++ {
  wg.Add(1)
  go func() {
    // Do something
    wg.Done()
  }()
}

wg.Wait()

//func (o *Once) Do(f func())
once := &sync.Once{}
for i := 0; i < 4; i++ {
    i := i
    go func() {
        once.Do(func() {
            fmt.Printf("first %d\n", i)
        })
    }()
}

Get() interface{} //用来从并发池中取出元素。
Put(interface{}) //将一个对象加入并发池。

pool := &sync.Pool{
  New: func() interface{} {
    return NewConnection()
  },
}

connection := pool.Get().(*Connection)

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

// 用来统计实例真正创建的次数
var numCalcsCreated int32

// 创建实例的函数
func createBuffer() interface{} {
    // 这里要注意下，非常重要的一点。这里必须使用原子加，不然有并发问题；
    atomic.AddInt32(&numCalcsCreated, 1)
    buffer := make([]byte, 1024)
    return &buffer
}

func main() {
    // 创建实例
    bufferPool := &sync.Pool{
        New: createBuffer,
    }

    // 多 goroutine 并发测试
    numWorkers := 1024 * 1024
    var wg sync.WaitGroup
    wg.Add(numWorkers)

    for i := 0; i < numWorkers; i++ {
        go func() {
            defer wg.Done()
            // 申请一个 buffer 实例
            buffer := bufferPool.Get()
            //buffer := createBuffer()
            _ = buffer.(*[]byte)
            // 释放一个 buffer 实例
            defer bufferPool.Put(buffer)
        }()
    }
    wg.Wait()
    fmt.Printf("%d buffer objects were created.\n", numCalcsCreated)
}

// 这些示例演示了 flag 包的更复杂用法。
package main

import (
 "errors"
 "flag"
 "fmt"
 "strings"
 "time"
)

// 示例 1: 一个名为 "species" 的单个字符串标志，默认值为 "gopher"。
var species = flag.String("species", "gopher", "我们正在研究的物种")

// 示例 2: 两个共享变量的标志，以便我们可以有一个简写。
// 初始化顺序是未定义的，因此确保两者使用相同的默认值。它们必须使用 init 函数进行设置。
var gopherType string

func init() {
 const (
  defaultGopher = "pocket"
  usage         = "gopher 的种类"
 )
 flag.StringVar(&gopherType, "gopher_type", defaultGopher, usage)
 flag.StringVar(&gopherType, "g", defaultGopher, usage+" (简写)")
}

// 示例 3: 用户自定义的标志类型，一个持续时间切片。
type interval []time.Duration

// String 是 flag.Value 接口的方法，用于格式化标志的值。
// String 方法的输出将用于诊断。
func (i *interval) String() string {
 return fmt.Sprint(*i)
}

// Set 是 flag.Value 接口的方法，用于设置标志的值。
// Set 方法的参数是一个要解析以设置标志的字符串。
// 它是一个逗号分隔的列表，因此我们将其拆分。
func (i *interval) Set(value string) error {
 // 如果我们想允许标志被设置多次，以累积值，
 // 我们将删除这个 if 语句。
 // 那样就允许使用例如
 // -deltaT 10s -deltaT 15s
 // 和其他组合。
 if len(*i) > 0 {
  return errors.New("间隔标志已设置")
 }
 for _, dt := range strings.Split(value, ",") {
  duration, err := time.ParseDuration(dt)
  if err != nil {
   return err
  }
  *i = append(*i, duration)
 }
 return nil
}

// 定义一个累积持续时间的标志。由于它有一个特殊类型，
// 我们需要使用 Var 函数，因此在初始化期间创建标志。
var intervalFlag interval

func init() {
 // 将命令行标志与 intervalFlag 变量关联起来，并设置一个用法消息。
 flag.Var(&intervalFlag, "deltaT", "使用事件之间的间隔的逗号分隔列表")
}

func main() {
 // 上面声明的所有有趣的部分都在上面声明的变量中，
 // 但要使 flag 包看到那些定义的标志，
 // 通常在 main 的开头（不是 init！）调用:
 flag.Parse()
 //测试命令：
 //go run main.go --species cat -gopher_type groundhog --deltaT 10s,20s,30s
}

{
    "users": [
      {
        "name": "Aric",
        "age": 27,
        "social": {
          "zhihu": "https://zhihu.com",
          "weibo": "https://weibo.com"
        }
      },
      {
        "name": "gloria",
        "age": 22,
        "social": {
          "zhihu": "https://zhihu.com",
          "weibo": "https://weibo.com"
        }
      }
    ]
  }

type AutoGenerated struct {
 Users []struct {
  Name   string `json:"name"`
  Age    int    `json:"age"`
  Social struct {
   Zhihu string `json:"zhihu"`
   Weibo string `json:"weibo"`
  } `json:"social"`
 } `json:"users"`
}

type Users struct {
    Users []User
}
type User struct {
  Name   string `json:"name"`
  Age    int    `json:"age"`
  Social Social `json:"social"`
 }
type Social struct{
 Zhihu string `json:"zhihu"`
 Weibo string `json:"weibo"`

}

package main

import (
 "encoding/json"
 "fmt"
 "io/ioutil"
 "os"
 "strconv"
)

type Users struct {
    Users []User
}
type User struct {
  Name   string `json:"name"`
  Age    int    `json:"age"`
  Social Social `json:"social"`
 }
type Social struct{
 Zhihu string `json:"zhihu"`
 Weibo string `json:"weibo"`

}

func main() {
 jsonFile, err := os.Open("user.json")
 if err != nil {
   fmt.Println(err)
 }
 fmt.Println("Successfully Opened users.json")
 defer jsonFile.Close()

 byteValue, err := ioutil.ReadAll(jsonFile)
 if err != nil {
  fmt.Println("Error reading file:", err)
  return
 }

 var users Users

 json.Unmarshal(byteValue, &users)

 for i := 0; i < len(users.Users); i++ {
   fmt.Println("User Name: " + users.Users[i].Name)
   fmt.Println("User Age: " + strconv.Itoa(users.Users[i].Age))
   fmt.Println("Zhihu Url: " + users.Users[i].Social.Zhihu)
   fmt.Println("Weibo Url: " + users.Users[i].Social.Weibo)


 b, err := json.MarshalIndent(users, "  ", "    ")
 fmt.Println(string(b))
 }
}