练习1 — map 遍历顺序验证

建一个 8 元素的 map，range 5 次，每次打印前 3 个 key → 观察随机性

加分：跑 10000 次统计每个 key"当第一"的频率，验证均匀分布

练习2 — string ↔ []byte 拷贝验证

用 unsafe 读底层 Data 指针，验证 []byte(s) 和 string(b) 都会拷贝

加分：用 unsafe 实现零拷贝转换（但别改！会 panic）

可选：strings.Builder vs += 拼接 10000 次的性能对比

go
package main

import (
	"fmt"
	"strconv"
	"strings"
	"time"
	"unsafe"
)

func main() {
	string2bytes()
}

// map 遍历顺序验证-1
func mapsort() {
	m := make(map[string]int)
	for i := 0; i < 8; i++ {
		key := fmt.Sprintf("key%d", i)
		value := 0
		m[key] = value
	}
	for j := 0; j < 5; j++ {
		fmt.Println("-----------------")
		sign := 0
		for key, value := range m {
			fmt.Printf("key :%s ==> value: %d\n", key, value)
			sign++
			if sign == 3 {
				break
			}
		}
		fmt.Println("-----------------")
	}
	fmt.Println("=====================")
	for j := 0; j < 10000; j++ {
		sign := 0
		for key, value := range m {
			m[key] = value + 1
			sign++
			if sign == 1 {
				break
			}
		}
	}
	fmt.Println("item 2 result:")
	for key, value := range m {
		fmt.Printf("key :%s ==> value: %d\n", key, value)
	}
}

// string ↔ []byte 拷贝验证
func string2bytes() {
	s := "hello world!"

	b := []byte(s)

	strData := unsafe.StringData(s)

	sliceData := unsafe.SliceData(b)
	fmt.Println("===[]byte and string 1===")
	fmt.Printf("source string address: %p\n", strData)
	fmt.Printf("[]byte address: %p\n", sliceData)
	fmt.Printf("same: %v\n", strData == sliceData)

	fmt.Println("===[]byte and string 2===")
	b2 := []byte("qqqwwweee")
	str2 := string(b2)

	strData2 := unsafe.StringData(str2)
	sliceData2 := unsafe.SliceData(b2)
	fmt.Printf("source string address: %p\n", strData2)
	fmt.Printf("[]byte address: %p\n", sliceData2)
	fmt.Printf("same: %v\n", strData2 == sliceData2)

	fmt.Println("o copy skip")

	fmt.Println("===================")
	starttime := time.Now()
	result := ""
	for i := 0; i < 10000; i++ {
		result = result + strconv.Itoa(i)
	}
	fmt.Println(result)
	elapsedtime := time.Since(starttime)
	fmt.Printf("use time: %v\n", elapsedtime)
	fmt.Println("===================")
	var buff strings.Builder
	starttime2 := time.Now()
	for i := 0; i < 10000; i++ {
		buff.WriteString(fmt.Sprintf("%d", i))
	}
	fmt.Println(buff.String())
	elapsedtime2 := time.Since(starttime2)
	fmt.Printf("use time: %v\n", elapsedtime2)
}

func getMapB() {
	//新版本已经是swiss table没有B字段
}