🍞2022.04.14

  1. package main
  3. import "fmt"
  5. func main() {
  6.     arr := [...]int{10, 22, 13, 54, 35, 76}
  7.     for key, value := range arr {
  8.         fmt.Printf("key:%d,value:%d\n", key, value)
  9.     }
  10.     fmt.Printf("测试👩‍🦳")
  11. }

🚄Go切片

数组的长度是固定的，声明以后就是数组类型的一部分，这样我们定义一个数组就存在不确定性！切片是在数组层面上对数组的一次封装🍞，支持数组长度不固定
注意⚠️：切片是引用数据类型

  1. _string := []string
  2. _int := []int
  1. // 由数组获取到切片
  2. arr2 := arr1[2:4] //左包含右不包含
  3. fmt.Printf("arr1[2:4]:===> %d\n", arr2)
  4. arr3 := arr1[:4] //开始到结束索引
  5. fmt.Printf("arr1[:4]:===> %d\n", arr3)
  1. 数组或者切片的长度可以通过len()函数去获取
  2. 数组或者切片的容量可以通过cap()函数去获取

切片长度以及对于容量的理解

image.png
image.png

🎥个人理解：如果你是通过数组去创建切片，切片的容量取决于原数组，还取决于你去切取数组的位置！ 最重要记住一点是切片是引用数据类型，他永远不可能超过其引用的数据来源定义的类型（长度或者容量什么的）！

内置make函数去创建切片

make创建切片是引用类型的，其底层是有一个分配内存的数组存在！make就是确定其长度和最大容量的方法

make([]string,len,cap)

make函数就是为创建的切片去分配内存空间！如果切片没有去初始化值，那么创建的切片默认值就是定义的类型的默认值，例如：int类型的默认值为0

创建一个空的切片

空切片的长度和容量都是0，且底层没有引用数组，不是引用类型

  1. var s1 = []int
  2. var s2 = []string
  4. s1 === nil
  5. s2 === nil

append

为切片添加元素

  1. package main
  3. import "fmt"
  5. func main() {
  6.     arr := []int{10, 20}
  8.     fmt.Printf("内存地址1️⃣：%p\n", arr)
  10.     //增加新的元素
  11.     arr = append(arr, 40)
  13.     fmt.Printf("内存地址2️⃣：%p", arr)
  14. }

image.png
append底层处理逻辑：append是底层重新创建了一个能容量你添加元素的数组，所以打印内存地址其实已经改变了！

🚝Goroutine

在java/c++中我们要实现并发编程的时候，我们通常需要自己维护一个线程池，并且需要自己去包装一个又一个的任务，同时需要自己去调度线程执行任务并维护上下文切换，这一切通常会耗费程序员大量的心智。那么能不能有一种机制，程序员只需要定义很多个任务，让系统去帮助我们把这些任务分配到CPU上实现并发执行呢？

Go语言中的goroutine就是这样一种机制，goroutine的概念类似于线程，但 goroutine是由Go的运行时（runtime）调度和管理的。Go程序会智能地将 goroutine 中的任务合理地分配给每个CPU。Go语言之所以被称为现代化的编程语言，就是因为它在语言层面已经内置了调度和上下文切换的机制。

在Go语言编程中你不需要去自己写进程、线程、协程，你的技能包里只有一个技能–goroutine，当你需要让某个任务并发执行的时候，你只需要把这个任务包装成一个函数，开启一个goroutine去执行这个函数就可以了，就是这么简单粗暴。

使用goroutine

Go语言中使用goroutine非常简单，只需要在调用函数的时候在前面加上go关键字，就可以为一个函数创建一个goroutine。

一个goroutine必定对应一个函数，可以创建多个goroutine去执行相同的函数

启动单个goroutine程序

  1. package main
  3. import "fmt"
  5. func hello() {
  6.     fmt.Println("Hello Goroutine!")
  7. }
  8. func main() {
  9.     hello()
  10.     fmt.Println("main goroutine done!")
  11. }

输出结果
image.png

  1. package main
  3. import "fmt"
  5. func hello() {
  6.     fmt.Println("Hello Goroutine!")
  7. }
  8. func main() {
  9.     go hello()
  10.     fmt.Println("main goroutine done!")
  11. }

输出结果
image.png
上面注意到⚠️：加上go关键字后hello函数执行的输出并没有在控制台进行输出！

这是因为go关键字标识后的函数，go语言内部会自己去处理创建一个新的线程去处理你这个包裹的需要去并发的函数！但是当主函数执行结束后整个进程就会被销毁，那么之前创建的那个线程去帮助处理的函数也就不会在去执行！相当于mian函数是boss，里面的你需要去进行并发的函数就相当于boss召集的小怪，帮助boss的，是boss的得力助手！你创建几个go语言并发的需求就会有几个小怪！但是只要你把boss打败了，那么小怪也就会跟着消失了！其实go语言创建并发也是这个原理！

如果你想让你的并发函数执行输出，那么你就可以让你的boss等等你，等你并发的函数执行结束后再结束主函数boss的生命（进程）！前提你是要给定并发足够的时间⌚️！

让主函数延迟结束🔚

  1. package main
  3. import "fmt"
  5. func hello() {
  6.     fmt.Println("Hello Goroutine!")
  7. }
  8. func main() {
  9.     go hello()
  10.     fmt.Println("main goroutine done!")
  11.     time.Sleep(time.Second)
  12. }

输出结果
image.png

image.png

方法定义

2022.06.04

Golang 方法总是绑定对象实例，并隐式将实例作为第一实参 (receiver)。

• 只能为当前包内命名类型定义方法。
• 参数 receiver 可任意命名。如方法中未曾使用 ，可省略参数名。
• 参数 receiver 类型可以是 T 或 *T。基类型 T 不能是接口或指针。
• 不支持方法重载，receiver 只是参数签名的组成部分。
• 可用实例 value 或 pointer 调用全部方法，编译器自动转换。

  1. package main
  3. import "fmt"
  5. type User struct {
  6.     id   int
  7.     name string
  8. }
  10. func (self User) Test() {
  11.     fmt.Println(self)
  12. }
  14. func main() {
  15.     u := User{1, "Tom"}
  16.     mValue := u.Test // 立即复制 receiver，因为不是指针类型，不受后续修改影响。
  18.     u.id, u.name = 2, "Jack"
  19.     u.Test()
  21.     mValue()
  22. }

指针类型定于与值类型定义方法

User 方法集包含 TestValue。签名变为 func TestValue(self User)。实际依然是 receiver value copy。

  1. package main
  3. import "fmt"
  5. type User struct {
  6.     id   int
  7.     name string
  8. }
  10. func (self *User) TestPointer() {
  11.     fmt.Printf("TestPointer: %p, %v\n", self, self)
  12. }
  14. func (self User) TestValue() {
  15.     fmt.Printf("TestValue: %p, %v\n", &self, self)
  16. }
  18. func main() {
  19.     u := User{1, "Tom"}
  20.     fmt.Printf("User: %p, %v\n", &u, u)
  22.     mv := User.TestValue
  23.     mv(u)
  25.     mp := (*User).TestPointer
  26.     mp(&u)
  28.     mp2 := (*User).TestValue 
  29.     mp2(&u)
  30. }
  1. User: 0xc42000a060, {1 Tom}    
  2. TestValue: 0xc42000a0a0, {1 Tom}     
  3. TestPointer: 0xc42000a060, &{1 Tom}    
  4. TestValue: 0xc42000a100, {1 Tom}

对象

2022.06.05

  1. package main
  3. import "fmt"
  5. //人
  6. type Person struct {
  7.     name string
  8.     sex  string
  9.     age  int
  10. }
  12. // 自定义类型
  13. type mystr string
  15. // 学生
  16. type Student struct {
  17.     Person
  18.     int
  19.     mystr
  20. }
  22. func main() {
  23.     s1 := Student{Person{"5lmh", "man", 18}, 1, "bj"}
  24.     fmt.Println(s1)
  25. }
  1. {{5lmh man 18} 1 bj}

指针类型

  1. package main
  3. import "fmt"
  5. //人
  6. type Person struct {
  7.     name string
  8.     sex  string
  9.     age  int
  10. }
  12. // 学生
  13. type Student struct {
  14.     *Person
  15.     id   int
  16.     addr string
  17. }
  19. func main() {
  20.     s1 := Student{&Person{"5lmh", "man", 18}, 1, "bj"}
  21.     fmt.Println(s1)
  22.     fmt.Println(s1.name)
  23.     fmt.Println(s1.Person.name)
  24. }
  1.  {0xc00005c360 1 bj}
  2.  zs
  3.  zs

接口

什么是接口

接口（interface）定义了一个对象的行为规范，只定义规范不实现，由具体的对象来实现规范的细节。

在Go语言中接口（interface）是一种类型，一种抽象的类型。

interface是一组method的集合，是duck-type programming的一种体现。接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）。

为什么要使用接口

  1. type Cat struct{}
  3. func (c Cat) Say() string { return "喵喵喵" }
  5. type Dog struct{}
  7. func (d Dog) Say() string { return "汪汪汪" }
  9. func main() {
  10.     c := Cat{}
  11.     fmt.Println("猫:", c.Say())
  12.     d := Dog{}
  13.     fmt.Println("狗:", d.Say())
  14. }

上面的代码中定义了猫和狗，然后它们都会叫，你会发现main函数中明显有重复的代码，如果我们后续再加上猪、青蛙等动物的话，我们的代码还会一直重复下去。那我们能不能把它们当成“能叫的动物”来处理呢？
像类似的例子在我们编程过程中会经常遇到：
比如一个网上商城可能使用支付宝、微信、银联等方式去在线支付，我们能不能把它们当成“支付方式”来处理呢？
比如三角形，四边形，圆形都能计算周长和面积，我们能不能把它们当成“图形”来处理呢？
比如销售、行政、程序员都能计算月薪，我们能不能把他们当成“员工”来处理呢？
Go语言中为了解决类似上面的问题，就设计了接口这个概念。接口区别于我们之前所有的具体类型，接口是一种抽象的类型。当你看到一个接口类型的值时，你不知道它是什么，唯一知道的是通过它的方法能做什么。

接口的定义

  1. 接口是一个或多个方法签名的集合。
  2.     任何类型的方法集中只要拥有该接口'对应的全部方法'签名。
  3.     就表示它 "实现" 了该接口，无须在该类型上显式声明实现了哪个接口。
  4.     这称为Structural Typing。
  5.     所谓对应方法，是指有相同名称、参数列表 (不包括参数名) 以及返回值。
  6.     当然，该类型还可以有其他方法。
  8.     接口只有方法声明，没有实现，没有数据字段。
  9.     接口可以匿名嵌入其他接口，或嵌入到结构中。
  10.     对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个复制品的指针，既无法修改复制品的状态，也无法获取指针。
  11.     只有当接口存储的类型和对象都为nil时，接口才等于nil。
  12.     接口调用不会做receiver的自动转换。
  13.     接口同样支持匿名字段方法。
  14.     接口也可实现类似OOP中的多态。
  15.     空接口可以作为任何类型数据的容器。
  16.     一个类型可实现多个接口。
  17.     接口命名习惯以 er 结尾。

每个接口由数个方法组成，接口的定义格式如下：

  1.  type 接口类型名 interface{
  2.         方法名1( 参数列表1 ) 返回值列表1
  3.         方法名2( 参数列表2 ) 返回值列表2
  4.         …
  5.     }
  1. 1.接口名：使用type将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加er，如有写操作的接口叫Writer，有字符串功能的接口叫Stringer等。接口名最好要能突出该接口的类型含义。
  2. 2.方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
  3. 3.参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略。

例子🌰

  1. type writer interface{
  2.     Write([]byte) error
  3. }

实现接口

一个对象只要全部实现了接口中的方法，那么就实现了这个接口。换句话说，接口就是一个需要实现的方法列表。
我们来定义一个Sayer接口：

  1. // Sayer 接口 
  2. type Sayer interface {     
  3.     say()
  4. }

定义dog和cat两个结构体：

  1. type dog struct {} 
  3. type cat struct {}

因为Sayer接口里只有一个say方法，所以我们只需要给dog和cat 分别实现say方法就可以实现Sayer接口了。

  1. // dog实现了Sayer接口 
  2. func (d dog) say() {     
  3.     fmt.Println("汪汪汪") 
  4. }
  5. // cat实现了Sayer接口 
  6. func (c cat) say() {     
  7.     fmt.Println("喵喵喵") 
  8. }

接口的实现就是这么简单，只要实现了接口中的所有方法，就实现了这个接口。

接口实现后有什么作用

那实现了接口有什么用呢？

接口类型变量能够存储所有实现了该接口的实例。 例如上面的示例中，Sayer类型的变量能够存储dog和cat类型的变量。

  1. func main() {
  2.     var x Sayer // 声明一个Sayer类型的变量x
  3.     a := cat{}  // 实例化一个cat
  4.     b := dog{}  // 实例化一个dog
  5.     x = a       // 可以把cat实例直接赋值给x
  6.     x.say()     // 喵喵喵
  7.     x = b       // 可以把dog实例直接赋值给x
  8.     x.say()     // 汪汪汪
  9. }

面试题

请问下面的代码是否能通过编译？

  1. type People interface {
  2.     Speak(string) string
  3. }
  5. type Student struct{}
  7. func (stu *Stduent) Speak(think string) (talk string) {
  8.     if think == "sb" {
  9.         talk = "你是个大帅比"
  10.     } else {
  11.         talk = "您好"
  12.     }
  13.     return
  14. }
  16. func main() {
  17.     var peo People = Student{}
  18.     think := "bitch"
  19.     fmt.Println(peo.Speak(think))
  20. }

接口类型判断

想要判断空接口中的值这个时候就可以使用类型断言，其语法格式：

  1.  x.(T)

其中：
x：表示类型为interface{}的变量 T：表示断言x可能是的类型。
该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false则表示断言失败。
举个例子：

  1. func main() {     
  2.     var x interface{}     
  3.     x = "pprof.cn"     
  4.     v, ok := x.(string)     
  5.     if ok {         
  6.         fmt.Println(v)     
  7.     } else {
  8.         fmt.Println("类型断言失败")     
  9.     } 
  10. }

上面的示例中如果要断言多次就需要写多个if判断，这个时候我们可以使用switch语句来实现：

  1. func justifyType(x interface{}) {     
  2.     switch v := x.(type) {     
  3.         case string:         
  4.             fmt.Printf("x is a string，value is %v\n", v) 
  5.         case int:         
  6.             fmt.Printf("x is a int is %v\n", v)     
  7.         case bool:         
  8.             fmt.Printf("x is a bool is %v\n", v)     
  9.         default:         
  10.             fmt.Println("unsupport type！")     
  11.     } 
  12. }

因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛。
关于接口需要注意的是，只有当有两个或两个以上的具体类型必须以相同的方式进行处理时才需要定义接口。不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗。

网络编程

互联网协议

互联网的核心是一系列协议，总称为”互联网协议”（Internet Protocol Suite），正是这一些协议规定了电脑如何连接和组网。我们理解了这些协议，就理解了互联网的原理。由于这些协议太过庞大和复杂，没有办法在这里一概而全，只能介绍一下我们日常开发中接触较多的几个协议

image.png

物理层

我们的电脑要与外界互联网通信，需要先把电脑连接网络，我们可以用双绞线、光纤、无线电波等方式。这就叫做”实物理层”，它就是把电脑连接起来的物理手段。它主要规定了网络的一些电气特性，作用是负责传送0和1的电信号。


数据链路层

单纯的0和1没有任何意义，所以我们使用者会为其赋予一些特定的含义，规定解读电信号的方式：例如：多少个电信号算一组？每个信号位有何意义？这就是”数据链接层”的功能，它在”物理层”的上方，确定了物理层传输的0和1的分组方式及代表的意义。早期的时候，每家公司都有自己的电信号分组方式。逐渐地，一种叫做”以太网”（Ethernet）的协议，占据了主导地位。
以太网规定，一组电信号构成一个数据包，叫做”帧”（Frame）。每一帧分成两个部分：标头（Head）和数据（Data）。其中”标头”包含数据包的一些说明项，比如发送者、接受者、数据类型等等；”数据”则是数据包的具体内容。”标头”的长度，固定为18字节。”数据”的长度，最短为46字节，最长为1500字节。因此，整个”帧”最短为64字节，最长为1518字节。如果数据很长，就必须分割成多个帧进行发送。
那么，发送者和接受者是如何标识呢？以太网规定，连入网络的所有设备都必须具有”网卡”接口。数据包必须是从一块网卡，传送到另一块网卡。网卡的地址，就是数据包的发送地址和接收地址，这叫做MAC地址。每块网卡出厂的时候，都有一个全世界独一无二的MAC地址，长度是48个二进制位，通常用12个十六进制数表示。前6个十六进制数是厂商编号，后6个是该厂商的网卡流水号。有了MAC地址，就可以定位网卡和数据包的路径了。
我们会通过ARP协议来获取接受方的MAC地址，有了MAC地址之后，如何把数据准确的发送给接收方呢？其实这里以太网采用了一种很”原始”的方式，它不是把数据包准确送到接收方，而是向本网络内所有计算机都发送，让每台计算机读取这个包的”标头”，找到接收方的MAC地址，然后与自身的MAC地址相比较，如果两者相同，就接受这个包，做进一步处理，否则就丢弃这个包。这种发送方式就叫做”广播”（broadcasting）。

网络层

按照以太网协议的规则我们可以依靠MAC地址来向外发送数据。理论上依靠MAC地址，你电脑的网卡就可以找到身在世界另一个角落的某台电脑的网卡了，但是这种做法有一个重大缺陷就是以太网采用广播方式发送数据包，所有成员人手一”包”，不仅效率低，而且发送的数据只能局限在发送者所在的子网络。也就是说如果两台计算机不在同一个子网络，广播是传不过去的。这种设计是合理且必要的，因为如果互联网上每一台计算机都会收到互联网上收发的所有数据包，那是不现实的。
因此，必须找到一种方法区分哪些MAC地址属于同一个子网络，哪些不是。如果是同一个子网络，就采用广播方式发送，否则就采用”路由”方式发送。这就导致了”网络层”的诞生。它的作用是引进一套新的地址，使得我们能够区分不同的计算机是否属于同一个子网络。这套地址就叫做”网络地址”，简称”网址”。
“网络层”出现以后，每台计算机有了两种地址，一种是MAC地址，另一种是网络地址。两种地址之间没有任何联系，MAC地址是绑定在网卡上的，网络地址则是网络管理员分配的。网络地址帮助我们确定计算机所在的子网络，MAC地址则将数据包送到该子网络中的目标网卡。因此，从逻辑上可以推断，必定是先处理网络地址，然后再处理MAC地址。
规定网络地址的协议，叫做IP协议。它所定义的地址，就被称为IP地址。目前，广泛采用的是IP协议第四版，简称IPv4。IPv4这个版本规定，网络地址由32个二进制位组成，我们通常习惯用分成四段的十进制数表示IP地址，从0.0.0.0一直到255.255.255.255。
根据IP协议发送的数据，就叫做IP数据包。IP数据包也分为”标头”和”数据”两个部分：”标头”部分主要包括版本、长度、IP地址等信息，”数据”部分则是IP数据包的具体内容。IP数据包的”标头”部分的长度为20到60字节，整个数据包的总长度最大为65535字节

传输层

有了MAC地址和IP地址，我们已经可以在互联网上任意两台主机上建立通信。但问题是同一台主机上会有许多程序都需要用网络收发数据，比如QQ和浏览器这两个程序都需要连接互联网并收发数据，我们如何区分某个数据包到底是归哪个程序的呢？也就是说，我们还需要一个参数，表示这个数据包到底供哪个程序（进程）使用。这个参数就叫做”端口”（port），它其实是每一个使用网卡的程序的编号。每个数据包都发到主机的特定端口，所以不同的程序就能取到自己所需要的数据。

“端口”是0到65535之间的一个整数，正好16个二进制位。0到1023的端口被系统占用，用户只能选用大于1023的端口。有了IP和端口我们就能实现唯一确定互联网上一个程序，进而实现网络间的程序通信。

我们必须在数据包中加入端口信息，这就需要新的协议。最简单的实现叫做UDP协议，它的格式几乎就是在数据前面，加上端口号。UDP数据包，也是由”标头”和”数据”两部分组成：”标头”部分主要定义了发出端口和接收端口，”数据”部分就是具体的内容。UDP数据包非常简单，”标头”部分一共只有8个字节，总长度不超过65,535字节，正好放进一个IP数据包。
UDP协议的优点是比较简单，容易实现，但是缺点是可靠性较差，一旦数据包发出，无法知道对方是否收到。为了解决这个问题，提高网络可靠性，TCP协议就诞生了。TCP协议能够确保数据不会遗失。它的缺点是过程复杂、实现困难、消耗较多的资源。TCP数据包没有长度限制，理论上可以无限长，但是为了保证网络的效率，通常TCP数据包的长度不会超过IP数据包的长度，以确保单个TCP数据包不必再分割。

应用层

应用程序收到”传输层”的数据，接下来就要对数据进行解包。由于互联网是开放架构，数据来源五花八门，必须事先规定好通信的数据格式，否则接收方根本无法获得真正发送的数据内容。”应用层”的作用就是规定应用程序使用的数据格式，例如我们TCP协议之上常见的Email、HTTP、FTP等协议，这些协议就组成了互联网协议的应用层。
如下图所示，发送方的HTTP数据经过互联网的传输过程中会依次添加各层协议的标头信息，接收方收到数据包之后再依次根据协议解包得到数据。

image.png


Go语言实现TCP通信

TCP就像货到付款的快递，送到家还必须见到你人才算一整套流程。UDP就像某快递快递柜一扔就走管你收到收不到，一般直播用UDP


TCP协议

TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议，因为是面向连接的协议，数据像水流一样传输，会存在黏包问题。

一个TCP服务端可以同时连接很多个客户端，例如世界各地的用户使用自己电脑上的浏览器访问淘宝网。因为Go语言中创建多个goroutine实现并发非常方便和高效，所以我们可以每建立一次链接就创建一个goroutine去处理。

TCP服务端程序的处理流程：
1.监听端口 2.接收客户端请求建立链接 3.创建goroutine处理链接。

一个TCP客户端进行TCP通信的流程如下：
1.建立与服务端的链接
2.进行数据收发
3.关闭链接 

  1. // tcp/server/main.go
  3. // TCP server端
  5. // 处理函数
  6. func process(conn net.Conn) {
  7.     defer conn.Close() // 关闭连接
  8.     for {
  9.         reader := bufio.NewReader(conn)
  10.         var buf [128]byte
  11.         n, err := reader.Read(buf[:]) // 读取数据
  12.         if err != nil {
  13.             fmt.Println("read from client failed, err:", err)
  14.             break
  15.         }
  16.         recvStr := string(buf[:n])
  17.         fmt.Println("收到client端发来的数据：", recvStr)
  18.         conn.Write([]byte(recvStr)) // 发送数据
  19.     }
  20. }
  22. func main() {
  23.     listen, err := net.Listen("tcp", "127.0.0.1:20000")
  24.     if err != nil {
  25.         fmt.Println("listen failed, err:", err)
  26.         return
  27.     }
  28.     for {
  29.         conn, err := listen.Accept() // 建立连接
  30.         if err != nil {
  31.             fmt.Println("accept failed, err:", err)
  32.             continue
  33.         }
  34.         go process(conn) // 启动一个goroutine处理连接
  35.     }
  36. }

使用Go语言的net包实现的TCP客户端代码如下：

  1. // tcp/client/main.go
  3. // 客户端
  4. func main() {
  5.     conn, err := net.Dial("tcp", "127.0.0.1:20000")
  6.     if err != nil {
  7.         fmt.Println("err :", err)
  8.         return
  9.     }
  10.     defer conn.Close() // 关闭连接
  11.     inputReader := bufio.NewReader(os.Stdin)
  12.     for {
  13.         input, _ := inputReader.ReadString('\n') // 读取用户输入
  14.         inputInfo := strings.Trim(input, "\r\n")
  15.         if strings.ToUpper(inputInfo) == "Q" { // 如果输入q就退出
  16.             return
  17.         }
  18.         _, err = conn.Write([]byte(inputInfo)) // 发送数据
  19.         if err != nil {
  20.             return
  21.         }
  22.         buf := [512]byte{}
  23.         n, err := conn.Read(buf[:])
  24.         if err != nil {
  25.             fmt.Println("recv failed, err:", err)
  26.             return
  27.         }
  28.         fmt.Println(string(buf[:n]))
  29.     }
  30. }

http编程

web工作流程

  • Web服务器的工作原理可以简单地归纳为

    • 客户机通过TCP/IP协议建立到服务器的TCP连接
    • 客户端向服务器发送HTTP协议请求包，请求服务器里的资源文档
    • 服务器向客户机发送HTTP协议应答包，如果请求的资源包含有动态语言的内容，那么服务器会调用动态语言的解释引擎负责处理“动态内容”，并将处理得到的数据返回给客户端
    • 客户机与服务器断开。由客户端解释HTML文档，在客户端屏幕上渲染图形结果

HTTP协议

  • 超文本传输协议(HTTP，HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议，它详细规定了浏览器和万维网服务器之间互相通信的规则，通过因特网传送万维网文档的数据传送协议
  • HTTP协议通常承载于TCP协议之上 ```go package main

import ( “fmt” “net/http” )

func main() { //http://127.0.0.1:8000/go // 单独写回调函数 http.HandleFunc(“/go”, myHandler) //http.HandleFunc(“/ungo”,myHandler2 ) // addr：监听的地址 // handler：回调函数 http.ListenAndServe(“127.0.0.1:8000”, nil) }

// handler函数 func myHandler(w http.ResponseWriter, r *http.Request) { fmt.Println(r.RemoteAddr, “连接成功”) // 请求方式：GET POST DELETE PUT UPDATE fmt.Println(“method:”, r.Method) // /go fmt.Println(“url:”, r.URL.Path) fmt.Println(“header:”, r.Header) fmt.Println(“body:”, r.Body) // 回复 w.Write([]byte(“www.5lmh.com”)) }

  1. ```go
  2. package main
  4. import (
  5.     "fmt"
  6.     "io"
  7.     "net/http"
  8. )
  10. func main() {
  11.     //resp, _ := http.Get("http://www.baidu.com")
  12.     //fmt.Println(resp)
  13.     resp, _ := http.Get("http://127.0.0.1:8000/go")
  14.     defer resp.Body.Close()
  15.     // 200 OK
  16.     fmt.Println(resp.Status)
  17.     fmt.Println(resp.Header)
  19.     buf := make([]byte, 1024)
  20.     for {
  21.         // 接收服务端信息
  22.         n, err := resp.Body.Read(buf)
  23.         if err != nil && err != io.EOF {
  24.             fmt.Println(err)
  25.             return
  26.         } else {
  27.             fmt.Println("读取完毕")
  28.             res := string(buf[:n])
  29.             fmt.Println(res)
  30.             break
  31.         }
  32.     }
  33. }