golang_learn note_2022年11月26日

D:\code_gitee\go_example\main.go

package main

import (
	"fmt"
)

func main() {
	// 显示声明类型
	const a string = "hello"
	// 隐式声明类型
	const b = "hello"
	// 多重赋值
	const x, y, z = 1, true, "hello"
	fmt.Println("x=", x, "y=", y, "z=", z)
	fmt.Println("----------------------")

	// 用于枚举
	const (
		Spring = 0
		Summer = 1
		Autumn = 2
		Winter = 3
	)
	fmt.Println(Spring)
	fmt.Println(Summer)
	fmt.Println(Autumn)
	fmt.Println(Winter)
	fmt.Println("----------------------")

	// 使用内置函数给常量赋值,比如说len,unsafe.Sizeof(),但是必须是内置函数,不能是自己定义的函数
	const (
		x1 = "hello"
		y1 = len(b)
	)
	fmt.Println("x1=", x1)
	fmt.Println("y1=", y1)
	fmt.Println("----------------------")

	// iota的使用,有点像个自增器
	const (
		Morning = iota
		Afternoon
		Evening
	)
	fmt.Println(Morning)
	fmt.Println(Afternoon)
	fmt.Println(Evening)
	fmt.Println("----------------------")

	// iota的使用,和移位结合起来使用,用于二进制的移位
	const (
		Red    = 1 << iota // 0001
		Orange             // 0010
		Yellow             // 0100
		Green              // 1000
	)
	fmt.Println(Red)
	fmt.Println(Orange)
	fmt.Println(Yellow)
	fmt.Println(Green)
	fmt.Println("----------------------")

	// 使用iota定义byte size
	// 给 float64 起个别名 ByteSize
	type ByteSize float64
	const (
		_           = iota
		KB ByteSize = 1 << (10 * iota) // 100 0000 0000 = 2 ** 10 =1024
		MB
		GB
		TB
		PB
		EB
		ZB
		YB
	)
	fmt.Println(KB)
	fmt.Println(MB)
	fmt.Println(GB)
	fmt.Println("----------------------")

	// iota 在同一行的使用情况
	const (
		Apple, Banana = iota + 1, iota + 2 // 虽然在同一行使用了两次,但是都没有增长
		Pinia, Bluebarry
		Peach, Leomon
	)
	fmt.Println(Apple)  // iota + 1 = 0+1 =1
	fmt.Println(Banana) // iota + 2 = 0+2 =2
	fmt.Println(Pinia)

}

D:\code_gitee\go_example\main01_初次使用.go.txt

package main

import (
	"fmt"

	"com.song.learn/models"
	"com.song.learn/utils"
)

func main() {
	per := models.Person{
		Name: "Alice",
		Age:  19,
	}
	fmt.Println(per)
	fmt.Println("------------------------")

	stu := models.Student{
		Name:  "Bruce",
		Age:   19,
		Grade: 3,
	}
	fmt.Println(stu)
	fmt.Println("-----------------------")

	res := utils.Sum(1, 3)
	fmt.Println("sum(1,3)=", res)
}

D:\code_gitee\go_example\main02_ICM报文封装_不会.go.txt

package main

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"net"
)

type ICMP struct {
	Type        uint8
	Code        uint8
	Checksum    uint16
	Identifier  uint16
	SequenceNum uint16
}

func CheckSum(data []byte) uint16 {
	var (
		sum    uint32
		length int = len(data)
		index  int
	)
	for length > 1 {
		sum += uint32(data[index])<<8 + uint32(data[index+1])
		index += 2
		length -= 2
	}
	if length > 0 {
		sum += uint32(data[index])
	}
	sum += (sum >> 16)

	return uint16(^sum)
}

func main() {
	var (
		icmp  ICMP
		laddr net.IPAddr = net.IPAddr{IP: net.ParseIP("192.168.1.2")} //***IP地址改成你自己的网段***
		raddr net.IPAddr = net.IPAddr{IP: net.ParseIP("192.168.1.1")}
	)

	//如果你要使用网络层的其他协议还可以设置成 ip:ospf、ip:arp 等
	conn, err := net.DialIP("ip4:icmp", &laddr, &raddr)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer conn.Close()

	//开始填充数据包
	icmp.Type = 8 //8->echo message  0->reply message
	icmp.Code = 0
	icmp.Checksum = 0
	icmp.Identifier = 0
	icmp.SequenceNum = 0

	var (
		buffer bytes.Buffer
	)
	//先在buffer中写入icmp数据报求去校验和
	binary.Write(&buffer, binary.BigEndian, icmp)
	icmp.Checksum = CheckSum(buffer.Bytes())
	//然后清空buffer并把求完校验和的icmp数据报写入其中准备发送
	buffer.Reset()
	binary.Write(&buffer, binary.BigEndian, icmp)

	if _, err := conn.Write(buffer.Bytes()); err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Printf("send icmp packet success!")
}

D:\code_gitee\go_example\main03_变量.go.txt

package main

import (
	"fmt"
	"reflect"
)

// 1. 全局变量,声明
var gx,gy int

// 2. 全局变量声明,分解写法
var (
	gm int = 110
	gn bool = true
)

// 3. 全局变量声明不允许使用语法糖形式
// gx:=123

func main() {
	// 1. 只是声明,不赋值
	var a int
	fmt.Printf("a=%d", a)
	fmt.Println("------------------")
	var b string
	fmt.Printf("b=%s", b)
	fmt.Println("------------------")

	// 2. 声明但不赋值
	var c int = 100
	fmt.Println(c)
	fmt.Printf("type(c)= %T\n", c)
	//%T 最终还是调用的是 reflect.TypeOf()函数
	fmt.Println("type(c)=", reflect.TypeOf(c))
	fmt.Println("------------------")

	// 3. 声明的时候直接赋值,自动类型推断
	var d = 20
	fmt.Printf("type(d)=%T\n", d)
	fmt.Println("------------------")

	// 4. 省略var关键字
	e := 3.14
	fmt.Printf("e=%f\n", e)
	fmt.Printf("type of e=%T\n", e)
	fmt.Println("------------------")

	// 5. 同时声明多个变量
	m, n := 123, 456
	fmt.Println("m=", m)
	fmt.Println("n=", n)
	fmt.Println("------------------")

	var m1, n1 = 123, 456 // m1和n1,都会进行类型推导
	var m11, n11 int = 123, 456 // m11和n11,两个类型都是一样的,所以可以直接声明int类型
	fmt.Println("m1=", m1)
	fmt.Println("n1=", n1)
	fmt.Println("m11=", m11)
	fmt.Println("n11=", n11)
	fmt.Println("------------------")

	var m2, n2 = 123, "test" // m2和n2,是两个不同的类型,这里会自动进行类型推导
	// var m2, n2 int,string= 123, "test" // 我本来以为这样声明两个变量,然后分别声明不同的类型,但是这样好像不行,必须两个都是相同的类型 
	fmt.Printf("m2=%T\n", m2)
	fmt.Printf("n2=%T\n", n2)
	fmt.Println("------------------")

	// 6. 同时声明多个变量,丢弃一个变量
	_, y := 123, 456 //前面的123就会被丢弃掉
	// fmt.Println("_=",_) // can not use _ as value or type
	fmt.Println("y=", y)
	fmt.Println("------------------")

	// 7. 全局变量
	fmt.Println("gx=",gx,"gy=",gy)
	fmt.Println("gm= ",gm,"gn= ",gn)
}

D:\code_gitee\go_example\main04_常量.go.txt

package main

import (
	"fmt"
)

func main() {
	// 显示声明类型
	const a string = "hello"
	// 隐式声明类型
	const b = "hello"
	// 多重赋值
	const x, y, z = 1, true, "hello"
	fmt.Println("x=", x, "y=", y, "z=", z)
	fmt.Println("----------------------")

	// 用于枚举
	const (
		Spring = 0
		Summer = 1
		Autumn = 2
		Winter = 3
	)
	fmt.Println(Spring)
	fmt.Println(Summer)
	fmt.Println(Autumn)
	fmt.Println(Winter)
	fmt.Println("----------------------")

	// 使用内置函数给常量赋值,比如说len,unsafe.Sizeof(),但是必须是内置函数,不能是自己定义的函数
	const (
		x1 = "hello"
		y1 = len(b)
	)
	fmt.Println("x1=", x1)
	fmt.Println("y1=", y1)
	fmt.Println("----------------------")

	// iota的使用,有点像个自增器
	const (
		Morning = iota
		Afternoon
		Evening
	)
	fmt.Println(Morning)
	fmt.Println(Afternoon)
	fmt.Println(Evening)
	fmt.Println("----------------------")

	// iota的使用,和移位结合起来使用,用于二进制的移位
	const (
		Red    = 1 << iota // 0001
		Orange             // 0010
		Yellow             // 0100
		Green              // 1000
	)
	fmt.Println(Red)
	fmt.Println(Orange)
	fmt.Println(Yellow)
	fmt.Println(Green)
	fmt.Println("----------------------")

	// 使用iota定义byte size
	// 给 float64 起个别名 ByteSize
	type ByteSize float64
	const (
		_           = iota
		KB ByteSize = 1 << (10 * iota) // 100 0000 0000 = 2 ** 10 =1024
		MB
		GB
		TB
		PB
		EB
		ZB
		YB
	)
	fmt.Println(KB)
	fmt.Println(MB)
	fmt.Println(GB)
	fmt.Println("----------------------")

	// iota 在同一行的使用情况
	const (
		Apple, Banana = iota + 1, iota + 2 // 虽然在同一行使用了两次,但是都没有增长
		Pinia, Bluebarry
		Peach, Leomon
	)
	fmt.Println(Apple)  // iota + 1 = 0+1 =1
	fmt.Println(Banana) // iota + 2 = 0+2 =2
	fmt.Println(Pinia)

}

D:\code_gitee\go_example\models\Person.go

package models

type Person struct {
	Name string
	Age  int
}

D:\code_gitee\go_example\models\Student.go

package models

type Student struct {
	Name  string
	Age   int
	Grade int
}

D:\code_gitee\go_example\utils\sum.go

package utils


func Sum(a int, b int) int {
	return a + b
}