// 变量类型不是任何的接口类型时，我们就需要先把它转成某个接口类型的值
// 可以使用
interface{}(x).(map[int]string)
interface{}(x).([]string)

x := 11
s := []int{3, 6, 8, 11, 45, 7, 47, 49, 55, 59, 70} 
//sort.Slice(s, func(i, j int) bool {
// return s[i] < s[j]
//})
sort.Ints(s)
fmt.Println(s)
sort.Sort(sort.Reverse(sort.IntSlice(s)))
//fmt.Println(s)
// 顺序数组，小于i全部不满足，大于i全部满足。返回满足条件的最小i
// 返回true向左，false向右
pos := sort.Search(len(s), func(i int) bool {
   fmt.Println(s[i])
   return s[i] <= x
})
fmt.Println(pos)
if pos < len(s) && s[pos] == x {
   fmt.Println(x, " 在 s 中的位置为：", pos)
} else {
   fmt.Println("s 不包含元素 ", x)
}

complexArray1 := [3][]string{
  []string{"d", "e", "f"},
  []string{"g", "h", "i"},
  []string{"j", "k", "l"},
}

dog := Dog{"little pig"}
var pet Pet = dog
dog.SetName("monster")
(&dog).SetName("monster") //或者这样

// unsafe.Offsetof是uintptr类型的，查看变量相对地址偏移量
n := Num{i: "EDDYCJY", j: 1}
nPointer := unsafe.Pointer(&n)
niPointer := (*string)(nPointer)
*niPointer = "煎鱼"
njPointer := (*int64)(unsafe.Pointer(uintptr(nPointer) + unsafe.Offsetof(n.j)))
*njPointer = 6
fmt.Printf("n.i: %s, n.j: %d", n.i, n.j)

func main() {
   m := 10
   ch := make(chan struct{})
   for i := 0; i < m; i++ {
      go func(i int) {
         ch <- struct{}{}
         fmt.Println(i)
      }(i)
      <-ch
   }
   close(ch)
}




func main2() {
   var count uint32
   trigger := func(i uint32, fn func()) {
      for {
         if n := atomic.LoadUint32(&count); n == i {
            fn()
            atomic.AddUint32(&count, 1)
            break
         }
         time.Sleep(time.Nanosecond)
      }
   }
   var m uint32 = 10
   for i := uint32(0); i < m; i++ {
      go func(i uint32) {
         fn := func() {
            fmt.Println(i)
         }
         trigger(i, fn)
      }(i)
   }
   trigger(10, func() {})
}

numbers2 := [...]int{1, 2, 3, 4, 5, 6}
maxIndex2 := len(numbers2) - 1
for i, e := range numbers2 {
  if i == maxIndex2 {
    numbers2[0] += e
  } else {
    numbers2[i+1] += e
  }
}
fmt.Println(numbers2)

// 可以通过执行
value2 := [...]int8{0, 1, 2, 3, 4, 5, 6}
switch value2[4] {
case 0, 1:
  fmt.Println("0 or 1")
case 2, 3:
  fmt.Println("2 or 3")
case 4, 5, 6:
  fmt.Println("4 or 5 or 6")
}

func underlyingError(err error) error {
  switch err := err.(type) {
  case *os.PathError:
    return err.Err
  case *os.LinkError:
    return err.Err
  case *os.SyscallError:
    return err.Err
  case *exec.Error:
    return err.Err
  }
  return err
}

func main() {
		defer func() {
			fmt.Println("Enter defer function.")
			// recover函数的正确用法。
			if p := recover(); p != nil {
				fmt.Printf("panic: %s\n", p)
			}
		}()
		// recover函数的错误用法。
		fmt.Printf("no panic: %v\n", recover())
		// 引发panic。
		panic(errors.New("something wrong"))
	
		// recover函数的错误用法。
		p := recover()
		fmt.Printf("panic: %s\n", p)
	
		fmt.Println("Exit function main.")
	}

go clean -cache //清除所有缓存
go clean -testcache // 清除测试缓存


t.Fail() //结果显示失败，但继续执行
t.FailNow() //立即结束
t.Log() //打印日志
t.Logt() //打印日志
t.Fatal() t.Fatalf() //结果显示失败，继续执行，并打印日志
t.Error() t.Errorf() //立即结束并打印日志

go test -bench=. -run=^$ puzzlers/article20/q3
// -bench=后跟正则，表示执行的性能测试方法
// -run==后跟正则，表示执行的功能测试函数。 不加-run，所有功能测试函数会被执行
// -parallel 功能测试函数最大并发数，仅对功能测试有用
// 也可在代码里显式调用 t.Parallel

    // demo.go 被测试代码，不用去读，只用知道事被测试的就行
    //GetPrimes 用于获取小于或等于参数max的所有质数。
	// 本函数使用的是爱拉托逊斯筛选法（Sieve Of Eratosthenes）。
	func GetPrimes(max int) []int {
		if max <= 1 {
			return []int{}
		}
		marks := make([]bool, max)
		var count int
		squareRoot := int(math.Sqrt(float64(max)))
		for i := 2; i <= squareRoot; i++ {
			if marks[i] == false {
				for j := i * i; j < max; j += i {
					if marks[j] == false {
						marks[j] = true
						count++
					}
				}
			}
		}
		primes := make([]int, 0, max-count)
		for i := 2; i < max; i++ {
			if marks[i] == false {
				primes = append(primes, i)
			}
		}
		return primes
	}

// demo_test.go 性能测试
func BenchmarkGetPrimes(b *testing.B) {
		for i := 0; i < b.N; i++ {
			GetPrimes(1000)
		}
	}

// 有三个计时器 
//b.StopTimer() 结束
// b.StartTimer() 开始
// b.ResetTimer 去除之前时间计算
func BenchmarkGetPrimes(b *testing.B) {
 b.StopTimer()
 time.Sleep(time.Millisecond * 500) // 模拟某个耗时但与被测程序关系不大的操作。
 max := 10000
 b.StartTimer()


 for i := 0; i < b.N; i++ {
  GetPrimes(max)
 }
}

// 一般锁
var mu sync.Mutex
mu.Lock()
_, err := writer.Write([]byte(data))
if err != nil {
 log.Printf("error: %s [%d]", err, id)
}
mu.Unlock()

type Person struct {
    name string
    age  int
}
// 全局变量（简单处理）
var p Person
func update(name string, age int) {
    // 更新第一个字段
    p.name = name
    // 加点随机性
    time.Sleep(time.Millisecond*200)
    // 更新第二个字段
    p.age = age
}
//方式2，原子操作
var p atomic.Value
func update2(name string, age int) {
    lp := &Person{}
    // 更新第一个字段
    lp.name = name
    // 加点随机性
    time.Sleep(time.Millisecond * 200)
    // 更新第二个字段
    lp.age = age
    // 原子设置到全局变量
    p.Store(lp)
}


func main() {
    wg := sync.WaitGroup{}
    wg.Add(10)
    // 10 个协程并发更新
    for i := 0; i < 10; i++ {
        name, age := fmt.Sprintf("nobody:%v", i), i
        go func() {
            defer wg.Done()
            update(name, age)
        }()
    }
    wg.Wait()
    // 结果是啥？你能猜到吗？
    fmt.Printf("p.name=%s\np.age=%v\n", p.name, p.age)
    //方式2
    _p := p.Load().(*Person)
    fmt.Printf("p.name=%s\np.age=%v\n", _p.name, _p.age)
}

// 可撤销的 
// WithDeadline函数和WithTimeout函数则都可以被用来产生一个会定时撤销的parent的子值
// deadline是针对某个具体时间，而timeout是针对当前时间的延时来定义自动撤销时间
cxt, cancelFunc := context.WithCancel(context.Background())
// WithValue可以带值
valueCtx:=context.WithValue(ctx,key,"【监控1】")

    func main() {
		coordinateWithContext()
	}
	
	func coordinateWithContext() {
		total := 12
		var num int32
		fmt.Printf("The number: %d [with context.Context]\n", num)
		cxt, cancelFunc := context.WithCancel(context.Background())
		for i := 1; i <= total; i++ {
			go addNum(&num, i, func() {
				if atomic.LoadInt32(&num) == int32(total) {
					cancelFunc()
				}
			})
		}
		<-cxt.Done()
		fmt.Println("End.")
	}
	
	// addNum 用于原子地增加一次numP所指的变量的值。
	func addNum(numP *int32, id int, deferFunc func()) {
		defer func() {
			deferFunc()
		}()
		for i := 0; ; i++ {
			currNum := atomic.LoadInt32(numP)
			newNum := currNum + 1
			time.Sleep(time.Millisecond * 200)
			if atomic.CompareAndSwapInt32(numP, currNum, newNum) {
				fmt.Printf("The number: %d [%d-%d]\n", newNum, id, i)
				break
			} else {
				//fmt.Printf("The CAS operation failed. [%d-%d]\n", id, i)
			}
		}
	}

str := "Go爱好者"
for i, c := range str {
 fmt.Printf("%d: %q [% x]\n", i, c, []byte(string(c)))
}


//结果
0: 'G' [47]
1: 'o' [6f]
2: '爱' [e7 88 b1]
5: '好' [e5 a5 bd]
8: '者' [e8 80 85]

type Reader struct {
  s        string    // Reader 读取的数据来源
  i        int // current reading index（当前读的索引位置）
  prevRune int // index of previous rune; or < 0（前一个读取的 rune 索引位置）
}


func NewReader(s string) *Reader{}

type Builder struct {
    addr *Builder // of receiver, to detect copies by value
    buf  []byte
}


// 该方法向 b 写入一个字节
func (b *Builder) WriteByte(c byte) error{}
// WriteRune 方法向 b 写入一个字符
func (b *Builder) WriteRune(r rune) (int, error){}
// WriteRune 方法向 b 写入字节数组 p
func (b *Builder) Write(p []byte) (int, error){}
// WriteRune 方法向 b 写入字符串 s
func (b *Builder) WriteString(s string) (int, error){}
// Len 方法返回 b 的数据长度。
func (b *Builder) Len() int{}
// Cap 方法返回 b 的 cap。
func (b *Builder) Cap() int{}
// Grow 方法将 b 的 cap 至少增加 n (可能会更多)。如果 n 为负数，会导致 panic。
func (b *Builder) Grow(n int){}
// Reset 方法将 b 清空 b 的所有内容。
func (b *Builder) Reset(){}
// String 方法将 b 的数据以 string 类型返回。
func (b *Builder) String() string{}

b := strings.Builder{}
_ = b.WriteByte('7')
n, _ := b.WriteRune('夕')
fmt.Println(n)
n, _ = b.Write([]byte("Hello, World"))
fmt.Println(n)
n, _ = b.WriteString("你好，世界")
fmt.Println(n)
fmt.Println(b.Len())
fmt.Println(b.Cap())
b.Grow(100)
fmt.Println(b.Len())
fmt.Println(b.Cap())
fmt.Println(b.String())
b.Reset()
fmt.Println(b.String())

// 这里的基础容量是8,扩容10个，最终为 2*8+10 = 16 
var builder1 strings.Builder
// 省略若干代码。
builder1.WriteString("LA")
fmt.Println("Grow the builder ...")
builder1.Grow(10)
fmt.Printf("The cap of contents in the builder is %d.\n", builder1.Cap())

// Size总长度。Len 是未读内容的长度，而不是已存内容的总长度
var reader1 strings.Reader
// 省略若干代码。
readingIndex := reader1.Size() - int64(reader1.Len()) // 计算出的已读计数。

type Reader struct {
    s        []byte
    i        int64 // 当前读取下标
    prevRune int   // 前一个字符的下标，也可能 < 0
}

// 读取数据至 b 
func (r *Reader) Read(b []byte) (n int, err error) {}
// 读取一个字节
func (r *Reader) ReadByte() (byte, error){}
// 读取一个字符
func (r *Reader) ReadRune() (ch rune, size int, err error){}
// 读取数据至 w
func (r *Reader) WriteTo(w io.Writer) (n int64, err error){}
// 进度下标指向前一个字节，如果 r.i <= 0 返回错误。
func (r *Reader) UnreadByte() {}
// 进度下标指向前一个字符，如果 r.i <= 0 返回错误，且只能在每次 ReadRune 方法后使用一次，否则返回错误。
func (r *Reader) UnreadRune() {}
// 读取 r.s[off:] 的数据至b，该方法忽略进度下标 i，不使用也不修改。
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) {}
// 根据 whence 的值，修改并返回进度下标 i ，当 whence == 0 ，进度下标修改为 off，当 whence == 1 ，进度下标修改为 i+off，当 whence == 2 ，进度下标修改为 len[s]+off.
// off 可以为负数，whence 的只能为 0，1，2，当 whence 为其他值或计算后的进度下标越界，则返回错误。
func (r *Reader) Seek(offset int64, whence int) (int64, error){}

x:=[]byte("你好，世界")
r1:=bytes.NewReader(x)
d1:=make([]byte,len(x))
n,_:=r1.Read(d1)
fmt.Println(n,string(d1))
r2:=bytes.Reader{}
r2.Reset(x)
d2:=make([]byte,len(x))
n,_=r2.Read(d2)
fmt.Println(n,string(d2))

type Buffer struct {
    buf      []byte
    off      int   
    lastRead readOp 
}

// 读取到字节 delim 后，以字节数组的形式返回该字节及前面读取到的字节。如果遍历 b.buf 也找不到匹配的字节，则返回错误(一般是 EOF)
func (b *Buffer) ReadBytes(delim byte) (line []byte, err error){}
// 读取到字节 delim 后，以字符串的形式返回该字节及前面读取到的字节。如果遍历 b.buf 也找不到匹配的字节，则返回错误(一般是 EOF)
func (b *Buffer) ReadString(delim byte) (line string, err error){}
// 截断 b.buf , 舍弃 b.off+n 之后的数据。n == 0 时，调用 Reset 方法重置该对象，当 n 越界时（n < 0 || n > b.Len() ）方法会触发 panic.
func (b *Buffer) Truncate(n int){}

var buffer1 bytes.Buffer
contents := "Simple byte buffer for marshaling data."
fmt.Printf("Writing contents %q ...\n", contents)
buffer1.WriteString(contents)
fmt.Printf("The length of buffer: %d\n", buffer1.Len())
fmt.Printf("The capacity of buffer: %d\n", buffer1.Cap())


// 结果
Writing contents "Simple byte buffer for marshaling data." ...
The length of buffer: 39
The capacity of buffer: 64


p1 := make([]byte, 7)
n, _ := buffer1.Read(p1)
fmt.Printf("%d bytes were read. (call Read)\n", n)
fmt.Printf("The length of buffer: %d\n", buffer1.Len()) //32
fmt.Printf("The capacity of buffer: %d\n", buffer1.Cap()) //64

contents := "ab"
buffer1 := bytes.NewBufferString(contents)
fmt.Printf("The capacity of new buffer with contents %q: %d\n",
 contents, buffer1.Cap()) // 内容容器的容量为：8。
unreadBytes := buffer1.Bytes()
fmt.Printf("The unread bytes of the buffer: %v\n", unreadBytes) // 未读内容为：[97 98]。




buffer1.WriteString("cdefg")
fmt.Printf("The capacity of buffer: %d\n", buffer1.Cap()) // 内容容器的容量仍为：8。
unreadBytes = unreadBytes[:cap(unreadBytes)]
fmt.Printf("The unread bytes of the buffer: %v\n", unreadBytes) // 基于前面获取到的结果值可得，未读内容为：[97 98 99 100 101 102 103 0]。




unreadBytes[len(unreadBytes)-2] = byte('X') // 'X'的ASCII编码为88。
fmt.Printf("The unread bytes of the buffer: %v\n", buffer1.Bytes()) // 未读内容变为了：[97 98 99 100 101 102 88]。


// 扩容了，所以后续unreadBytes[len(unreadBytes)-2] = byte('X')操作，
//不会影响unreadBytes值
contents = "cdedefghijk"
fmt.Printf("Write contents %q ...\n", contents)
buffer1.WriteString(contents)
fmt.Printf("3The capacity of buffer: %d\n", buffer1.Cap())

comment := "lalalallalllalal"


// 定义Reader类型的数据
reader1 := strings.NewReader(comment)


//Seek 从当前位置（io.SeekCurrent）   偏移offset1位读起。
offset1 = int64(53)
index1, err = reader1.Seek(offset1, io.SeekCurrent)


// 从reader1，读取num1位数据
reader2 := io.LimitReader(reader1, num1)


// 读取到切片buf2，10位
buf2 := make([]byte, 10)
n, err = reader2.Read(buf2)


// 从reader1偏移offset2位读起，共读num2位
io.NewSectionReader(reader1, offset2, num2)


writer1 := new(strings.Builder)
// 读写器。从reader1读，写入到writer1。没用缓冲。读和写对应
reader4 := io.TeeReader(reader1, writer1)
buf4 := make([]byte, 40)
//返回读取到位数
n, err = reader4.Read(buf4)


reader5a := strings.NewReader("aaaaaaaa.")
reader5b := strings.NewReader("bbbbbbbbbbbbbbbbbbbbbbbbbbb.")
reader5c := strings.NewReader("ccccccccccccccc.")
reader5d := strings.NewReader("dddddd.")
// 合并读取
reader5 := io.MultiReader(reader5a, reader5b, reader5c, reader5d)
buf5 := make([]byte, 50)
for i := 0; i < 8; i++ {
  // 每次最多读取一个Reader
   n, err = reader5.Read(buf5)
   executeIfNoErr(err, func() {
      fmt.Printf("6Read(%d): %q\n", n, buf5[:n])
   })
}


// 管道操作
pReader, pWriter := io.Pipe()
_ := interface{}(pReader).(io.ReadCloser)
_ := interface{}(pWriter).(io.WriteCloser)


comments := [][]byte{
   []byte("Pipe creates a synchronous in-memory pipe."),
   []byte("It can be used to connect code expecting an io.Reader "),
   []byte("with code expecting an io.Writer."),
}
// 这里添加这个同步工具纯属为了保证下面示例中的打印语句都能够执行完成。
// 在实际使用中没有必要这样做。
var wg sync.WaitGroup
wg.Add(2)
go func() {
   defer wg.Done()
   for _, d := range comments {
      time.Sleep(time.Millisecond * 500)
      n, err := pWriter.Write(d)
      if err != nil {
         fmt.Printf("write error: %v\n", err)
         break
      }
      fmt.Printf("7Written(%d): %q\n", n, d)
   }
   pWriter.Close()
}()
go func() {
   defer wg.Done()
   wBuf := make([]byte, 55)
   for {
      n, err := pReader.Read(wBuf)
      if err != nil {
         fmt.Printf("read error: %v\n", err)
         break
      }
      fmt.Printf("7Read(%d): %q\n", n, wBuf[:n])
   }
}()
wg.Wait()

// NewReader ，NewReaderSize用来初始化的方法。
// NewReader 默认4k,NewReaderSize可自定义大


type Reader struct {
   buf          []byte //缓冲区
   rd           io.Reader // io.Reader类型的字段，代表底层读取器
   r, w         int       // buf read and write positions
   err          error
   lastByte     int // last byte read for UnreadByte; -1 means invalid
   lastRuneSize int // size of last rune read for UnreadRune; -1 means invalid
}


type Writer struct {
   err error
   buf []byte
   n   int
   wr  io.Writer
}

// NewReader ，NewReaderSize用来初始化的方法。
// NewReader 默认4k,NewReaderSize可自定义大
Peek、Read、ReadSlice和ReadBytes
Peek方法 ，返回[]byte, error。 不会更改已读计数。error可能为bufio.ErrBufferFull，表示缓冲区已满。
Read方法，会更改已读计数。参数值的长度过大，且缓冲区中已无未读字节时，跨过缓冲区并直接向底层读取器索要数
ReadSlice方法会在缓冲区的未读部分中寻找给定的分隔符，并在必要时对缓冲区进行填充
Reader值的ReadLine方法会依赖于它的ReadSlice方法，而其ReadString方法则完全依赖于ReadBytes方法
Reader值的Peek方法、ReadSlice方法和ReadLine方法都可能会造成其缓冲区中的内容的泄露

//bufio.Writer类型有一个名为Flush的方法，它的主要功能是把相应缓冲区中暂存的所有数据，都写到底层写入器中
// Write、 WriteByte、WriteRune 都会必要的时候调用它的Flush方法
//Flush方法，将缓冲区的数据填充到底层写入器
//Write方法和ReadFrom方法也会跨过缓冲区，并直接把数据写进其底层写入

fd1, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, syscall.IPPROTO_TCP)
if err != nil {
  fmt.Printf("socket error: %v\n", err)
  return
}
defer syscall.Close(fd1)
fmt.Printf("The file descriptor of socket：%d\n", fd1)

type dailArgs struct {
   network string
   address string
   timeout time.Duration
}
args := dailArgs{
   "tcp",
   "baidu.com:80",
   time.Second * 2,
}
ts1 := time.Now()
conn, err := net.DialTimeout(args.network, args.address, args.timeout)
ts2 := time.Now()
defer conn.Close()


a := make([]byte, 20)
r,e :=conn.Write(a)
fmt.Println(r,e,a)


fmt.Printf("The local address: %s\n", conn.LocalAddr())
fmt.Printf("The remote address: %s\n", conn.RemoteAddr())

url1 := "http://baidu.com"
resp1, err := http.Get(url1)
if err != nil {
   fmt.Printf("request sending error: %v\n", err)
   return
}
defer resp1.Body.Close()
line1 := resp1.Proto + " " + resp1.Status
fmt.Printf("The first line of response:\n%s\n", line1)