Go ​

func main() {
   listen, err := net.Listen("tcp", ":8888")
   for {
      conn, err := listen.Accept()
      // 开启新的Groutine，处理新的连接
      go Handle(conn)
   }
}


func Handle(conn net.Conn) {
   defer conn.Close()
   packet := make([]byte, 1024)
   for {
      // 阻塞直到读取数据
      n, err := conn.Read(packet)
      // 阻塞直到写入数据
      _, _ = conn.Write(packet[:n])
   }
}

// netpoll_epoll.go
func netpollinit()
func netpollopen(fd uintptr, pd *pollDesc) int32
func netpoll(delay int64) gList

fmt.Sprintf()

strconv.FormatInt(变量, 进制)

strconv.FormatFloat(变量, 格式, 小数保留几位, 小数类型值如: 64)

strconv.FormatBool(变量)

strconv.Itoa(变量)

Parse系列函数有两个返回值,可以用b,_接收,下划线表示忽略

strconv.ParseBool(变量)

strconv.ParseInt(变量, 进制, 整型位数)

strconv.ParseFloat(变量, 小数类型位数)

func main() {
	//iota数值递增
	const (
		a = iota
		b
		c, d = iota, iota	//不会递增
	)
	fmt.Println(a,b,c,d) //0,1,2,2
}

var num int = 10 
var ptr *int = &num
//将num的内存地址赋值给指针类型的ptr
//*int表示指针类型, &num表示num在内存中的地址
fmt.Printf("%v", &num)//num的内存地址
fmt.Printf("%v", ptr)//num的内存地址
fmt.Printf("%v", &ptr)//ptr的内存地址
fmt.Printf("%v", *ptr)//取出存储的num地址里的值,也就是10

指针初始化：// &i为指针地址，i为值地址，*I为具体值
var i *int; 
i = new(int); 
*i = 1

fmt.Scanf(指定%格式, 变量地址)与fmt.Scanln(变量地址)

if a < 10 {

}
//if语句判断不需要小括号
if b := 1; b < 10 {  

}
//if判断中可以直接定义变量

switch score := 30; {
    case "a":
    fmt.Println("a")
    case "b":
    fmt.Println("b")
    case "c", "d":
    fmt.Println("c", "d")
	case score > 20 $$ score < 50:
    fmt.Println("判断")
    fallthrough
    case:
    fmt.Println("0")
    default:
    fmt,Println("以上都不匹配,默认输出")
}
//不需要break, case后面可以带多个表达式用逗号分隔
//case后面也可不带表达式, 也可以直接定义变量, 不推荐
//fallthrough穿透: 当前case成立,仍执行后面的case,只穿透一层

for i := 1; i <= 10;i++ {

}
//传统循环,不需要小括号
//如果字符串含中文循环出来会乱码,按字节来遍历的,转为切片可解决
for index, value := range str {
    
}
//for-range默认按字符方式遍历

lable2:
for i := 0;i < 4;i++ {
    label1:
    for j := 0;j < 10;j++ {
        if j == 2 {
            break label1
        }
        fmt.Println("123")
    }
}
//break默认会跳出最近的循环
//当指定跳出的标签时,会跳出标签层对应的for循环

lable2:
for i := 0;i < 4;i++ {
    label1:
    for j := 0;j < 10;j++ {
        if j == 2 {
            continue label1
        }
        fmt.Println("123")
    }
}
//continue默认结束当前最近的循环,执行下次循环
//当指定跳出的标签时,会结束标签层对应的当前循环,执行下次循环

fmt.Println("1")
goto label
fmt.Println("2")
fmt.Println("3")
fmt.Println("4")
fmt.Println("5")
label:
fmt.Println("6")
//goto语句指定标签,直接跳到标签处执行代码,不建议使用该语句
//通常与if语句一起使用

//定义函数类型
type myFunc func(int, int ) int
//定义函数
func getSun(num1 int, num2 int) int {
	return num1 + num2
}
//定义传函数参数的函数
func myFunc2(funvar myFunc, num1 int, num2 int) int  {
	return funvar(num1, num2)
}
//在main中使用
func main() {
	res3 := myFunc2(getSun, 500, 500)
	fmt.Println(res3)
}

func myfunc(args... int) (i int, o int) {
    num := 1
    for a :=0; a<len(args); a++{
       num += args[a]
    } 
    return num, a
}
//args...代表传进来的多个参数,类型是切片

var abc int = 567
func init(){
    res := 123
    defer fmt.Println(res)	//123
    res++
}
func main(){
    
}
//defer后面的代码会推入栈中等待函数执行完后再执行,并拷贝引用的值
//在全局中,go语言会依次解析全局变量->init初始化函数->main主函数

len(str)					
//返回变量的长度, 内置函数(无需引包)

[]rune(str)
//转为切片并返回, 内置函数(无需引包), 解决遍历字符串出现乱码的问题.

strconv.Atoi("123")
//有两个返回值: value和error
//字符串转整数并返回, 需要引包, 只能转数字字符串, 否则返回的为nil零值

strconv.Itoa(123)
//整数转字符串并返回, 需要引包

**[]byte("hello")**
//字符串转byte切片并返回ascll码值

string([]byte{97,98,99})
//将byte切片转为字符串并返回, 内置函数

strconv.FormatInt(123, 2)
//10进制转其他进制并返回

strings.Contains("hello", "he")
//查找子字符串是否在指定的字符串中, 返回布尔值, 需要引包

strings.Count("ababa", "ab")
//统计子字符串在指定的字符串中有多少个并返回, 需要引包

strings.EqualFold("abc", "ABC")
//字符串比较, 不区分大小写(==是区分大小写), 返回布尔值, 需要引包

strings.Index("abc", "b")
//返回子字符串在指定字符串中第一次出现的值的索引值, 需要引包

strings.LastIndex("abc", "b")
//返回子字符串在指定字符串中最后一次出现的值的索引值, 需要引包

strings.Replace("gogohello", "go", "ios", -1)
//指定初始字符串, 要替换的位置子串, 替换后的子串, 替换次数
//-1为替换所有匹配的子串, 不改变初始字符串, 返回替换后的新字符串

strings.Split("go,go,hello",  ",")
//按照指定的字符分割字符串,返回一个包含分割后的多个字符串的数组
//不会改变初始字符串本身

strings.ToLower("Go")
//字符串转小写并返回, 不改变字符串本身

strings.ToUpper("Go")
//字符串转大写并返回, 不改变字符串本身

strings.TrimSpace(" gao ")
//去除字符串两端空格并返回, 不改变字符串本身

strings.Trim("!gao!", "!")
//去掉字符串两端指定的字符并返回, 不改变字符串本身

strings.TrimLeft("!gao", "!")
//去掉字符串左边指定的字符并返回, 不改变字符串本身

strings.TrimRight("gao!", "!")
//去掉字符串右边指定的字符并返回, 不改变字符串本身

strings.HasPrefix("!gao", "!")
//判断字符串是否以指定的字符开头并返回布尔值

strings.HasSuffix("gao!", "!")
//判断字符串是否以指定的字符结束并返回布尔值

now := time.Now()
//获取当前时间并返回

now.Year()
// 获取年

int(now.Month())
// 获取月

now.Day()
// 获取日期

now.Hour()
// 获取小时

now.Minute()
// 获取分钟

now.Second()
// 获取秒

now.Format("2006-01-02 15:04:05")
//格式化日期时间

type Duration int64
const (
	Nanosecond Duration = 1						//纳秒
	Microsecond 		= 1000 * Nanosecond		//微秒
	Millisecond			= 1000 * Microsecond	//毫秒
	Second				= 1000 * Millisecond	//秒
	Minute				= 60 * Second			//分
	Hour				= 60 * Minute			//时
)
// 内置的时间常量

time.Sleep()
//休眠即延迟执行, 可使用时间常量来计算需要休眠的时间

now.Unix()
//获取1970年到现在的秒数时间戳

now.UnixNano()
//获取1970年到现在的纳秒数时间戳

new()
//传入一个值类型, 创建一个指针, 系统分配指针的地址值以及自身的地址
//指针的地址值的值为传入值类型的零值

make()
//传入一个引用类型, 创建一个指针, 系统分配指针的地址值以及自身的地址
//指针的地址值的值为传入引用类型的零值

func test () int {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println(err)
		}
	}()
	num1 := 100
	num2 :=0
	num3 := num1 / num2
	return num3
}

func main()  {

	test := test()

	fmt.Printf("123456")
	fmt.Println(test)
}

type Circle struct {
	raduis float64
}

func (c Circle) area() float64 {
	return 3.14 * c.raduis * c.raduis
}
func (c *Circle) area2() float64 {
	c.raduis = 10.0
	return 3.14 * c.raduis * c.raduis
} 
func main()  {
	var name Circle
	name.raduis = 5.0
	res := name.area2()
	fmt.Println(res)	//输出314
}
//在方法area2中通过指针改变了结构体中radius的值, 指针指向的结构体本身.

type A struct {
	number int
}
type B struct {
	number int
}
func main()  {
	var a A
	var b B
	a = A(b)
	fmt.Println(a,b)
}
//当元素的名字, 个数, 类型完全相同, 可以进行类型强转

type Circle struct {
	Radius float64 `json:"radius"`
}
func main()  {
	var name Circle
	a,_ := json.Marshal(name)
	fmt.Println(string(a))	//{"radius":0}
}
//json.Marshal()将结构体转换为字节码, 通过string()内置函数转换为字符串

//主包
type a struct {
	number int
}
func News(b int) *a {
	return &a{
		number: b,
	}
}
//跨包(model包)
func main()  {
	var stu = model.News(10)
	fmt.Println(*stu)
}

map[KeyType]ValueType

//KeyType:表示键的类型。
//ValueType:表示键对应的值的类型。

make(map[KeyType]ValueType, [cap])

// 其中cap表示map的容量，该参数虽然不是必须的，但是我们应该在初始化map的时候就为其指定一个合适的容量。

scoreMap := make(map[string]int, 8)	// 初始化map，并设置容量8
scoreMap["张三"] = 90	// 向map变量中插入数据

// 声明时填充元素
userInfo := map[string]string{
	"username": "pprof.cn",
	"password": "123456",
}

scoreMap := make(map[string]int)
// 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值
v, ok := scoreMap["张三"]

scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
scoreMap["王五"] = 60
// 需要使用 for range 遍历
for k, v := range scoreMap {
	fmt.Println(k, v)
}

delete(scoreMap, "小明")// 将键为'小明'的数据从map变量scoreMap中删除

rand.Seed(time.Now().UnixNano()) //初始化随机数种子

var scoreMap = make(map[string]int, 200)

for i := 0; i < 100; i++ {
	key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
	value := rand.Intn(100)          //生成0~99的随机整数
	scoreMap[key] = value
}
//取出map中的所有key存入切片keys
var keys = make([]string, 0, 200)
for key := range scoreMap {
	keys = append(keys, key)
}
//对切片进行排序
sort.Strings(keys)
//按照排序后的key遍历map
for _, key := range keys {
	fmt.Println(key, scoreMap[key])
}

var mapSlice = make([]map[string]string, 3)
for index, value := range mapSlice {
	fmt.Printf("index:%d value:%v\n", index, value)
}
fmt.Println("after init")
// 对切片中的map元素进行初始化
mapSlice[0] = make(map[string]string, 10)
mapSlice[0]["name"] = "王五"
mapSlice[0]["password"] = "123456"
mapSlice[0]["address"] = "红旗大街"
for index, value := range mapSlice {
	fmt.Printf("index:%d value:%v\n", index, value)
}

var sliceMap = make(map[string][]string, 3)
fmt.Println(sliceMap)
fmt.Println("after init")
key := "中国"
value, ok := sliceMap[key]
if !ok {
	value = make([]string, 0, 2)
}
value = append(value, "北京", "上海")
sliceMap[key] = value
fmt.Println(sliceMap)

type 接口类型名 interface{
	方法名1( 参数列表1 ) 返回值列表1
	方法名2( 参数列表2 ) 返回值列表2
	…
}

type Mover interface {
    move()
}

type dog struct {}

// 值接收者实现接口
func (d dog) move() {
    fmt.Println("狗会动")
}
func main() {
    var x Mover
    var wangcai = dog{} // 旺财是dog类型
    x = wangcai         // x可以接收dog类型
    var fugui = &dog{}  // 富贵是*dog类型
    x = fugui           // x可以接收*dog类型
    x.move()
}
// 使用值接收者实现接口之后，不管是dog结构体还是结构体指针*dog类型的变量都可以赋值给该接口变量。因为Go语言中有对指针类型变量求值的语法糖，dog指针fugui内部会自动求值*fugui。

// 指针接收者实现接口
func (d *dog) move() {
    fmt.Println("狗会动")
}
func main() {
    var x Mover
    var wangcai = dog{} // 旺财是dog类型
    x = wangcai         // x不可以接收dog类型
    var fugui = &dog{}  // 富贵是*dog类型
    x = fugui           // x可以接收*dog类型
}
// 此时实现Mover接口的是*dog类型，所以不能给x传入dog类型的wangcai，此时x只能存储*dog类型的值。

func putNum(iniChan chan int) {
	for i:=0;i<=8000;i++ {
		iniChan<-i
	}
	close(iniChan)
}
func primeChan (intChan chan int, primeChan chan int, exitChan chan bool) {
	//var num int
	var flag bool
	for {
		num, ok := <-intChan
		if !ok {
			break
		}
		flag = true
		for i := 2; i < num; i++ {
			if num % i == 0 {
				flag = false
				break
			}
		}
		if flag {
			primeChan<- num
		}
	}
	exitChan<-true
}

func main() {
	iniChan := make(chan int, 1000)
	promeChan := make(chan int, 2000)
	exitChan := make(chan bool, 4)
	go putNum(iniChan)
	for i := 0; i < 4; i++ {
		go primeChan(iniChan, promeChan, exitChan)
	}
	go func() {

		for i := 0; i < 4; i++ {
			<-exitChan
		}
		close(promeChan)

	}()
	for {
		res, ok :=<-promeChan
		if !ok {
			break
		}
		fmt.Printf("s=%d\n", res)
	}
}

func main () {
	f, err := os.Create('./test/is')
	if err != nil {
		fmt.Println("create err:", err)
		return
	}
	defer f.Close()		//关闭文件
}

func main () {
	f, err := os.Open('./test/is')
	if err != nil {
		fmt.Println("create err:", err)
		return
	}
	_, err := f.WriteString("高江华")
	if err != nil {
		fmt.Println("WriteString err:", err)
		return
	}					//会报错,权限不足
	defer f.Close()		//关闭文件
}

func main () {
	f, err := os.OpenFile('./test/is', O_RDWR, 6)
	if err != nil {
		fmt.Println("create err:", err)
		return
	}
	_, err := f.WriteString("高江华")
	if err != nil {
		fmt.Println("WriteString err:", err)
		return
	}
	defer f.Close()		//关闭文件
}

reader := bufio.NewReader(f) 	//创建一个带有缓冲区的reader
buf, err := reader.ReadBytes('\n')		//到\n结束,读一行数据
if err != nil {			//err == io.EOF则读完所有内容
	fmt.Println("ReadBytes err:", err)
	return
}
fmt.Println(string(buf))

func main () {
	//打开要读取的文件
    fr, err := os.Open("C:/123/test.txt")
    if err != nil {
        fmt.Println("Open err:", err)
        return
    }
    defer fr.Close()
    //创建要写入的文件
    fw, err := os.Create("C:/123/my.txt")
    if err != nil {
        fmt.Println("Create err:", err)
        return
    }
    defer fw.Close()
    //创建一个切片缓冲区
    buf := make([]byte, 4096)
    for {
        //将读到的数据放入buf切片缓冲区中
        n, err := fr.Read(buf)
        if err != nil && err == io.EOF {
            fmt.Printf("读完")
            return
        }
        //将读取后放入缓冲区的内容写入要写入的文件中
        fw.Write(buf[:n])
    }
}

func main() {
	var path string
    fmt.Scan(&path)
    //打开目录
    f, err := os.OpenFile(path, os.O_RDONLY, os.ModeDir)
    if err != nil {
        fmt.Println("OpenFile err:", err)
        return
    }
    defer f.Close()
    //读取目录项
    info, err := f.Readdir(-1)	//负值代表读取目录中的所有目录项
    if err != nil {
        fmt.Println("Readdir err:", err)
        return
    }
    //遍历返回的切片
    for _, fileinfo := range info {
        if fileinfo.IsDir() {
            fmt.Println(fileinfo.Name(),"是一个目录")
        }else{
        	fmt.Println(fileinfo.Name(),"是一个文件")
        }
    }
}

func First[T any](items []T) T {
    return items[0]
}
// [T any]表示类型参数T，它表示任意类型。any关键字表示T类型可以是任何有效类型。

func func1() {
	intSlice := []int{1, 2, 3, 4, 5}
	firstInt := First[int](intSlice) // returns 1

	println(firstInt)

	stringSlice := []string{"apple", "banana", "cherry"}
	firstString := First[string](stringSlice) // returns "apple"

	println(firstString)
}

func First[T any](items []T) T {
	return items[0]
}

func SumGenerics[T int | int16 | int32 | int64 | int8 | float32 | float64](a, b T) T {
    return a + b
}

func func2() {
	sumInt := SumGenerics[int](2, 3)

	sumFloat := SumGenerics[float32](2.5, 3.5)

	sumInt64 := SumGenerics[int64](10, 20)

	fmt.Println(sumInt)   // returns 5
	fmt.Println(sumFloat) // returns 6.0
	fmt.Println(sumInt64) // returns 30
}

type Person struct {
 	Name    string
 	Age     int
 	Address string
}

func Serialize[T any](data T) ([]byte, error) {
  	buffer := bytes.Buffer{}
  	encoder := gob.NewEncoder(&buffer)
  	err := encoder.Encode(data)
  	if err != nil {
    	return nil, err
  	}
  	return buffer.Bytes(), nil
}

func Deserialize[T any](b []byte) (T, error) {
	buffer := bytes.Buffer{}
	buffer.Write(b)
	decoder := gob.NewDecoder(&buffer)
	var data T
	err := decoder.Decode(&data)
	if err != nil {
		return data, err
	}
	return data, nil
}
// 函数Serialize和Deserialize，它们利用Go的gob包将任意数据类型转换为字节，反之亦然。

func DeserializeUsage() {
	// 创建一个Person实例
	person := Person{
		Name:    "John",
		Age:     30,
		Address: "123 Main St.",
	}
	// 将person对象转换为字节数组
	serialized, err := Serialize(person)
	if err != nil {
    	panic(err)
	}
	// 将字节数组转换回Person对象
	deserialized, err := Deserialize[Person](serialized)
	if err != nil {
    	panic(err)
  	}
  
	fmt.Printf("Name: %s, Age: %d, Address: %s", deserialized.Name, deserialized.Age, deserialized.Address)
	// Output: Name: John, Age: 30, Address: 123 Main St.
}

// 接受任意类型T的值并返回一个错误
type Validator[T any] func(T) error
// 使用自定义验证器执行数据验证
func Validate[T any](data T, validators ...Validator[T]) error {
	for _, validator := range validators {
		err := validator(data)
		if err != nil {
			return err
		}
	}
	return nil
}
// 自定义验证器：确保字符串不为空
func StringNotEmpty(s string) error {
	if len(strings.TrimSpace(s)) == 0 {
		return fmt.Errorf("string cannot be empty")
	}
	return nil
}
// 自定义验证器：检查整数是否在指定范围内
func IntInRange(num int, min, max int) error {
	if num < min || num > max {
		return fmt.Errorf("number must be between %d and %d", min, max)
	}
	return nil
}

func main() {
	person := Person{
		Name:    "John",
		Age:     30,
		Address: "123 Main St.",
	}
	
	err := Validate(
		person, // 实例
		func(p Person) error {	// 验证 name 是否为空
			return StringNotEmpty(p.Name)
		}, 
		func(p Person) error {	// 验证 age 是否在0~120之内
			return IntInRange(p.Age, 0, 120)
		}
	)
	
	if err != nil {
		println(err.Error())
		panic(err)
	}
	
	println("Person is valid")
}

// 登录表单的结构体
type LoginForm struct {
    Username string
    Password string
}

// 接受任意类型T的值并返回一个错误
type Validator[T any] func(T) error

// 使用自定义验证器执行数据验证
func Validate[T any](data T, validators ...Validator[T]) error {
	for _, validator := range validators {
		err := validator(data)
		if err != nil {
			return err
		}
	}
	return nil
}

// 自定义验证器：确保字符串不为空
func StringNotEmpty(s string) error {
	if len(strings.TrimSpace(s)) == 0 {
		return fmt.Errorf("string cannot be empty")
	}
	return nil
}

// 给 LoginForm 实现一个 Validate 方法
func (f *LoginForm) Validate() error {
    return Validate(f,
        func(l *LoginForm) error {
            return StringNotEmpty(l.Username)	// 验证用户名
        },
        func(l *LoginForm) error {
            return StringNotEmpty(l.Password)	// 验证密码
        },
    )
}

func main() {
    loginForm := LoginForm{
        Username: "John",
        Password: "123",
    }

    err := loginForm.Validate() // 调用校验方法
    if err != nil {
        println(err.Error())
        panic(err)
    }

    println("Login form is valid")
}

//对int类型的反射
func reflect1(b interface{}) {
	rtype := reflect.TypeOf(b)
	fmt.Println("rtype=", rtype)
	//输出类型为int, 实际类型为reflect.type
	rvalue := reflect.ValueOf(b)
	fmt.Printf("rvalue=%v type=%T\n", rvalue, rvalue)
	//输出值为100, 实际类型为reflect.value
	a := 2 + rvalue.Int()
	fmt.Println("a=", a)
	//无法做值操作,需要使用方法Int()转换
	iv := rvalue.Interface()
	//转回interface{}类型
	num := iv.(int)
	fmt.Println("num=", num)
	//将interface通过断言转成需要的类型
}
//对结构体的反射
func reflect2(b interface{})  {
	rtype := reflect.TypeOf(b)
	fmt.Println("rtype=", rtype)
	//输出类型为student, 实际类型为reflect.type
	rvalue := reflect.ValueOf(b)
	fmt.Printf("rvalue=%v type=%T\n", rvalue, rvalue)
	//输出值为{高江华, 26}, 实际类型为reflect.value
	iv := rvalue.Interface()
	//转回interface{}类型
	fmt.Printf("iv=%v iv=%T\n", iv, iv)
	//值{高江华, 26} 类型student
	//反射是运行时的反射, 这里的iv无法取到内部的值, 因编译不通过
	stu, ok := iv.(student)
	if ok {
		fmt.Printf("stu.Name=%v\n", stu.Name)
	}
	//需要进行类型断言后,才能取到内部的值
}
//声明结构体类型
type student struct {
	Name string
	Age int
}

func main() {
	var num int = 100
	reflect1(num)
	//定义结构体实例
	stu := student{
		Name: "高江华",
		Age: 26,
	}
	reflect2(stu)
}

var num int = 10
value := reflect.ValueOf(num)

fmt.Println(value.Kind()) // 输出：int

// 修改前需要使用对应的指针类型来完成
// 同时需要使用Elem()方法
func main() {
	var num int = 100
	fn := reflect.ValueOf(&num)
	fn.Elem().SetInt(200)
    //Elem()用于获取指针指向的变量
	fmt.Printf("%v\n", num)	//输出200
}

type Person struct {
    Name string
    Age  int
}

p := Person{Name: "Alice", Age: 30}

// 获取结构体字段数量
num := reflect.ValueOf(p).NumField()

fmt.Println(num) // 输出：2

type Person struct {
	Name string
	Age  int
}

func main() {
	p := Person{Name: "Alice", Age: 30}
	
	value := reflect.ValueOf(p)
	
	nameField := value.Field(0)
	ageField := value.Field(1)
	
	if nameField.Kind() == reflect.String {
		fmt.Println(nameField.String()) // 输出：Alice
	}
	
	if ageField.Kind() == reflect.Int {
		age := ageField.Int()
		fmt.Println(age) // 输出：30
	}
}