var i
func get(){
    i := 1
}

// 示例1：指针切片
// 创建包含指针的切片
items := make([]*Item, 0, 100)

// 添加一些指针元素
items = append(items, &Item{data: "data1"})
items = append(items, &Item{data: "data2"})

// 假设我们"删除"第一个元素
// 手动清除方法 items[0] = nil
// 使用copy
copy(item[0:],item[1:])
items = items[1:]  // 现在 items 只有 data2
// 问题：底层数组仍然引用着 data1 的指针！
// data1 指向的内存不会被GC回收

///////////////////////////////////////////////////////
// 示例2：包含指针字段的结构体
// 问题：底层数组仍然引用着 data1 的指针！
// data1 指向的内存不会被GC回收
type User struct {
    Name string
    Data *Data  // 指针字段！
}

users := make([]User, 0, 10)
users = append(users, User{Name: "Alice", Data: &Data{value: 100}})

// 删除元素后，Data指针仍然被底层数组引用
users = users[1:]

func main(){
  s := []int{1, 2, 3}
  f(s[:2])
  fmt.Println(s) // [1,2,10]
  
}

func f(s []int){
  _ = append(s, 10)
}

/*
// append操作分析：
1. 检查容量：len=2, cap=3，容量足够
2. 不创建新数组，直接使用原底层数组
3. 在原底层数组索引2位置写入10
4. 返回新切片：len=3, cap=3

内存布局变化:
索引:  0   1   2
前:   [1] [2] [3]
后:   [1] [2] [10]  // 索引2的值被覆盖了！

// 注意：_ = append(s, 10)
// 虽然我们忽略了返回值，但底层数组已经被修改了！
*/

s := "hello"
fmt.Println(len(s)) // 5

s := "汉"
fmt.Println(len(s)) // 3

s:="adbcd"
r:= []rune(s)

// 获取字符串长度
utf8.RuneCountInString(s)

fmt.Println(strings.TrimRight("123oxo", "xo")) // 123
fmt.Println(strings.TrimLeft("oxo123", "ox")) // 123
fmt.Println(strings.TrimPrefix("oxo123", "ox")) /// o123

func concat(values []string) string {
  total := 0
  for i := 0; i < len(values); i++ {
    total += len(values[i]) // 统计每个字符串的字节数
  }
  sb := strings.Builder{} // 底层是持有一个byte切片,WriteString执行后都会对这个切片进行追加操作
  // Grow 给builder持有的切片指定多少字节数，减少字节切片扩容操作，提升性能
  sb.Grow(total) // 根据统计的字节数给builder开辟空间，减少内存分配
  for _, value := range values {
    _, _ = sb.WriteString(value)
  }
  return sb.String()
}

type slice []int
func (s *slice) add(element int) {
*s = append(*s, element)
}

func countEmptyLines(reader io.Reader) (int, error) {
scanner := bufio.NewScanner(reader)
  for scanner.Scan() {
  // ...
  }
}

s := "abc"
defer f(s) // s = abc
defer f(){
  fmt.Println(s) // s = ddd 闭包调用执行时才赋值
}()
s = "ddd"

func main() {
  i := 0
  j := 0
  defer func(i int) {
  fmt.Println(i, j)
  }(i)
  i++
  j++
  // i = 0 
  // j = 1
}

// 错误包装
if err != nil {
  return fmt.Errorf("bar failed: %w", err)
}

// 示例：使用nil通道动态管理select分支
for {
    select {
    case v, ok := <-ch1:
        if !ok {
            ch1 = nil // 将通道置为nil，使此case不再被选中
            continue
        }
        process(v)
    case v, ok := <-ch2:
        if !ok {
            ch2 = nil // 将通道置为nil，使此case不再被选中
            continue
        }
        process(v)
    }

    if ch1 == nil && ch2 == nil {
        break // 两个通道都已关闭，退出循环
    }
}

func potentialDeadlock() {
    var mu sync.Mutex
    
    mu.Lock()
    // 危险：如果format内部触发了需要同一锁的操作
    s := fmt.Sprintf("Locked: %v", someFunction()) 
    mu.Unlock()
}

func someFunction() string {
    // 如果这里也需要获取同一个锁，就会死锁
    mu.Lock() // 第二次尝试加锁 - 死锁！
    defer mu.Unlock()
    return "data"
}

//// 数据竞争
var sharedData string

func goroutine1() {
    // 不安全：同时修改共享数据
    sharedData = fmt.Sprintf("Value: %d", time.Now().Unix())
}

func goroutine2() {
    // 同时读取或修改 sharedData
    fmt.Println(sharedData)
}

s := make([]int, 1) // 无数据竟态,当一个go程插入后，切片已满底层会重新创建一个数组扩容
s := make([]int, 0, 1) // 存在数据竟态,两个go程都访问索引为 1 的位置
go func() {
  s1 := append(s, 1)
  fmt.Println(s1)
}()
go func() {
  s2 := append(s, 1)
  fmt.Println(s2)
}()

func handler(ctx context.Context, circles []Circle) ([]Result, error) {
  results := make([]Result, len(circles))
  g, ctx := errgroup.WithContext(ctx)
  for i, circle := range circles {
    i := i
    circle := circle
    g.Go(func() error {
      result, err := foo(ctx, circle)
        if err != nil {
          return err
        }
        results[i] = result
        return nil
    })
  }
  if err := g.Wait(); err != nil { // g.Wait() 等待所有go程执行完成
    return nil, err
  }
  return results, nil
}

// 都不能被复制
sync.Cond
sync.Map
sync.Mutex
sync.RWMutex
sync.Once
sync.Pool
sync.WaitGroup

func consumer(ch <-chan Event) {
  timerDuration := 1 * time.Hour
  timer := time.NewTimer(timerDuration)
  for {
    timer.Reset(timerDuration)
    select {
      case event := <-ch:
      handle(event)
      case <-timer.C:
      log.Println("warning: no messages received")
    }
  }
}

// json格式化 会有问题 ID字段会被省略 
// 执行json.Marshal()后  "2021-05-18T21:15:08.381652+02:00"
type Event struct {
  ID int
  time.Time // 这样会组合会实现time的所有方法,  time.Time实现了json.Marshaler当调用json.Marshal()会调用它已实现的方法
}
type Event struct {
  ID int
  Time time.Time // 使用
}
// 

type Closer interface {
  Close() error
}

client := &http.Client{
  Timeout: 5 * time.Second, // 请求超时等待时间
  Transport: &http.Transport{
      DialContext: (&net.Dialer{
        Timeout: time.Second, // 连接超时等待时间
      }).DialContext,
      TLSHandshakeTimeout: time.Second, // tls握手超时等待时间
      ResponseHeaderTimeout: time.Second, // 服务器响应头等待时间
  },
}
s := &http.Server{
  Addr: ":8080",
  ReadHeaderTimeout: 500 * time.Millisecond, // 读取请求头等待超时
  ReadTimeout: 500 * time.Millisecond, // 读取请求超时
  Handler: http.TimeoutHandler(handler, time.Second, "foo"), // 一个封装函数，用于指定处理程序完成的最大时间
}

//go:build integration
package db
import (
"testing"
)
func TestInsert(t *testing.T) {
// ...
}
// $ go test --tags=integration -v .

func TestLongRunning(t *testing.T) {
  if testing.Short() {
  t.Skip("skipping long-running test")
  }
  // ...
}

go test -race ./...

// 先执行C 再并行执行 AB
func TestA(t *testing.T) {
  t.Parallel()
  // ...
}
func TestB(t *testing.T) {
  t.Parallel()
  // ...
}
func TestC(t *testing.T) {
  // ...
}

func TestFoo(t *testing.T) {
  t.Run("subtest 1", func(t *testing.T) {
    if false {
      t.Error()
    }
  })
  t.Run("subtest 2", func(t *testing.T) {
    if 2 != 2 {
      t.Error()
    }
  })
}

// 模拟请求
req := httptest.NewRequest(http.MethodGet, "http://localhost",
strings.NewReader("foo"))

// 模拟服务器
srv := httptest.NewServer(
  http.HandlerFunc(
  func(w http.ResponseWriter, r *http.Request) {
    _, _ = w.Write([]byte(`{"duration": 314}`))
    },
  ),
)
defer srv.Close()

func TestLowerCaseReader(t *testing.T) {
  err := iotest.TestReader(
    &LowerCaseReader{reader: strings.NewReader("aBcDeFgHiJ")},
    []byte("acegi"),
  )
  if err != nil {
    t.Fatal(err)
  }
}

$ go test -coverprofile=coverage.out ./...
$ go tool cover -html=coverage.out

// 测试前setup
func TestMySQLIntegration(t *testing.T) {
  // ...
  db := createConnection(t, "tcp(localhost:3306)/db")
  // ...
}

func createConnection(t *testing.T, dsn string) *sql.DB {
  db, err := sql.Open("mysql", dsn)
  if err != nil {
    t.FailNow()
  }
  t.Cleanup( // 测试完后关闭资源
    func() {
      _ = db.Close()
  })
  return db
}

func TestMain(m *testing.M) {
  setupMySQL()
  code := m.Run()
  teardownMySQL()
  os.Exit(code)
}

// 由于结构体的大小必须是字长（8字节）的整数倍，因此其地址总长度为24字节而非17字节。编译时，Go编译器会添加填充数据以确保数据对齐
type Foo struct {
  i int64
  b1 byte // 在64位的系统编译器默认会补 7个byte
  b2 byte
}

// 这个版本要快些，编译器会避免将bytes转为string
func (c *cache) get(bytes []byte) (v int, contains bool) {
  v, contains = c.m[string(bytes)]
  return
}
func (c *cache) get(bytes []byte) (v int, contains bool) {
  key := string(bytes)
  v, contains = c.m[key]
  return
}

// 需要创建多个byte切片的场景使用sync.pool优化
var pool = sync.Pool{
  New: func() any {
  return make([]byte, 1024)
  },
}
func write(w io.Writer) {
  buffer := pool.Get().([]byte)
  buffer = buffer[:0]// 清空buffer
  defer pool.Put(buffer)
  getResponse(buffer)
  _, _ = w.Write(buffer)
}

package main
import (
  "fmt"
  "log"
  "net/http"
  _ "net/http/pprof"
)
func main() {
  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { 
  fmt.Fprintf(w, "")
  })
  log.Fatal(http.ListenAndServe(":80", nil))
}