知道了不行，熟悉也不够，要真正进入潜意识，成为条件反射才行！
多读书，多看报，少吃零食，多睡觉。
golang基本语法中比较有含金量的技能点 1、锁 2、反射 3、并发编程
数据与切片区别
1、数组 值传递
2、切片 引用传递 使用append添加数据
3、map 引用传递
4、指针 引用传递
var声明变量 自动推导可以定义局部变量
go语言和python语言一样支持多返回值，也就是说函数可以一次性返回多个值，这和其他语言有着显著的不同。
go语言中数组是值传递，这和其他的语言有着很大的不同，切片是引用传递。
Go 是静态类型语⾔，不能在运⾏期改变变量类型。使⽤关键字 var 定义变量，⾃动初始化为零值。如果提供初始化值，可省略变量类型，由
编译器⾃动推断。
var x int
var f float32 = 1.6
var s = "abc"
在函数内部，可⽤更简略的 “:=” ⽅式定义变量。
func main() {
x := 123
// 注意检查，是定义新局部变量，还是修改全局变量。该⽅式容易造成错误。
}
可⼀次定义多个变量。
var x, y, z int
var s, n = "abc", 123
var (
a int
b float32
)
func main() {
n, s := 0x1234, "Hello, World!"
println(x, s, n)
}多变量赋值时，先计算所有相关值，然后再从左到右依次赋值。
data, i := [3]int{0, 1, 2}, 0
i, data[i] = 2, 100+l
// (i = 0) -> (i = 2), (data[0] = 100)特殊只写变量 “_”，⽤于忽略值占位。
func test() (int, string) {
return 1, "abc"
}
func main() {
_, s := test()
println(s)
}编译器会将未使⽤的局部变量当做错误。
var s string
func main() {
i := 0
// 全局变量没问题。
// Error: i declared and not used。(可使⽤ "_ = i" 规避)
}
注意重新赋值与定义新同名变量的区别。
引⽤类型
引⽤类型包括 slice、map 和 channel。它们有复杂的内部结构，除了申请内存外，还需
要初始化相关属性。
内置函数 new 计算类型⼤⼩，为其分配零值内存，返回指针。⽽ make 会被编译器翻译成具体的创建函数，由其分配内存和初始化成员结构，返回对象⽽⾮指针。
a := []int{0, 0, 0}
a[1] = 10
b := make([]int, 3)
b[1] = 10
c := new([]int)
c[1] = 10
// 提供初始化表达式。
// makeslice
// Error: invalid operation: c[1] (index of type *[]int)类型转换
不⽀持隐式类型转换，即便是从窄向宽转换也不⾏。
var b byte = 100
// var n int = b
var n int = int(b)
// Error: cannot use b (type byte) as type int in assignment
// 显式转换
使⽤括号避免优先级错误。
*Point(p)
(*Point)(p)
<-chan int(c)
(<-chan int)(c)
// 相当于 *(Point(p))
// 相当于 <-(chan int(c))
同样不能将其他类型当 bool 值使⽤。
a := 100
if a {
println("true")
// Error: non-bool a (type int) used as if condition
}
字符串
字符串是不可变值类型，内部⽤指针指向 UTF-8 字节数组。
• 默认值是空字符串 “”。
• ⽤索引号访问某字节，如 s[i]。
• 不能⽤序号获取字节元素指针，&s[i] ⾮法。
• 不可变类型，⽆法修改字节数组。
• 字节数组尾部不包含 NULL。
struct String
{
byte*
intgo
str;
len;
};
使⽤索引号问字符 (byte)。
s := "abc"
println(s[0] == '\x61', s[1] == 'b', s[2] == 0x63)
输出：
true true true
使⽤ “`” 定义不做转义处理的原始字符串，⽀持跨⾏。
s := `a
b\r\n\x00
c`
println(s)
输出:
a
b\r\n\x00
c
连接跨⾏字符串时，"+" 必须在上⼀⾏末尾，否则导致编译错误。
s := "Hello, " +
"World!"
s2 := "Hello, "
+ "World!"
// Error: invalid operation: + untyped string
⽀持⽤两个索引号返回⼦串。⼦串依然指向原字节数组，仅修改了指针和⻓度属性。
s := "Hello, World!"
s1 := s[:5]
// Hello
s2 := s[7:]
s3 := s[1:5]
// Hello
// World!
// ello
golang中http的函数原型
func HandleFunc(pattern string, handler func(ResponseWriter, *Request))
func ListenAndServe(addr string, handler Handler) error
tcp函数原型
服务端
func Listen(network, address string) (Listener, error)
listener.Accept() Accept() (Conn, error)
客户端
func Dial(network, address string) (Conn, error)
Write(b []byte) (n int, err error)
获取到Conn后就可以从中进行读写
简单tcp服务器
package main
import (
"net"
"fmt"
"io"
)
func main() {
listener, e := net.Listen("tcp", "192.168.28.30:9999")
if e!=nil {
fmt.Println(e)
}
defer listener.Close()
i:=1
for ; ; {
conn, err := listener.Accept()
if err!=nil {
fmt.Println(err)
}
go func() {
buf := make([]byte, 2048)
for ; ; {
n, err2 := conn.Read(buf)
if err2 != nil {
fmt.Println(err2)
}
if err2==io.EOF {
break
}
i++
fmt.Println("==========",i,"===========")
fmt.Println(string(buf[:n]))
}
}()
}
}
