go语言核心详解

知道了不行，熟悉也不够，要真正进入潜意识，成为条件反射才行！
多读书，多看报，少吃零食，多睡觉。

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

}