近期学习golang
package main
import (
"bufio"
"fmt"
"net"
)
func process(conn net.Conn) {
defer conn.Close()
for {
reader := bufio.NewReader(conn)
var buf [124]byte
n, err := reader.Read(buf[:])
if err != nil {
fmt.Println("read from client failed, err:", err)
break
}
recStr := string(buf[:n])
fmt.Println("收到客户端发来的数据：", recStr)
conn.Write([]byte(recStr)) // 发送数据
}
}
func main() {
listen, err := net.Listen("tcp", "127.0.0.1:5000")
if err != nil {
fmt.Println("listen failed, err:", err)
return
}
for {
conn, err := listen.Accept() // 建立连接
if err != nil {
fmt.Println("accept failed, err:", err)
continue
}
go process(conn) // 启动一个goroutine处理连接
}
}
package main
import (
"bufio"
"fmt"
"net"
"os"
"strings"
)
func main() {
conn, err := net.Dial("tcp", "127.0.0.1:500///////////0")
if err != nil {
fmt.Println("err :", err)
return
}
defer conn.Close() // 关闭连接
inputReader := bufio.NewReader(os.Stdin)
for {
input, _ := inputReader.ReadString('\n') // 读取用户输入///////
inputInfo := strings.Trim(input, "\r\n")
if strings.ToUpper(inputInfo) == "Q" { // 如果输入q就退出
return
}
_, err = conn.Write([]byte(inputInfo)) // 发送数据
if err != nil {
return
}
buf := [512]byte{}
n, err := conn.Read(buf[:])
if err != nil {
fmt.Println("recv failed, err:", err)
return
}
fmt.Println(string(buf[:n]))
}
}
package main
import (
"bufio"
"bytes"
"encoding/binary"
"fmt"
"io"
"net"
)
// Encode 将消息编码
func Encode(message string) ([]byte, error) {
// 读取消息的长度，转换成int32类型（占4个字节）
var length = int32(len(message))
var pkg = new(bytes.Buffer)
// 写入消息头
err := binary.Write(pkg, binary.LittleEndian, length)
if err != nil {
return nil, err
}
// 写入消息实体
err = binary.Write(pkg, binary.LittleEndian, []byte(message))
if err != nil {
return nil, err
}
return pkg.Bytes(), nil
}
// Decode 解码消息
func Decode(reader *bufio.Reader) (string, error) {
// 读取消息的长度
lengthByte, _ := reader.Peek(4) // 读取前4个字节的数据
fmt.Println(lengthByte, 90)
lengthBuff := bytes.NewBuffer(lengthByte)
fmt.Println(lengthByte, 91)
var length int32
err := binary.Read(lengthBuff, binary.LittleEndian, &length)
if err != nil {
return "err11", err
}
// Buffered返回缓冲中现有的可读取的字节数。
// if int32(reader.Buffered()) < length+4 {
// return "errint32", err
// }
fmt.Println(reader.Buffered(), int32(reader.Buffered()), length)
// 读取真正的消息数据
pack := make([]byte,5 )
_, err = reader.Read(pack)
if err != nil {
return "45", err
}
return string(pack[:]), nil
}
func process(conn net.Conn) {
defer conn.Close()
reader := bufio.NewReader(conn)
for {
msg, err := Decode(reader)
if err == io.EOF {
return
}
if err != nil {
fmt.Println("decode msg failed, err:", err)
return
}
if msg == "" {
fmt.Println("deckkkkkkr:", err)
return
}
fmt.Println("收到client发来的数据：", msg)
conn.Write([]byte("avbb"))
}
}
func main() {
listen, err := net.Listen("tcp", "127.0.0.1:8081")
if err != nil {
fmt.Println("listen failed, err:", err)
return
}
defer listen.Close()
for {
conn, err := listen.Accept()
if err != nil {
fmt.Println("accept failed, err:", err)
continue
}
go process(conn)
}
}
package main
import (
"flag"
"fmt"
)
/**
*flag 包UI额
*/
func main() {
name := flag.String("name", "leos", "请输入参数name -name ")
fmt.Println("name is", *name)
var age string
flag.StringVar(&age, "age", "89", "请输入参数age -age")
flag.Parse()
fmt.Println("age is", age)
}
package main
import "fmt"
type Books struct {
Name string
Author string
}
func main() {
var a int = 8
fmt.Printf("%v\n", a)
var book1 Books = Books{
Name: "红楼梦",
Author: "曹雪芹",
}
fmt.Printf("%v\n", book1)
fmt.Printf("%v\n", book1.Name)
fmt.Printf("%v\n", book1.Author)
book2 := book1
book1.Name = "menfaf"
fmt.Printf("%v\n", book2)
}
package main
import "fmt"
type oks struct {
Name string
}
func doArray(array [3]string) {
for i := 0; i < len(array); i++ {
fmt.Printf("array[i]: %v\n", array[i])
}
}
func swap(x *int, y *int) {
var temp int
temp = *x /* 保存 x 地址的值 */
*x = *y /* 将 y 赋值给 x */
*y = temp /* 将 temp 赋值给 y */
}
func main() {
var a int = 78
var b int = 90
fmt.Println("yuanlai fr ", a, b)
swap(&a, &b)
fmt.Println("jiaohuanhou 222", a, b)
var oneArray [3]string
oneArray[0] = "one"
oneArray[1] = "two"
oneArray[2] = "three"
fmt.Printf("oneArray: %v\n", oneArray)
doArray(oneArray)
for i := 0; i < len(oneArray); i++ {
fmt.Printf("oneArray[i]: %v\n", oneArray[i])
}
var twoArray [3][3]string
twoArray[0][0] = "one"
twoArray[0][1] = "one1"
twoArray[0][2] = "one2"
twoArray[1][0] = "one3"
fmt.Printf("twoArray: %v\n", twoArray)
}
package main
import (
"encoding/json"
"fmt"
)
func BianVar() {
var one int = 89
two := "abc"
four, five := "cbf", "oks"
var three float32 = 89.09
fmt.Println(one, two, three, four, five)
}
func arrayDo() {
var one [3]int
one[0] = 67
fmt.Println(one)
two := [3]string{"abc", "efg", "leo"}
fmt.Println(two)
for i := 0; i < len(two); i++ {
fmt.Println(two[i])
}
var three [2][2]string
three[0][0] = "one1"
three[0][1] = "one2"
three[1][0] = "one3"
three[1][1] = "one4"
fmt.Println(three)
for _, th := range three {
for _, v := range th {
fmt.Println(v)
}
}
fmt.Println("*****************")
//指针数组
four := &one
fmt.Println(*four)
fmt.Println("*******原始**********")
one[2] = 34
fmt.Println(four)
fmt.Println(*four) //67 0 34]
fmt.Println("*******原始1**********")
four[1] = 89
fmt.Println(one) //[67 89 34]
fmt.Println("**********------*******")
var five [3]*int
fmt.Println(five)
for i := 0; i < len(one); i++ {
five[i] = &one[i]
}
fmt.Println(five)
for i := 0; i < len(five); i++ {
fmt.Println(*five[i])
}
}
func sliceDo() {
var array = [3]string{"abc", "leo", "jyh"}
fmt.Println(array)
one := array[0:]
fmt.Println(one) //[abc leo jyh]
array[0] = "abc1"
fmt.Println(one) //[abc1 leo jyh]
two := make([]string, 1)
fmt.Println(two)
two[0] = "nihaos"
fmt.Println(len(two))
fmt.Println(cap(two))
two = append(two, "anb", "fafa")
fmt.Println(len(two))
fmt.Println(cap(two))
two = append(two, "anb", "fafa")
fmt.Println(len(two)) //5
fmt.Println(cap(two)) //6
fmt.Println(two)
}
func mapDo() {
var one = make(map[string]string, 6)
one["name"] = "lihua"
fmt.Println(one) //map[name:lihua]
two := one
fmt.Println(two) //map[name:lihua]
one["name"] = "leos"
fmt.Println(two) //map[name:leos]
}
type leoint int
type leostring string
func (l leostring) SayOk() {
fmt.Println("------")
}
type Animal struct {
Name string
FootNum int
}
/**
*构造函数
*/
func NewAnimal(name string, foot_num int) *Animal {
return &Animal{
Name: name,
FootNum: foot_num,
}
}
func (a Animal) say() {
fmt.Printf("%s say thisis %d \n", a.Name, a.FootNum)
}
func (a *Animal) setName(name string) {
a.Name = name
}
func structDo() {
var one leoint
one = 999
fmt.Println(one)
var two leostring
two = "leos"
two.SayOk()
fmt.Println(two)
dog := Animal{Name: "dog", FootNum: 4}
fmt.Println(dog, dog.Name, dog.FootNum)
cat := Animal{"cat", 4}
fmt.Println(cat, cat.Name, cat.FootNum)
cat1 := &cat
fmt.Println(cat1)
cat1.Name = "peiqi"
fmt.Println(cat)
fmt.Printf("%#v\n", dog)
a := &Animal{Name: "cat", FootNum: 9}
fmt.Printf("%#v\n", a.FootNum)
a1 := new(Animal)
fmt.Printf("%#v\n", a1)
a2 := NewAnimal("lisi", 89)
fmt.Printf("%#v\n", a2.FootNum)
a2.say()
a2.setName("leosss")
fmt.Printf("%#v", a2.Name)
}
type Adress struct {
City string
Area string
}
//嵌套结构体
type Human struct {
Name string
Age int
Adress
}
func structSt() {
h := Human{
Name: "zhangsan",
Age: 34,
Adress: Adress{
City: "shenzhen",
Area: "longhua",
},
}
fmt.Printf("%#v\n", h)
fmt.Println(h.City)
c := &Class{
Title: "101",
Students: make([]*Student, 0, 200),
}
for i := 0; i < 10; i++ {
stu := &Student{
Name: fmt.Sprintf("stu%02d", i),
Gender: "男",
ID: i,
}
c.Students = append(c.Students, stu)
}
//JSON序列化：结构体-->JSON格式的字符串
data, err := json.Marshal(c)
if err != nil {
fmt.Println("json marshal failed")
return
}
fmt.Printf("json:%s\n", data)
//JSON反序列化：JSON格式的字符串-->结构体
str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
c1 := &Class{}
err = json.Unmarshal([]byte(str), c1)
if err != nil {
fmt.Println("json unmarshal failed!")
return
}
fmt.Printf("%#v\n", c1)
}
//Student 学生
type Student struct {
ID int
Gender string
Name string
}
//Class 班级
type Class struct {
Title string
Students []*Student
}
func main() {
// BianVar()
//arrayDo()
//sliceDo()
//mapDo()
//structDo()
structSt()
}
package main
import (
"bufio"
"bytes"
"encoding/binary"
"fmt"
"io"
"os"
"strings"
)
//io Reader 学下
func ReadFrom(reader io.Reader, num int) ([]byte, error) {
p := make([]byte, num)
n, err := reader.Read(p)
if n > 0 {
return p[:n], nil
}
return p, err
}
//从标准输入获取
func inputStdin() {
data, err := ReadFrom(os.Stdin, 99)
fmt.Println(data, err)
}
//从字符串获取
func strs() {
data, err := ReadFrom(strings.NewReader("from string"), 12)
fmt.Println(data, err)
}
func filess() {
file, err := os.Open("xx.txt")
fmt.Println(file)
data, err := ReadFrom(file, 9)
fmt.Println(data, err)
}
// 输入输出
func main() {
fmt.Println("iiii")
// 从标准输入读取
// 从字符串读取
// filess()
// file, err := os.Open("xx.txt")
// if err!=nil{
// fmt.Println("open file faid;err;",err)
// }
// r:=bufio.NewReader(file)
// var buf [14]byte
// n, err := r.Read(buf[:])
// fmt.Println(string(buf[:n]), n, err)
// rs:=strings.NewReader("nininininini")
// r:=bufio.NewReader(rs)
// lengthByte, _ := r.Peek(4) // 读s取前4个字节的数据
// fmt.Println(lengthByte)
// fmt.Println(string(lengthByte))
// var length int32
// lengthBuff := bytes.NewBuffer(lengthByte)
// err := binary.Read(lengthBuff, binary.LittleEndian, &length)
// fmt.Println(err)
// fmt.Println(r.Buffered())
var message = "你好世界"
var length = int32(len(message))
var pkg = new(bytes.Buffer)
fmt.Println(length)
binary.Write(pkg, binary.LittleEndian, length)
// 写入消息头
err := binary.Write(pkg, binary.LittleEndian, []byte("你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界你好世界"))
fmt.Println(err)
lb := pkg.Bytes()
fmt.Println(lb)
rb := bytes.NewReader(lb)
r := bufio.NewReader(rb)
lengthByte, _ := r.Peek(4) // 读取前4个字节的数据
fmt.Println(lengthByte, 90)
lengthBuff := bytes.NewBuffer(lengthByte)
fmt.Println(lengthByte, 91)
var length1 int32
err = binary.Read(lengthBuff, binary.LittleEndian, &length1)
fmt.Println(length1, 911)
fmt.Println(r.Buffered(), 9112)
pack := make([]byte, int(4+length1))
_ ,_=r.Read(pack)
fmt.Println(string(pack[4:]))
}
源码部分引用 https://topgoer.cn/
不逼一下自己，都不知道自己有多优秀！！！
浙公网安备 33010602011771号