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

}