随笔- 56 文章- 1 评论- 0 阅读- 5874

近期学习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)
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

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:]))
}