go语言

2020-11-04

https://tour.golang.org/welcome/1

go语言高级编程：https://books.studygolang.com/advanced-go-programming-book/

hello world

package main

import "fmt"

func main(){
    fmt.Println("hello world!")
}

Go语言开发环境搭建

安装

参考 https://golang.google.cn/dl/

正常安装就好，然后在cmd下输入go version试试，能不能得到结果。

windows下GOPATH配置

GOPATH是一个环境变量，用来表明你写的go项目的存放路径，gopath最好只设置一个，所有的项目代码都放置到GOPATH的src目录下。

在D盘下新建一个目录比如，D:\documents\go，这个路径作为系统环境变量GOPATH的值。可能用户环境变量也有个GOPATH，是C:\Users\zhou2，把这个删了。
在D:\documents\go下新建三个文件夹：src，pkg，bin。
将D:\documents\go\bin加入到系统环境变量PATH中。
在cmd中输入go env查看GOPATH是否正确。

go get 包可以使用了, 最后包会安装到 D:\documents\go目录的pkg和src文件夹里, pkg里是*.a格式的, 暂且理解为库吧, src目录里是*.go格式的源码。

项目结构

适合个人开发者

流行的项目结构

适合企业开发者

VS code

使用vs code来编辑go代码，首先在vs code里面安装goz扩展插件。在侧边栏的extensions选项中搜索go，然后安装就好了。

使用vs code打开D:\documents\go\src文件夹，在里面新建go文件写代码。

这时，问题来了：由于网络的原因，vs code内部不自己下载很多插件，所以必须我们自己上VPN从github上下载，然后在vs code中安装：

进入项目地址D:\documents\go\src\github.com\zhouhuahui\helloWorld
然后打开git，执行git clone https://github.com/golang/tools.git tools
返回到vs code中的项目
使用快捷键ctrl+shift+p，打开了vs code的命令行，执行Go:Install/Update Tools，然后在下面出现的很多选项中全部选中，点击OK，然后等待vs code安装所有的插件，并全部显示succeed。

在项目内写代码时，比如helloWorld项目，首先在helloWorld内部，打开cmd（我想在vs code内的terminal内也可以，注意terminal定位到helloWorld目录下），执行go mod init helloWorld。之后才能运行go build和helloWorld.exe执行代码。还有，terminal要是cmd形式的，而不是powershell。

go install错误

1	A connection attempt failed because the connected party did not prope

其实这个错误不是网络原因，可以使用下述命令使用go模块代理，这样go install或者go get就不会报错了。参考：https://goproxy.cn/

1 2	go env -w GO111MODULE=on go env -w GOPROXY=https://goproxy.cn,direct

然后创建$GOPATH/src/golang.org/x文件夹，cd到此文件夹，执行

1
2
3

git clone https://github.com/golang/tools.git
git clone https://github.com/golang/lint.git
go get golang.org/x/lint/golint

然后重启VSCode就好了。

参考：
https://www.jianshu.com/p/4f2c476e189a
https://blog.csdn.net/qq_36546907/article/details/83958134

最后安装的包都在$GOPATH/pkg/mod里面：

go语言基础

变量和常量

go语言中值得注意的关键字。

func  func        interface  select  
defer go          map        chan
goto  fallthrough range      type
var

标识符

用来表示变量名，函数名，类型名，方法名。在go语言中，标识符有些特殊，如果标识符的首字母是大写的，那么就表示对外部可见，否则对外部不可见。

变量

值得注意的保留字。

Constants: true false iota nil

Type: int int8 int16 int32 int64
      uint uint8 uint32 uint64 uintptr
      float32 float64 complex128 complex64
      bool byte rune string error
      chan map func

Functions: make len cap new append copy close delete
           complex real imag
           panic recover

变量的声明：

1	var s1 string

// 批量声明
var(
	name string
    age int
    isOk bool
)
func main(){
    fmt.Print(isOk)
    fmt.Printf("name:%s", name)
    fmt.Println(age)
}

常量

如何声明常量

const pi = 3.14 // 不需要指明类型

// 批量声明常量时，如果某一行声明后没有赋值，默认就和上一行一致
const(
	n1 = 100
    n2
    n3
)

// iota
// 在const关键字出现时将被重置为0，const中每新增一行常量声明
// 将使iota计数一次
const (
	n1 = iota // 0
    n2        // 1
    n3        // 2
    n4        // 3
)
const (
	b1 = iota // 0
    b2        // 1
    _       
    b3        // 3
)
// 插队
const (
	c1 = iota // 0
    c2 = 100
    c3 = iota // 2
)
// 多个常量声明在一行
const (
	d1, d2 = iota+1, iota+2 // 1, 2
    d3, d4 = iota+1, iota+2 // 2, 3
)

类型

基础类型：bool, string和其他数字类型

聚合类型：数组和结构体类型

引用类型：通道chan, 函数func, 指针, 切片slice, map

变量声明

在全局声明的变量是可以不使用的，但是在函数中声明的变量是要必须使用的，否则会编译不过去。

声明变量同时赋值

1	var s1 string = "zhou"

类型推导（根据值来判断变量是什么类型）

1	var s2 = "20"

在函数内部，可以使用更简短的:=方式声明并初始化变量

1
2
3

func main(){
    n := 10
}

匿名变量

func foo() (int, string){
    return 10, "zhou"
}
func main(){
    x, _ = foo() // _是匿名变量
}

字符串

go语言字符串内部支持UTF-8编码。

字符串用双引号包裹的，字符是用单引号包裹的，和C++语言类似。字符串也可以通过`符号来包裹多行的语句，类似于js语言。

import (
	"fmt"
	"strings"
)

func main(){
    s := `
	吉林大学
		计算机
    `
    // +号进行字符串拼接

    // Split()函数来分割字符串
    s = "D:\\documents\\GitRep"
    ret := strings.Split(s, "\\")
    fmt.Println(ret)
    
    // 其他的函数以后再说
}

import (
	"fmt"
	"strings"
)

func main(){
    s := `
	吉林大学
		计算机
    `
    s = "D:\\documents\\GitRep周"
    // 遍历每个字节，并打印所表示的数字，前面的英文字符对应一个字节，最后的"周"会对应三个字节
    for i:=0; i<len(s); i++ {
        fmt.Println(s[i])
    }
    
    // 拿出具体的字符打印
    for _, c := range s{
        fmt.Printf("%c\n", c)
    }
    
    // 字符串修改；rune切片，存储很多rune类型的数组
    // 不能直接更改字符串，这样是会报错的
    s2 := []rune(s) // rune就是int32类型
    s2[0] = 'C'
    fmt.Println(string(s2)) // 把rune切片强制转换为字符串
}

go语言没有自动类型转换，只能进行强制类型转换

数组

数组的初始化

func main(){
    // 定义一个长度为3，存储int类型元素的数组a
    var a [3]int

    // 初始化1
    a = [3]int{0, 1, 2}

    // 初始化2：根据初始值自动推断数组长度
    a2 := [...]int{0, 1, 2, 3, 4}
    
    // 初始化3：根据索引初始化
    a3 := [5]int{0:1, 4:2}
}

数组的遍历

func main(){
    a3 := [5]int{0:1, 4:2}
    
    // 1. for循环遍历

    // 2. for range遍历
    for i, v := range a3{
        fmt.Println(i, v)
    }
}

二维数组：

1
2
3

func main(){
    var a [3][2]int
}

一个数组可以被其他数组初始化，但是不能被其他数组赋值

func main(){
    a3 := [5]int{0: 1, 4: 2}

	var a4 [5]int = a3
	fmt.Println(a4)
}

切片Slice

切片Slice是一个拥有相同类型元素的可变长度的序列，它是基于数组类型做的一层封装，非常灵活，支持自动扩容。切片是一个引用类型，它的内部结构包含地址，长度和容量。切片一般用于快速地操作一块数据集合。

切片的定义

func main(){
    var a []int // 中括号中没有长度，等于nil，因为a不指向任何底层数组   
    var s []string{"zhou"} // 定义并初始化，不等于nil
}

通过内置的len()和cap()函数可以得到切片的长度和容量。

由数组得到切片

func main(){
    a1 := [...]int{1,3,5,7,9,11,13}
    a2 := a1[0:4] // a1的切片，a2是指向a1数组的地址的
    
    // 创建字符切片
    a := []byte("ab") // 注意这里是小括号，而不是大括号
	b := []byte("ab")
}

由make()函数创建一个切片。前面的切片创建方式都不是动态的，没法指定切片的长度和容量。

1
2
3

func main(){
    a := make([]int, 5, 10) // 切片长度是5，容量是10
}

如果make函数只有两个参数，那么第二个参数表示切片的长度。

要判断一个切片是否是空的，要用len()函数来判断。

切片只是保存了一个数组的元数据，因此切片之间的拷贝，仅仅复制了元数据，而没有复制数组本身。

append()

调用append()函数来向切片中新增元素

func main(){
    s1 := []string{"北京","上海","深圳"}
    
    // 调用append()函数必须使用原来的切片变量保存返回值
    // 因为append后，底层数组的物理位置改变了
    // 如果不用原来的切片变量保存返回值的话，s1就指向错误的地址  
    s1 = append(s1, "广州")
    ss := []string{"武汉","西安"}
    // 把ss切片中的数据都追加到s1中
    s1 = append(s1, ss...) // ...表示将ss拆分为多个字符串  
}

copy()

copy()函数实现将一个切片的数据复制到另一个切片空间中

func main(){
    a1 := []int{1,3,5}
    var a2 []int = make([]int, 3, 3)
    copy(a2, a1) // 要保证a2的长度大于等于a1的长度
}

判断切片是否相等

使用bytes包

a := []byte("ab")
b := []byte("ab")
flag := bytes.Equal(a, b)
fmt.Println(flag)  // true

map

例子

package bayes

import "fmt"

var probY map[string]float64              // P(Y)
var probX1Y map[string]map[string]float64 // P(X1|Y)
var probX2Y map[string]map[string]float64 // P(X2|Y)

func Init() {
	probY = make(map[string]float64)

	probX1Y = make(map[string]map[string]float64)
	probX1Y["1"] = make(map[string]float64)
	probX1Y["-1"] = make(map[string]float64)

	probX2Y = make(map[string]map[string]float64)
	probX2Y["1"] = make(map[string]float64)
	probX2Y["-1"] = make(map[string]float64)
}

/*
 * this bayes classifier is only for example4.1, so we have strict restrictions about input
 * data: [{X1, X2, Y}] data is array of {X1, X2, Y}
 * X1: the first feature of all samples, X1 in {1, 2, 3}
 * X2: the second feature of all samples, X2 in {S, M, L}
 * Y: the labeled class of all samples, Y in {1, -1}
 * the trained output is stored in all kinds of maps which indicate the probabilities of certain events happening
 */
func BayesTrain(data [][3]string) {
	for key, value := range data {
		fmt.Printf("index:%d, sample:{%s, %s, %s}\n", key, value[0], value[1], value[2])
	}
}

package bayes

import (
	"testing"
)

func testBayes(t *testing.T) {
	Init()
	var data [][3]string = make([][3]string, 0)
	data = append(data, [3]string{"1", "S", "-1"})
	data = append(data, [3]string{"1", "M", "-1"})
	BayesTrain(data)
}
func TestBayes(t *testing.T) {
	t.Run("testBayes", testBayes)
}

循环

for循环

Go 语言可以使用 for range 遍历数组、切片、字符串、map 及通道（channel）。通过 for range 遍历的返回值有一定的规律：

数组、切片、字符串返回索引和值。
map 返回键和值。
通道（channel）只返回通道内的值。

遍历数组，切片获得索引和元素

1
2
3

for key, value := range []int{1, 2, 3}{
    fmt.Println("key:%d value:%d\n", key, value)
}

遍历map, 获得map的键和值

m := map[string]int{
    "hello": 100,
    "world": 200,
}
for key, value := range m{
    fmt.Println(key, value)
}

函数

// ret是返回值
func f(x int, y int) (ret int){
    ret = x+y;
    return
}
func f2(x int, y int) int{
    return x+y;
}

func f3() (int, int){
    return 1, 2
}

defer

在golang当中，defer代码块会在函数调用链表中增加一个函数调用。这个函数调用不是普通的函数调用，而是会在函数正常返回，也就是return之时添加一个函数调用。因此，defer通常用来释放函数内部变量。

多个defer语句按照先进后出的顺序延迟执行。

go语言的return语句不是原子操作，这个和defer有关。

func f1() int{
    x := 5
    defer func(){
        x++
    }()
    return x
}
func f2() (x int){
    x := 5
    defer func(){
        x++
    }()
}
func f3()(y int){
    x := 5
    defer func(){
        x++
    }()
    return x
}
func main(){
    fmt.Println(f1()) // 5
    fmt.Println(f2()) // 6
    fmt.Println(f3()) // 5
}

结构体

结构体定义

type person struct{
    name string
    age int
    hobby []string
}

方法

type dog struct{
    name string
}
// 方法是作用于特定类型的函数
// 通过d可以访问到结构体类型变量的属性，d就是接收者
func (d dog)wang(){
    fmt.Printf("%s: 汪汪汪!",d.name)
}

值接收者和指针接收者

指针接收者可以改变值。

type dog struct{
    name string
}
// 值接收者
func (d dog)changeName(){
    d.name = "newName"
}
// 指针接收者
func (d *dog)changeName2(){
    d.name = "newName"
}
func main(){
    var d dog
    d.name = "name"
    d.changeName()
    fmt.Println(d.name) // name
    d.changeName2()
    fmt.Println(d.name) // newName
}

import

import(
    "time" //普通写法
    . "fmt" //使用此包内的成员时不带fmt前缀
    j "encoding/json" //json包重命名
    _ "net" //仅执行net包中的init方法，不能调用该包成员
)

使用规范

不要使用相对路径引入包(以GOPATH/src作为根目录)
引入包顺序遵循标准库，项目包，第三方包
第三方包按命名顺序

比如：

import(
    "fmt"
    "time" //标准库
    
    "controllers/doctor"
    "controllers/student" //项目包
    
    "models/person" //项目包
    
    "github.com/garyburd/redigo/redis"
    "github.com/go-sql-driver/mysql" //第三方包
)

第三方包应该会放在go/bin/pkg/里面。

接口

接口是一种类型；

type speaker interface{
    speak() // 只要实现了speak函数，就都是speaker接口。这是方法签名
}
type cat struct{}
type dog struct{}

func (c cat) speak(){
    fmt.Println("喵喵喵")
}
func (d dog) speak(){
    fmt.Println("汪汪汪")
}

func da(x speaker){
    x.speak()
}

func main(){
    var c cat
    var d dog
    da(c); // 喵喵喵
    da(d); // 汪汪汪
}

接口的实现

type 接口名 interface{
    方法1(参数1, 参数2...)(返回值1, 返回值2...)
    方法2(参数1, 参数2...)(返回值1, 返回值2...)
}

如果一个变量中实现了接口规定的所有方法，这个变量就实现了这个接口。

值接收者和指针接收者实现接口：

type speaker interface{
    speak() // 只要实现了speak函数，就都是speaker接口。这是方法签名
}
type cat struct{}
type dog struct{}

// 值接收者实现
func (c cat) speak(){
    fmt.Println("喵喵喵")
}
func (d dog) speak(){
    fmt.Println("汪汪汪")
}

func main(){
    var s speaker
    var c cat
    var d *dog = &dog{}
    s = c
    s.speak()
    s = d
    s.speak()
}

type speaker interface{
    speak() // 只要实现了speak函数，就都是speaker接口。这是方法签名
}
type cat struct{}
type dog struct{}

// 指针接收者实现
func (c *cat) speak(){
    fmt.Println("喵喵喵")
}
func (d *dog) speak(){
    fmt.Println("汪汪汪")
}

func main(){
    var s speaker
    var c cat
    var d *dog = &dog{}
    s = c // 报错，因为对于指针接收者实现接口的变量，要用它的指针形式
    s.speak()
    s = d
    s.speak()
}

空接口

1	interface{} // 空接口

如果一个函数的参数可以是任何类型，那么就设置为空接口类型。

如果我们想要map的键是string类型，但是值是不一定的类型，就可以用空接口了。

func main(){
    var m1 map[string]interface{}
    m1 = make(map[string]interface{}, 16)
    m1["name"] = "周琳"
    m1["age"] = 9000
    m1["married"] = true
    m1["hobby"] = [...]string{"sing", "dance", "rap", "basketball"}
    fmt.Println(m1)
}

通过断言判断空接口的动态类型

func assign(a interface{}){
    switch t := a.(type){
    case string:
        fmt.Println("string", t)
    case int:
        fmt.Println("int", t)
    }
}

如果我们知道了一个空接口类型变量的动态类型是int，则可以使用类型断言，来转换为对应的类型。

func main(){
    var a interface{} = 3
	b := a.(int)
	fmt.Printf("%#T",b) // int
}

文件操作

创造一个文件：

1
2
3

import "os"
oname := "mr-out-0" //文件的相对路径或绝对路径
ofile,_ = os.Create(oname)

打开文件：

import "os"
import "log"
filename = "file1.txt"
file,err = os.Open(filename)
if err!=nil{
    log.Fatalf("cannot open %v",filename)
}

读取文件：

1 2	import "io/ioutil" content,err := ioutil.ReadAll(file)

strconv包

如果使用string方法来给一个int32类型的变量转换为字符串，那么就会产生这个int类型底层二进制表示在UTF-8编码中对应的字符。

func main(){
    i := int32(2316)
    ret := string(i)
    fmt.Println(ret)
}
// 输出在下面

ऌ

使用fmt.Sprintf()函数可以将数字转换为字符串

func main(){
    i := 2316
    ret := fmt.Sprintf("%d", i)
    fmt.Println(ret)
    fmt.Printf("%#v", ret)
}
// 输出

1 2	2316 "2316"

使用strconv包进行类型转换

import (
	"fmt"
	"strconv"
)

func main() {
	// 字符串到数字
	str := "1000"
	ret1, err := strconv.ParseInt(str, 10, 64) // 10进制，64位
	if err != nil {
		fmt.Println("Parseint failed, err: ", err)
	} else {
		fmt.Printf("%#v", ret1)
	}
}

time包

import (
	"fmt"
    "time"
)
func main(){
    now := time.Now() // 获取当前时间
	fmt.Println(now.Year())
	fmt.Println(now.Month())
	fmt.Println(now.Date())
	fmt.Println(now.Hour())
	fmt.Println(now.Minute())
	fmt.Println(now.Second())

	// 时间戳
	timestamp1 := now.Unix()     // 时间戳
	timestamp2 := now.UnixNano() // 纳秒时间戳
	t1 := time.Unix(timestamp1, 0)
	fmt.Println(timestamp1)
	fmt.Println(timestamp2)
	fmt.Println(t1)

	// 时间间隔
	//time.Second // time.Duration类型
	fmt.Println(now.Add(24 * time.Hour)) // 24h之后的时间   
    
    // 定时器
    timer := time.Tick(time.Second) // 每隔一秒钟返回当前时间
    for t :=range timer{
        fmt.Println(t)
    }
}

reflect包

it’s all relative

I started learning golang a couple of days ago and found reflect.Valueof() and Value.Elem() quite confusing. What is the difference between this two function/methods and how to use them correctly?

Both function/methods return a Value, and according to the go doc

ValueOf returns a new Value initialized to the concrete value stored in the interface i. ValueOf(nil) returns the zero Value.Elem returns the value that the interface v contains or that the pointer v points to. It panics if v’s Kind is not Interface or Ptr. It returns the zero Value if v is nil.

interface 和反射

在讲反射之前，先来看看Golang关于类型设计的一些原则

变量包括（type, value）两部分
- 理解这一点就知道为什么nil != nil了
type 包括 static type和concrete type. 简单来说 static type是你在编码是看见的类型(如int、string)，concrete type是runtime系统看见的类型
类型断言能否成功，取决于变量的concrete type，而不是static type. 因此，一个 reader变量如果它的concrete type也实现了write方法的话，它也可以被类型断言为writer.

接下来要讲的反射，就是建立在类型之上的，Golang的指定类型的变量的类型是静态的（也就是指定int、string这些的变量，它的type是static type），在创建变量的时候就已经确定，反射主要与Golang的interface类型相关（它的type是concrete type），只有interface类型才有反射一说。

在Golang的实现中，每个interface变量都有一个对应pair，pair中记录了实际变量的值和类型:

1	(value, type)

value是实际变量值，type是实际变量的类型。一个interface{}类型的变量包含了2个指针，一个指针指向值的类型【对应concrete type】，另外一个指针指向实际的值【对应value】。

例如，创建类型为*os.File的变量，然后将其赋给一个接口变量r：

tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)

var r io.Reader
r = tty

接口变量r的pair中将记录如下信息：(tty, *os.File)，这个pair在接口变量的连续赋值过程中是不变的，将接口变量r赋给另一个接口变量w:

1 2	var w io.Writer w = r.(io.Writer)

接口变量w的pair与r的pair相同，都是:(tty, *os.File)，即使w是空接口类型，pair也是不变的。

interface及其pair的存在，是Golang中实现反射的前提，理解了pair，就更容易理解反射。反射就是用来检测存储在接口变量内部(值value；类型concrete type) pair对的一种机制。

Golang的反射reflect

reflect的基本功能TypeOf和ValueOf

既然反射就是用来检测存储在接口变量内部(值value；类型concrete type) pair对的一种机制。那么在Golang的reflect反射包中有什么样的方式可以让我们直接获取到变量内部的信息呢？它提供了两种类型（或者说两个方法）让我们可以很容易的访问接口变量内容，分别是reflect.ValueOf() 和 reflect.TypeOf()，看看官方的解释

// ValueOf returns a new Value initialized to the concrete value
// stored in the interface i.  ValueOf(nil) returns the zero 
func ValueOf(i interface{}) Value {...}

翻译一下：ValueOf用来获取输入参数接口中的数据的值，如果接口为空则返回0


// TypeOf returns the reflection Type that represents the dynamic type of i.
// If i is a nil interface value, TypeOf returns nil.
func TypeOf(i interface{}) Type {...}

翻译一下：TypeOf用来动态获取输入参数接口中的值的类型，如果接口为空则返回nil

reflect.TypeOf()是获取pair中的type，reflect.ValueOf()获取pair中的value，示例如下：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var num float64 = 1.2345

	fmt.Println("type: ", reflect.TypeOf(num))
	fmt.Println("value: ", reflect.ValueOf(num))
}

运行结果:
type:  float64
value:  1.2345

reflect.TypeOf：直接给到了我们想要的type类型，如float64、int、各种pointer、struct 等等真实的类型
reflect.ValueOf：直接给到了我们想要的具体的值，如1.2345这个具体数值，或者类似&{1 “Allen.Wu” 25} 这样的结构体struct的值
也就是说明反射可以将“接口类型变量”转换为“反射类型对象”，反射类型指的是reflect.Type和reflect.Value这两种

从relfect.Value中获取接口interface的信息

当执行reflect.ValueOf(interface)之后，就得到了一个类型为”relfect.Value”变量，可以通过它本身的Interface()方法获得接口变量的真实内容，然后可以通过类型判断进行转换，转换为原有真实类型。不过，我们可能是已知原有类型，也有可能是未知原有类型，因此，下面分两种情况进行说明。

已知原有类型【进行“强制转换”】

已知类型后转换为其对应的类型的做法如下，直接通过Interface方法然后强制转换，如下：

1	realValue := value.Interface().(已知的类型)

示例如下：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var num float64 = 1.2345

	pointer := reflect.ValueOf(&num)
	value := reflect.ValueOf(num)

	// 可以理解为“强制转换”，但是需要注意的时候，转换的时候，如果转换的类型不完全符合，则直接panic
	// Golang 对类型要求非常严格，类型一定要完全符合
	// 如下两个，一个是*float64，一个是float64，如果弄混，则会panic
	convertPointer := pointer.Interface().(*float64)
	convertValue := value.Interface().(float64)

	fmt.Println(convertPointer)
	fmt.Println(convertValue)
}

运行结果：
0xc42000e238
1.2345

转换的时候，如果转换的类型不完全符合，则直接panic，类型要求非常严格！
转换的时候，要区分是指针还是指
也就是说反射可以将“反射类型对象”再重新转换为“接口类型变量”

未知原有类型【遍历探测其Filed】

很多情况下，我们可能并不知道其具体类型，那么这个时候，该如何做呢？需要我们进行遍历探测其Filed来得知，示例如下:

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Id   int
	Name string
	Age  int
}

func (u User) ReflectCallFunc() {
	fmt.Println("Allen.Wu ReflectCallFunc")
}

func main() {

	user := User{1, "Allen.Wu", 25}

	DoFiledAndMethod(user)

}

// 通过接口来获取任意参数，然后一一揭晓
func DoFiledAndMethod(input interface{}) {

	getType := reflect.TypeOf(input)
	fmt.Println("get Type is :", getType.Name())

	getValue := reflect.ValueOf(input)
	fmt.Println("get all Fields is:", getValue)

	// 获取方法字段
	// 1. 先获取interface的reflect.Type，然后通过NumField进行遍历
	// 2. 再通过reflect.Type的Field获取其Field
	// 3. 最后通过Field的Interface()得到对应的value
	for i := 0; i < getType.NumField(); i++ {
		field := getType.Field(i)
		value := getValue.Field(i).Interface()
		fmt.Printf("%s: %v = %v\n", field.Name, field.Type, value)
	}

	// 获取方法
	// 1. 先获取interface的reflect.Type，然后通过.NumMethod进行遍历
	for i := 0; i < getType.NumMethod(); i++ {
		m := getType.Method(i)
		fmt.Printf("%s: %v\n", m.Name, m.Type)
	}
}

运行结果：
get Type is : User
get all Fields is: {1 Allen.Wu 25}
Id: int = 1
Name: string = Allen.Wu
Age: int = 25
ReflectCallFunc: func(main.User)

通过运行结果可以得知获取未知类型的interface的具体变量及其类型的步骤为：

先获取interface的reflect.Type，然后通过NumField进行遍历
再通过reflect.Type的Field获取其Field
最后通过Field的Interface()得到对应的value

通过运行结果可以得知获取未知类型的interface的所属方法（函数）的步骤为：

先获取interface的reflect.Type，然后通过NumMethod进行遍历
再分别通过reflect.Type的Method获取对应的真实的方法（函数）
最后对结果取其Name和Type得知具体的方法名
也就是说反射可以将“反射类型对象”再重新转换为“接口类型变量”
struct 或者 struct 的嵌套都是一样的判断处理方式

通过reflect.Value设置实际变量的值

reflect.Value是通过reflect.ValueOf(X)获得的，只有当X是指针的时候，才可以通过reflec.Value修改实际变量X的值，即：要修改反射类型的对象就一定要保证其值是“addressable”的。

示例如下：

package main

import (
	"fmt"
	"reflect"
)

func main() {

	var num float64 = 1.2345
	fmt.Println("old value of pointer:", num)

	// 通过reflect.ValueOf获取num中的reflect.Value，注意，参数必须是指针才能修改其值
	pointer := reflect.ValueOf(&num)
	newValue := pointer.Elem()

	fmt.Println("type of pointer:", newValue.Type())
	fmt.Println("settability of pointer:", newValue.CanSet())

	// 重新赋值
	newValue.SetFloat(77)
	fmt.Println("new value of pointer:", num)

	////////////////////
	// 如果reflect.ValueOf的参数不是指针，会如何？
	pointer = reflect.ValueOf(num)
	//newValue = pointer.Elem() // 如果非指针，这里直接panic，“panic: reflect: call of reflect.Value.Elem on float64 Value”
}

运行结果：
old value of pointer: 1.2345
type of pointer: float64
settability of pointer: true
new value of pointer: 77

需要传入的参数是 float64这个指针，然后可以通过pointer.Elem()去获取所指向的Value，*注意一定要是指针。
如果传入的参数不是指针，而是变量，那么
- 通过Elem获取原始值对应的对象则直接panic
- 通过CanSet方法查询是否可以设置返回false
newValue.CantSet()表示是否可以重新设置其值，如果输出的是true则可修改，否则不能修改，修改完之后再进行打印发现真的已经修改了。
reflect.Value.Elem() 表示获取原始值对应的反射对象，只有原始对象才能修改，当前反射对象是不能修改的
也就是说如果要修改反射类型对象，其值必须是“addressable”【对应的要传入的是指针，同时要通过Elem方法获取原始值对应的反射对象】
struct 或者 struct 的嵌套都是一样的判断处理方式

通过reflect.ValueOf来进行方法的调用

这算是一个高级用法了，前面我们只说到对类型、变量的几种反射的用法，包括如何获取其值、其类型、如果重新设置新值。但是在工程应用中，另外一个常用并且属于高级的用法，就是通过reflect来进行方法【函数】的调用。比如我们要做框架工程的时候，需要可以随意扩展方法，或者说用户可以自定义方法，那么我们通过什么手段来扩展让用户能够自定义呢？关键点在于用户的自定义方法是未可知的，因此我们可以通过reflect来搞定

示例如下：

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Id   int
	Name string
	Age  int
}

func (u User) ReflectCallFuncHasArgs(name string, age int) {
	fmt.Println("ReflectCallFuncHasArgs name: ", name, ", age:", age, "and origal User.Name:", u.Name)
}

func (u User) ReflectCallFuncNoArgs() {
	fmt.Println("ReflectCallFuncNoArgs")
}

// 如何通过反射来进行方法的调用？
// 本来可以用u.ReflectCallFuncXXX直接调用的，但是如果要通过反射，那么首先要将方法注册，也就是MethodByName，然后通过反射调动mv.Call

func main() {
	user := User{1, "Allen.Wu", 25}
	
	// 1. 要通过反射来调用起对应的方法，必须要先通过reflect.ValueOf(interface)来获取到reflect.Value，得到“反射类型对象”后才能做下一步处理
	getValue := reflect.ValueOf(user)

	// 一定要指定参数为正确的方法名
	// 2. 先看看带有参数的调用方法
	methodValue := getValue.MethodByName("ReflectCallFuncHasArgs")
	args := []reflect.Value{reflect.ValueOf("wudebao"), reflect.ValueOf(30)}
	methodValue.Call(args)

	// 一定要指定参数为正确的方法名
	// 3. 再看看无参数的调用方法
	methodValue = getValue.MethodByName("ReflectCallFuncNoArgs")
	args = make([]reflect.Value, 0)
	methodValue.Call(args)
}


运行结果：
ReflectCallFuncHasArgs name:  wudebao , age: 30 and origal User.Name: Allen.Wu
ReflectCallFuncNoArgs

要通过反射来调用起对应的方法，必须要先通过reflect.ValueOf(interface)来获取到reflect.Value，得到“反射类型对象”后才能做下一步处理
reflect.Value.MethodByName这.MethodByName，需要指定准确真实的方法名字，如果错误将直接panic，MethodByName返回一个函数值对应的reflect.Value方法的名字。
[]reflect.Value，这个是最终需要调用的方法的参数，可以没有或者一个或者多个，根据实际参数来定。
reflect.Value的 Call 这个方法，这个方法将最终调用真实的方法，参数务必保持一致，如果reflect.Value’Kind不是一个方法，那么将直接panic。
本来可以用u.ReflectCallFuncXXX直接调用的，但是如果要通过反射，那么首先要将方法注册，也就是MethodByName，然后通过反射调用methodValue.Call

Golang的反射reflect性能

Golang的反射很慢，这个和它的API设计有关。在 java 里面，我们一般使用反射都是这样来弄的。

1
2
3

Field field = clazz.getField("hello");
field.get(obj1);
field.get(obj2);

这个取得的反射对象类型是 java.lang.reflect.Field。它是可以复用的。只要传入不同的obj，就可以取得这个obj上对应的 field。

但是Golang的反射不是这样设计的:

1 2	type_ := reflect.TypeOf(obj) field, _ := type_.FieldByName("hello")

这里取出来的 field 对象是 reflect.StructField 类型，但是它没有办法用来取得对应对象上的值。如果要取值，得用另外一套对object，而不是type的反射

1 2	type_ := reflect.ValueOf(obj) fieldValue := type_.FieldByName("hello")

这里取出来的 fieldValue 类型是 reflect.Value，它是一个具体的值，而不是一个可复用的反射对象了，每次反射都需要malloc这个reflect.Value结构体，并且还涉及到GC。

Golang reflect慢主要有两个原因

涉及到内存分配以及后续的GC；
reflect实现里面有大量的枚举，也就是for循环，比如类型之类的。

总结

上述详细说明了Golang的反射reflect的各种功能和用法，都附带有相应的示例，相信能够在工程应用中进行相应实践，总结一下就是：

反射可以大大提高程序的灵活性，使得interface{}有更大的发挥余地
- 反射必须结合interface才玩得转
- 变量的type要是concrete type的（也就是interface变量）才有反射一说
反射可以将“接口类型变量”转换为“反射类型对象”
- 反射使用 TypeOf 和 ValueOf 函数从接口中获取目标对象信息
反射可以将“反射类型对象”转换为“接口类型变量
- reflect.value.Interface().(已知的类型)
- 遍历reflect.Type的Field获取其Field
反射可以修改反射类型对象，但是其值必须是“addressable”
- 想要利用反射修改对象状态，前提是 interface.data 是 settable,即 pointer-interface
通过反射可以“动态”调用方法
因为Golang本身不支持模板，因此在以往需要使用模板的场景下往往就需要使用反射(reflect)来实现

参考链接

encoding/base64包

导入方式：

1	import "encoding/base64"

base64实现了RFC 4648规定的base64编码。Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符（即6Bits）来表示二进制数据(即8Bits)的方法。Base64编码是从二进制到字符的过程，可用于在HTTP环境下传递较长的标识信息，这样更适合放在URL中进行传递。此时，采用Base64编码具有不可读性，需要解码后才能阅读。

该编码的规则就是：

把3个字符变成4个字符：方法就是先将3个8Bits（38=24Bits）的值分成4个6Bits的值（46=24Bits），然后在这四个6Bits值前添加两个0将其变为8Bits的值，这样就能够保证生成的4个值表示的值大小为（0～63），即可以将其转成对应的ASCII码（64个可打印字符）举例：

转换前：          01110011 00110001 00110011
拆分成4份：        011100 110011 000100 110011
高位补0:          00011100 00110011 00000100 00110011
对应的值为：       28 51 4 51
转成对应的ASCII码： c z E z

每76个字符加一个换行符
最后的结束符也要处理

然而，标准的Base64并不适合直接放在URL里传输，因为URL编码器会把标准Base64中的“/”和“+”字符变为形如“%XX”的形式，而这些“%”号在存入数据库时还需要再进行转换，因为ANSI SQL中已将“%”号用作通配符。

为解决此问题，可采用一种用于URL的改进Base64编码，它不仅在末尾去掉填充的’=’号，并将标准Base64中的“+”和“/”分别改成了“-”和“_”，这样就免去了在URL编解码和数据库存储时所要作的转换，避免了编码信息长度在此过程中的增加，并统一了数据库、表单等处对象标识符的格式。

type Encoding

1
2
3

type Encoding struct {
    // 内含隐藏或非导出字段
}

双向的编码/解码协议，根据一个64字符的字符集定义，RFC 4648标准化了两种字符集。默认字符集用于MIME（RFC 2045）和PEM（RFC 1421）编码；另一种用于URL和文件名，用’-‘和’_’替换了’+’和’/‘。

下面的两个函数分别就是编码和解码的过程：

func (*Encoding) EncodeToString

1	func (enc *Encoding) EncodeToString(src []byte) string

返回将src编码后的字符串。

func (*Encoding) DecodeString

1	func (enc *Encoding) DecodeString(s string) ([]byte, error)

返回base64编码的字符串s代表的数据。

举例：

package main 
import(
    "fmt"
    "encoding/base64"
)

func main() { 
    msg := "Hello,world" //11个字符应该装成15个base64编码的字符
    encoded := base64.StdEncoding.EncodeToString([]byte(msg))
    fmt.Println(encoded) //SGVsbG8sd29ybGQ=,后面的=是作填充用的
    // 解码后的字节数一定是4的倍数，如果不是就补充=号
    
    decoded, err := base64.StdEncoding.DecodeString(encoded)
    if err != nil {
        fmt.Println("decode error:", err)
        return
    }
    fmt.Println(string(decoded))//Hello,world
}

下面的方法不是将他们编码成字符串：

解码字符：

func (*Encoding) DecodedLen

1	func (enc *Encoding) DecodedLen(n int) int

返回n字节base64编码的数据解码后的最大长度。

func (*Encoding) Decode

1	func (enc *Encoding) Decode(dst, src []byte) (n int, err error)

将src的数据解码后存入dst，最多写DecodedLen(len(src))字节数据到dst，并返回写入的字节数。如果src包含非法字符，将返回成功写入的字符数和CorruptInputError。换行符（\r、\n）会被忽略。

举例：

package main 
import(
    "encoding/base64"
    "log"
    "fmt"
    "io"
)

func main() { 
    encoded := "Zm9vLGJhcg=="
    n := base64.StdEncoding.DecodedLen(len(encoded))//DecodedLen返回len(encoded)字节base64编码的数据解码后的最大长度
    fmt.Println(n) //9
    dbuf := make([]byte, n) 
    _, err :=base64.StdEncoding.Decode(dbuf, []byte(encoded))

    if err != nil && err != io.EOF {
        log.Fatal("Read failed", err)
    }
    fmt.Printf("decoded result : %s\n", dbuf) //decoded result : foo,bar
}

下面两个代码组合进行编码：

func (*Encoding) EncodedLen

1	func (enc *Encoding) EncodedLen(n int) int

返回n字节数据进行base64编码后的最大长度。

func (*Encoding) Encode

1	func (enc *Encoding) Encode(dst, src []byte)

将src的数据编码后存入dst，最多写EncodedLen(len(src))字节数据到dst，并返回写入的字节数。

函数会把输出设置为4的倍数，因此不建议对大数据流的独立数据块执行此方法，使用NewEncoder()代替。

举例：

package main 
import(
    "encoding/base64"
    "fmt"
)

func main() { 
    decoded := "foo,bar"
    n := base64.StdEncoding.EncodedLen(len(decoded))//DecodedLen返回len(encoded)字节base64编码的数据解码后的最大长度
    fmt.Println(n) //12
    dbuf := make([]byte, n) 
    base64.StdEncoding.Encode(dbuf, []byte(decoded))

    fmt.Printf("encode result : %s\n", dbuf) //encode result : Zm9vLGJhcg==
}

下面就是生成编码器和解码器的方法，其实和上面的Encode和Decode实现的效果一样，在编码的是大数据流时使用下面的方法：

func NewEncoder（可写Write）

1	func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser

创建一个新的base64流编码器。写入的数据会在编码后再写入w，base32编码每3字节执行一次编码操作；写入完毕后，使用者必须调用Close方法以便将未写入的数据从缓存中刷新到w中。

举例：

package main 
import(
    "encoding/base64"
    "os"
)

func main() { 
    input := []byte("foo,bar")
    encoder := base64.NewEncoder(base64.StdEncoding, os.Stdout) //生成一个编码器，会将调用Write()写入的值编码后写到os.Stdout中
    encoder.Write(input)

    encoder.Close()
    //返回Zm9vLGJhcg==
}

func NewDecoder（可读-Read）

1	func NewDecoder(enc *Encoding, r io.Reader) io.Reader

创建一个新的base64流解码器。

举例：

package main 
import(
    "encoding/base64"
    "strings"
    "log"
    "fmt"
    "io"
)

func main() { 
    encoded := "Zm9vLGJhcg=="
    decoder := base64.NewDecoder(base64.StdEncoding, strings.NewReader(encoded))
    n := base64.StdEncoding.DecodedLen(len(encoded))//DecodedLen返回len(encoded)字节base64编码的数据解码后的最大长度
    fmt.Println(n) //9
    dbuf := make([]byte, n) 
    _, err := decoder.Read(dbuf)//将读取的解码后的值写到dbuf中
    if err != nil && err != io.EOF {
        log.Fatal("Read failed", err)
    }
    fmt.Printf("decoded result : %s\n", dbuf) //decoded result : foo,bar
}

bytes包

go test的使用

go test真的太难理解了，我一开始也不要知道Test开头的函数里的fmt输出语句是没有显示在屏幕上的，导致我看不到自己的输出语句，也就没法测试。

func TestF1(t *testing.T){
    fmt.Println("you passed")
}
// 这里通过go test -run TestF1测试是看不到输出语句的

这篇文章写的不错：【1】

// main.go
package main

func F1() (s string) {
	s = "string"
	return
}

// main_test.go
package main

import "testing"

func testF1(t *testing.T) {
	s := F1()
	ans := "string"
	if s != ans {
		t.Errorf("output error")
	}
}
func TestF1(t *testing.T) {
	testF1(t)
}

以上两个文件是在同一个文件夹的，然后运行下面的代码：

1	go test -run TestF1

输出是：

1 2	PASS ok helloWorld 0.027s

如果将main_test.go中的第8行改了，会输出

--- FAIL: TestF1 (0.00s)
    main_test.go:9: output error
FAIL
exit status 1
FAIL    helloWorld      0.028s

这里有一些go test的使用知识：

go的test一般以xxx_test.go为文件名，xxx并没有特别要求是要实测的文件名
tes文件里要测试的函数要大写Testxxx(t testing.T)或者Testxxx(b testing.B) \
t.Errorf(“”)为打印错误信息，并且当前test case会被跳过
t.SkipNow()跳过当前test，并且直接按PASS处理继续下一个test
使用t.Run来执行subtests可以做到控制test输出以及test的顺序

main_test.go第14行可以改为

1	t.Run("testF1",testF1)

并发编程

go语言通过goroutine实现并发。goroutine属于用户态线程，我们可以根据需要创建成千上万个goroutine并发工作。goroutine是由Go语言的运行时(runtime)调度完成。

go语言还提供channel在多个goroutine间进行通信，goroutine和channel是go语言秉承的CSP(Communicating Sequential Process)并发模式的重要实现基础。

goroutine

只需要在调用函数时在前面加上go关键字就可以创建一个goroutine。

func hello(){
    fmt.Println("hello")
}
// main函数启动后会自动创建一个main goroutine
func main(){
    go hello() // 开启一个单独的goroutine去执行hello函数
    fmt.Println("main")
    // hello 不会打印
    // main goroutine结束后，由它创建的goroutine都会消除
}

如何让hello打印出来？

func hello(i int){
    fmt.Println(i)
}
// main函数启动后会自动创建一个main goroutine
func main(){
    for i:=0; i<100; i++{
        go hello(i) // 开启一个单独的goroutine去执行hello函数
    }
    fmt.Println("main")
    time.Sleep(time.Second)
}

使用匿名函数的形式来创建goroutine

// main函数启动后会自动创建一个main goroutine
func main(){
    for i:=0; i<100; i++{
        go func(){
            fmt.Println(i)
        }()
    }
    fmt.Println("main")
    time.Sleep(time.Second)
}

上面这个函数会有问题，最后会输出很多个100。原因是当for循环结束时，i的结果是100，而这100个goroutine都用的是这一个i。

改成下面的代码就好了。

// main函数启动后会自动创建一个main goroutine
func main() {
	for i := 0; i < 100; i++ {
		go func(i int) {
			fmt.Println(i)
		}(i)
	}
	fmt.Println("main")
	time.Sleep(time.Second)
}

sync.WaitGroup

使用sync.WaitGroup来实现goroutine的同步，不用使用time.Sleep来傻等了。

var wg sync.WaitGroup
func hello(i int){
    defer wg.Done() // goroutine结束就登记-1
    fmt.Println("hello gorouotine-", i)
}
func main(){
    for i:=0; i<10; i++{
        wg.Add(1) // 启动一个goroutine就登记+1
        go hello(i)
    }
    wg.Wait() // 等待所有登记的goroutine都结束
}

开启一个线程，来输出随机数。

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

var wg sync.WaitGroup

func f() {
	defer wg.Done()
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < 5; i++ {
		r1 := rand.Int()    // int64
		r2 := rand.Intn(10) // 0<=x<10
		fmt.Println(r1, r2)
	}
}
func main() {
	wg.Add(1)
	go f()
	wg.Wait()
}

channel

虽然可以使用共享内存进行数据交换，但是共享内存在不同的goroutine中容易发生竞争问题。为了保证数据交换的正确性，必须使用互斥量对内存进行加锁，这种做法会造成性能问题。

go语言提倡使用通信共享内存。

go语言的channel是一种特殊的数据类型，通道像一个传送带或者队列，总是遵循先进先出的规则，保证收发数据的顺序，每一个通道是一个具体类型的管道，也就是声明channel的时候需要为其指定元素类型。

1	var 变量 chan 元素类型

例如：

1 2	var ch1 chan int // 传递int类型的通道 var ch2 chan float32

通道必须使用make来初始化。

var b chan int 
func main(){
    b = make(chan int) // 不带缓冲区的通道的初始化
    // 有goroutine来收数据，发数据的才能发送进来。
    
    b = make(chan int, 16) // 带缓冲区的通道的初始化
}

发送:

1	ch <- 10 // 把10发送到ch中

接收：

<- ch

关闭：

close(ch)

select

go语言可以尝试随机地从多个通道中取出数据或发送数据，是用select来实现的。

select{
    case <-ch1:
    	...
    case data := <-ch2:
    	...
    case ch3 <- data:
    	...
    default:
    	...
}

举个例子：

func main() {
	ch := make(chan int, 1)
	for i := 0; i < 10; i++ {
		var data int
		select {
		case data = <-ch:
			fmt.Println(data)
		case ch <- i:
		}
	}
}

输出是：

sync.Cond

Cond实现了一个条件变量，一个线程集合地，供线程等待或者宣布某事件的发生。比如，调用了Cond.Wait()函数的线程就会进入线程集合，而其他线程判断满足某个事件了，就会调用Cond.Broadcast()或者Cond.Signal()进行唤醒线程集合中的被阻塞的线程的操作。

Cond

type Cond struct {
    // 在观测或更改条件时L会冻结
    L Locker
    // 包含隐藏或非导出字段
}

每个Cond实例都有一个相关的锁（一般是Mutex或RWMutex类型的值），它必须在改变条件时或者调用Wait方法前保持锁定。

func (*Cond)Broadcast

Broadcast唤醒所有等待c的线程。调用者在调用本方法时，建议（但并非必须）保持c.L的锁定。

func (*Cond)Signal

Signal唤醒等待c的一个线程（如果存在）。调用者在调用本方法时，建议（但并非必须）保持c.L的锁定。

func (*Cond)Wait

Wait自行解锁c.L并阻塞当前线程，在之后线程恢复执行时，Wait方法会在返回前锁定c.L。和其他系统不同，Wait除非被Broadcast或者Signal唤醒，不会主动返回。

注意：Wait方法会在返回前锁定c.L，因此执行Signal或者Broadcast的线程应该不要忘了在合适的时机执行Cond.L.Unlock()。

go语言使用rpc

用通俗易懂的语言描述就是：RPC允许跨机器、跨语言调用计算机程序方法。打个比方，我用go语言写了个获取用户信息的方法getUserInfo，并把go程序部署在阿里云服务器上面，现在我有一个部署在腾讯云上面的php项目，需要调用golang的getUserInfo方法获取用户信息，php跨机器调用go方法的过程就是RPC调用。

在golang中实现RPC非常简单，有封装好的官方库和一些第三方库提供支持。Go RPC可以利用tcp或http来传递数据，可以对要传递的数据使用多种类型的编解码方式。golang官方的net/rpc库使用encoding/gob进行编解码，支持tcp或http数据传输方式，由于其他语言不支持gob编解码方式，所以使用net/rpc库实现的RPC方法没办法进行跨语言调用。

golang官方还提供了net/rpc/jsonrpc库实现RPC方法，JSON RPC采用JSON进行数据编解码，因而支持跨语言调用。但目前的jsonrpc库是基于tcp协议实现的，暂时不支持使用http进行数据传输。

除了golang官方提供的rpc库，还有许多第三方库为在golang中实现RPC提供支持，大部分第三方rpc库的实现都是使用protobuf进行数据编解码，根据protobuf声明文件自动生成rpc方法定义与服务注册代码，在golang中可以很方便的进行rpc服务调用。

net/rpc库实现rpc的例子

//master.go
package rpc

import "net"
import "os"
import "log"
import "net/rpc"
import "net/http"

type Master struct{
    
}
func (m *Master)Example(args *ExampleArgs, reply *ExampleReply) error{
    reply.Y = args.X+1
    return nil
}

func (m *Master)Server(){
    rpc.Register(m)
    rpc.HandleHTTP()
    sockname := masterSock()
    os.Remove(sockname)
    l, e := net.Listen("tcp",sockname)
    if e!=nil {
        log.Fatal("listen error:",e)
    }
    go http.Serve(l, nil)
}

//worker.go
package rpc

import "fmt"
import "log"
import "net/rpc"

func CallExample(){
    args := ExampleArgs{}
    args.X = 99
    reply := ExampleReply{}
    call("Master.Example", &args, &reply)

    fmt.Printf("reply.Y %v\n", reply.Y)
}

func call(rpcname string, args interface{}, reply interface{}) bool {
    sockname := masterSock()
    c, err := rpc.DialHTTP("tcp",sockname)
    if err != nil {
        log.Fatal("Dialing:",err)
    }
    defer c.Close()
 
    err = c.Call(rpcname, args, reply)
    if err == nil {
        return true
    }   
    fmt.Println(err)
    return false
}

//rpc.go
package rpc

import "os"
import "strconv"
import "fmt"

type ExampleArgs struct{
    X int
}

type ExampleReply struct{
    Y int
}

func masterSock() string{
    return "127.0.0.1:8095"
}

//master_main.go
package main

import "../rpc"

func main(){
    m := rpc.Master{}
    m.Server()
    for true {
    
    }
}

//worker_main.go
package main

import "../rpc"

func main(){
    rpc.CallExample()
}

上面的每份代码对应一个文件，属于同一个package的文件放在对应名字的文件夹中。然后转到main文件夹中，先运行go run master_main.go 即可打开服务器进程，然后运行go run worker_main.go 运行客户端程序，即可得到结果100。

上面是个简单的利用go语言的net/rpc包来实现rpc的例子。

package

如果一个package内有很多文件，一个文件利用到了另一个文件定义的变量或函数，则在go run时要把这个包内的所有文件都加到后面，顺序不重要，这时，所有文件相当于组合成一个go文件了。

引用

go语言标准网：https://studygolang.com/pkgdoc

一个go语言教程：https://docs.hacknode.org/gopl-zh/ch12/ch12-01.html

【1】go tes常用介绍 https://blog.csdn.net/qq_28119741/article/details/85219164?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163168541816780261937717%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=163168541816780261937717&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v1~rank_v31_ecpm-7-85219164.pc_search_result_cache&utm_term=%E4%BD%BF%E7%94%A8go+test&spm=1018.2226.3001.4187

展开全文 >>

js中基本数据类型及其用法

2020-10-12

类型

在js中，有6种不同的数据类型：

string
number
boolean
object
function
symbol

3种对象类型：

Object
Date
Array

2种不包含任何值的数据类型

null
undefined

typeof

typeof操作符可以返回string, number, boolean, object, function, undefined

特殊地，null的数据类型是object

Object.prototype

var arr = [1,2,3]
var date = new Date()
function Person(){
    this.name = 'zhou'
}
var p1 = new Person()
Object.prototype.toString.call(arr) //[object Array]
Object.prototype.toString.call(date) //[object Date]
Object.prototype.toString.call(p1) //[object Object]

由于js中只有3种对象类型，Object.prototype.toString.call只会返回上述三种结果之一。

展开全文 >>

css-vertical-align属性

2020-10-11

vertical-align应该是我目前遇到的最复杂的属性了。先了解基线的概念。

基线

下面是一行文本（不包括padding和margin区域），其中制定了一些线的概念。

baseline基线是一行文本中x字符的低端所在的直线。

还有，基线的位置不是固定的：

在文本内联元素中，如上图，基线是字符x的下边缘位置
在img元素中，基线就是图片的下边缘
在inline-block元素中。如果该元素中有内联元素，基线就是最后一行内联元素的基线；如果该元素没有内联元素或者内联元素的overflow不是visible，基线就是margin的底边缘。

vertical-align

vertical-align属性应用于行内元素，如display属性值为inline, inline-block, table-cell的。

第一种用法，若应用于表单元格中，如display属性为table-cell的，这个属性会设置单元格框中单元格内容的对齐方式。如果给一个表格的td加一个vertical-align: middle 的样式，表格里面的内容会垂直居中。

第二种用法，该属性定义行内元素相对于该元素所在行的垂直对齐。意思是，如果有几个行内元素a, b, c在同一行，那么这3个行内元素在垂直方向该如何对齐，它们是全部bottom对齐，全部baseline对齐还是a的middle和b,c的baseline对齐，这是由它们自己分别设置的vertical-align属性决定的。

下面以一个例子来解释。

<!DOCTYPE html>
<html>

<head>
    <body>
        <div style="width:500px; height:1000px; background:aquamarine">
            <span>
                abcxyz周华辉
            </span>
            <div style="display:inline-block; width:100px; height:100px; margin:10px; background:blue">
            </div>
            <span>
                西瓜
            </span>
        </div>
    </body>

</html>

默认所有内联元素的vertical-align值为baseline

如上图所示，所有元素的baseline对齐了。

设置第一个span的vertical-align为middle

很明显，第一个span的middle line和另外两个元素的baseline对齐了。

垂直居中的方法

若设置内层元素inner在外层元素outter中垂直居中。可以

设置outter的display为table-cell，vertical-align:middle
在outter中另外增加一个div
1
2
3
4
5
div{
width: 0px;
height: 100%;
vertical-align: middle
}
然后设置inner的vertical-align为middle。然后inner就在outter中垂直居中了。

展开全文 >>

css-水平垂直居中

2020-10-11

css2

水平居中

margin 0 auto

有一个html文本（1.html）：

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>div居中</title>
		<link rel="stylesheet" type="text/css" href="test.css">
	</head>
	<body>
		<div class="outerDiv" style="width:250px;height:350px;border: 2px solid red;">
			<div class="innerDiv" style="width: 150px;height: 150px;background-color: green;">
			</div>
		</div>
	</body>
</html>

设置下面的css样式，可以达到水平居中

1
2
3

.innerDiv{
	margin: 0 auto;
}

为什么不把上下左右的margin全部设置成auto呢？这样不就上下左右都居中了？

首先，div是一个块级元素，宽度默认都是相对于父元素的100%，即：一个块元素，如果我们不人为的去设置它的宽度，他就单独占一行！换句话说，这一行就只有他一个元素！想让他水平居中，左右margin设置成auto后底层很容易就可以计算出margin具体的数值应该是多少，从而达成左右居中。说到这里，我们再去考虑垂直居中：页面在垂直方向上块级元素不一定只有一个，即块级元素没有“默认占一列”这样的规定，因此即使把margin设置成auto，也不能自动计算出margin到底该是多少

垂直居中

line-height

对于单行文字在父元素中垂直居中，可以设置，这行文字的line-height为父元素的height。

table-cell

对于1.html，设置下面的css样式：

.outerDiv{
	display: table-cell;
	vertical-align: middle;
}
.innerDiv{
	margin: 0 auto;
}

定位+负边距

<div class="wrapper">
    <div class="box">
    </div>
</div>

.wrapper{
    position: relative;
    width: 500px;
    height: 500px
}
.box{
    position:absolute; 
    left:50%;
    top:50%;
    margin-left:-150px;
    margin-top:-100px;
    padding:20px;
    width:300px;
    height:200px;
    background:#41D7FB;
}

注意：想要在其中垂直居中的父元素必须要么是body元素，要么设置position: relative。

特点：

兼容性好
元素的宽高需要固定

定位+自适应边距

<div class="wrapper">
    <div class="box">
        西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书
    </div>
</div>

.wrapper{
    position: relative;
    width: 500px;
    height: 500px;
    background: black
}
.box{
    position: absolute;
    top: 0;
    bottom: 0;
    width:200px;
    bottom: 200px
    margin: auto;
    background: #41D7FB
}

需要固定宽高。

css3

直接利用flex布局。

或者，利用transform属性

<!DOCTYPE html>
<html>

<head>
    <style>
        .wrapper {
            position: relative;
            width: 500px;
            height: 500px;
            background: black
        }

        .box {
            position: absolute;
            left: 50%;
            top: 50%;
            width: 200px;
            height: 200px;
            transform: translate(-50%, -50%);
            background: #41D7FB
        }
    </style>
</head>

<body>
    <div class="wrapper">
        <div class="box">
            西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书西瓜书
        </div>
    </div>
</body>
</html>

展开全文 >>

js-遍历对象

2020-10-10

js对象的属性中可直接用，可访问到的属性分为数据属性和访问器属性。

数据属性

实际存储属性值

{
    value: 属性值,
    writable: true/false, //控制是否可以修改
    enumerable: true/false, //控制是否可枚举
    configurable: true/false, //控制是否可删除，控制是否可修改前两个特性，一旦改为false，则不可逆
}

访问器属性

不实际存储数据，专门提供对其他数据的保护。

{
    get: function(){},
    set: function(value){},
    enumerable: true/false,
    configurable: true/false
}

for…in

访问可枚举的属性
访问存在于实例的，也可以访问存在于原型中的
按照键的字典序输出

Object.keys

访问可枚举的属性
访问存在于实例的
按照键的字典序输出

for…of

主要用来遍历可迭代的对象(Array, Map, Set, arguments等)，它主要获取对象的value值。

参考 https://segmentfault.com/a/1190000014497376

展开全文 >>

js-闭包

2020-10-09

js中的闭包是个很难理解的概念，因为仔细思考，它似乎违背了编译原理的知识，可能是因为js是动态语言，而编译原理的知识是针对静态语言吧。看下面的例子。

<script>
    function func1() {
        var cnt = 0
        return function () {
            cnt++
            return cnt
        }
    }
    var s1 = func1()
    s1()
    s1()
    var s2 = func1()
    console.log(s1())
</script>

输出：

这说明，js中的funtion并不是C语言中的函数，而是一个类似于对象的概念。当你执行func1()时，并不是执行一个函数，而是创造了一个对象，并执行这个对象里面的代码。当你第一次执行func1()时，创造了一个匿名对象，这个对象里面有数据cnt，而当你再次执行func1()时，又创造了一个匿名对象，这个对象里面也有cnt，但是与上一个不同。所以，上面的代码，输出3.

展开全文 >>

浏览器渲染页面的过程

2020-10-09

Safari和Chrome使用webkit内核进行页面渲染。

webkit引擎渲染流程

浏览器包含3个很重要的进程：浏览器进程，网络进程，渲染进程。

渲染进程会从网络进程请求html文档的内容。

渲染引擎（渲染进程）开始解析HTML文档，构建DOM树，如果遇到了CSS文件，那么会边下载解析CSS，边构建DOM树，待CSS解析完成后，就可以构建渲染树了。也就是说，CSS会阻塞渲染树的构建，而不会阻塞DOM树的构建。

当CSS在解析过程中，会禁止js脚本的执行。原因是，脚本在文档解析阶段会请求样式信息，如果当时还没有解析完CSS，就去执行脚本，脚本就会得到错误的结果。

在HTML文档的解析过程中，遇到js脚本时，会阻塞HTML文档的解析，然后下载js脚本，当CSS解析完成后，立即执行js脚本。当js脚本下载执行完毕后在继续解析HTML。

当遇到图片文件时，会边下载图片，边解析HTML文本，甚至不等图片下载完成，就进行页面渲染。

为了达到更好的用户体验，渲染引擎会力求尽快将内容显示在屏幕上，它不必等到整个HTML文档解析完毕后，就会构建渲染树，设置布局并渲染页面，在不断接收和处理来自网络的其余内容的同时，渲染引擎会将部分内容解析并显示出来。

html解析流程例子

用户输入网址（假设是个html页面，并且是第一次访问），浏览器向服务器发出请求，服务器返回html文件；
浏览器开始载入html代码，发现＜head＞标签内有一个＜link＞标签引用外部CSS文件；
浏览器又发出CSS文件的请求，服务器返回这个CSS文件；
浏览器继续载入html中＜body＞部分的代码，并且CSS文件已经拿到手了，可以开始渲染页面了；
浏览器在代码中发现一个＜img＞标签引用了一张图片，向服务器发出请求。此时浏览器不会等到图片下载完，而是继续解析后面的代码；
服务器返回图片文件，由于图片占用了一定面积，影响了后面段落的排布，因此浏览器需要回过头来重新渲染这部分代码；
浏览器发现了一个包含一行Javascript代码的＜script＞标签，赶快运行它；
Javascript脚本执行了这条语句，它命令浏览器隐藏掉代码中的某个＜div＞（style.display=”none”）。突然少了这么一个元素，浏览器不得不重新渲染这部分代码；

优化

预解析

在执行脚本时，其他线程会解析文档的其余部分，找出并下载需要通过网络下载的资源，通过这种方式，资源可以在并行连接上下载，从而提高总体速度。预解析不会修改DOM树，而是将这项工作交由主解析器处理。

参考 https://segmentfault.com/a/1190000018652029

展开全文 >>

js-认识this

2020-10-09

在js语言中，this不总是指向一个对象，有时候它会指向window对象，有时候，它会指向调用方法的那个对象，有时候也可以自己将对象绑定到this上。

观察下面的例子。

<script>
    var o = {
        name: "zhou",
        func1: function () {
            if (this.name) {
                console.log(this.name)
            } else {
                console.log("can't find")
            }
        },
        func2: function () {
            return function () {
                if (this.name) {
                    console.log(this.name)
                } else {
                    console.log("can't find")
                }
            }
        },
        func3: function () {
            return () => {
                if (this.name) {
                    console.log(this.name)
                } else {
                    console.log("can't find")
                }
            }
        },
        func4: function () {
            return function () {
                if (this.name) {
                    console.log(this.name)
                } else {
                    console.log("can't find")
                }
            }.bind(this)
        },
    }
    o.func1();
    o.func2()();
    o.func3()();
    o.func4()();
</script>

最后的输出是：

zhou 
can't find
zhou
zhou

func1中的this指向对象o；func2中的this指向window对象。

箭头函数可以将词法作用域绑定到外层对象，所以，func3中的匿名对象中的this指向外层对象o，否则，this指向window对象。

使用js中原生的Function.bind方法，可以将方法中的this绑定到你想指定的对象，在func4中，将匿名对象中的this和对象o绑定。.bind(this) 里面的this指的就是对象o。

展开全文 >>

Vue-响应式原理

2020-10-08

js中的getter与setter

要了解vue的响应式原理，必先了解js的getter与setter。下面的例子描述了getter与setter是如何为用户定义的对象o工作的。

var o = {
  a: 7,
  get b() { 
    return this.a + 1;
  },
  set c(x) {
    this.a = x / 2
  }
};

console.log(o.a); // 7
console.log(o.b); // 8
o.c = 50;
console.log(o.a); // 25

js是一个动态语言，可以动态为对象添加一个属性，同时设置它的getter和setter。使用Object.defineProperty扩展Date原型，为预定义好的Date类添加year属性。

var d = Date.prototype;
Object.defineProperty(d, "year", { //这是d对象中对于year的访问器属性
  get: function() { return this.getFullYear() },
  set: function(y) { this.setFullYear(y) }
});

综上，getter和setter可以通过两种方式来定义。

使用对象初始化器定义
使用Object.defineProperty方法。

vue响应式原理

原来，在vue的设计中，有两个核心的概念：组件和虚拟DOM树。组件其实就是一个js对象，通过vue.extend方法创建的对象就是一个组件（这个方法在vue3.0以后就没有了），而一个组件对应一个虚拟DOM树，虚拟DOM树会最终挂载到真正的浏览器DOM树上。

当你把一个普通的js对象传入vue实例作为data选项，vue将会遍历此对象所有的property，并使用Object.defineProperty把这些property全部转化为getter和setter，在property被访问和修改时通知变更。

每个组件实例都对应一个watcher实例，它会在组件渲染的过程中把接触到的数据property记录为依赖，例如：template中有一行html代码<p>{{ message }}</p> ，组件实例中的data选项有对象Data: {message: "zhou"}。当渲染到上面那句html代码时，就会记录依赖项为message和依赖为p结点。之后，当依赖项的setter触发时，会通知watcher，从而使它关联的所有组件重新渲染（本组件和它的关联的子组件，如果在子组件中使用了v-bind命令进行结点和父亲数据的单向数据绑定，那么就有父组件的数据和子组件的结点的关联）。

数据劫持，vue响应式实现

参考 https://segmentfault.com/a/1190000006599500

先上一个代码，看双向数据绑定的应用场景。

<div id="mvvm-app">
    <input type="text" v-model="word">
    <p>
        {{ word }}
    </p>
    <button v-on:click="sayHi">
        change model
    </button>
</div>
<script src="./js/observer.js"></script>
<script src="./js/watcher.js"></script>
<script src="./js/compile.js"></script>
<script src="./js/mvvm.js"></script>
<script>
    var vm = new MVVM({
        el: '#mvvm-app',
        data: {
            word: 'Hello World'
        },
        methods: {
            sayHi: function(){
                this.word = 'Hi, everybody!'
            }
        }
    })
</script>

vue.js采用数据劫持结合发布者-订阅者模式，通过Object.defineProperty来劫持data中各个属性的setter和getter，在数据变动时发布消息给订阅者。

实现一个数据监听器Observer，能够对数据对象的所有属性进行监听（若属性为对象，则继续对属性的属性进行监听，这是一个递归），如有变动可将最新值通知订阅者。
实现一个指令解析器Compile，对每个元素节点的指令进行扫描和解析，构建虚拟DOM，根据指令模板替换数据，绑定响应的更新函数。
实现一个Watcher，作为连接Observer和Compile的桥梁，Watcher就是订阅者，能够收到更新消息，并通过Compile对虚拟DOM进行更新，进而更新视图。

observer

Observer对象为data中的所有属性，包括子属性，加入setter和getter，来监听属性的变动，那么需要将data递归遍历。给某个对象赋值，就会触发setter，那么就能监听到属性变化了。

监听子属性：为子属性加入getter和setter。

在这篇文章中，属性一般指的是vue实例中data对象中的属性及其子属性。

//observer.js
function observer(data){
    //data对应的键和data已经被监听，而且data不是对象
    if(!data || typeof data !== 'object'){
        return;
    }
    //取出所有属性进行遍历, key是一个字符串，如'message'
    Object.keys(data).forEach(key=>{
        defineReactive(data, key, data[key])
    })
}
function defineReactive(data, key, value){
    obserer(value) //监听子属性
    Object.defineProperty(data, key, {
        enumerable: true,
        configurable: false,
        get: function(){
            return value
        },
        set: function(newValue){
            console.log('监听到值变化 ', value, '-->', newValue)
            data[key] = newValue
            defineReactive(data, key, data[key]) //更新的data[key]里面没有getter和setter，要设置一下
        }
    })
}

我们已经可以监听每个数据的变化了，那么如何通知订阅者呢？我们就在observer对象里面维护一个订阅者队列dep，数据变动，就触发订阅者队列的notify()方法。

//observer.js
//... 省略
function defineReactive(data, key, value){
    var dep = new Dep()
    observer(value) //监听子属性
    
    Object.defineProperty(data, key, {
        //... 省略
        set: function(newValue){
            if(value == newValue) return;
            console.log('监听到值变化 ', value, '-->', newValue)
            data[key] = newValue
            dep.notify() //通知所有订阅者
        }
    })
}

function Dep(){
    this.subs = []
}
Dep.prototype = {
    addSub: function(sub){
        this.subs.push(sub)
    },
    notify: function(){
        this.subs.forEach(function(sub){
            sub.update()
        })
    }
}

我们知道，watcher就是订阅者，但是如何向订阅者队列中添加watcher订阅者呢？

//observer.js
//... 省略
function defineReactive(data, key, value){
    var dep = new Dep()
    observer(value) //监听子属性
    
    Object.defineProperty(data, key, {
        //... 省略
        get: function(){
            //由于需要在闭包dep中添加watcher，所以通过Dep.target暂存全局属性：watcher，添加到dep中后就可以移出Dep.target
            Dep.target && dep.addSub(Dep.target)
            return value
        }
    })
}

试想，一个watcher要想加入到某个属性的订阅者队列中，就要访问这个属性（因为可以触发它的getter），所以在wathcer的构造过程中，要有一个访问属性的过程。

//watcher.js
//... 省略
watcher.prototype = {
    get: function(key){
        Dep.target = this
        this.value = data[key] //这里会触发data[key]的getter，从而添加了订阅者  
        Dep.target = null
    }
}

watcher

watcher是observer和compile的桥梁。主要做：

在自身实例化时往属性的订阅者队列中添加自己
自身有一个updata方法
待dep.notify()执行后，能调用自身的updata方法，并触发compile中绑定的回调（具体见compile的实现）

watcher并不会直接改变虚拟DOM和视图，compile做这件事，watcher只是compile的门户。

function watcher(vm, exp, cb){
    this.cb = cb //compile中定义的回调函数
    this.vm = vm //vue实例
    this.exp = exp //exp是data对象中的键，字符串类型
    //此处为了触发属性的getter，从而在属性的订阅者队列中添加自己
    this.value  = this.get()
}
watcher.prototype = {
    updata: function(){
        this.run()
    },
    run: function(){
        var value = this.get() //取到最新值
        var oldValue = this.value
        if(value !== oldValue){
            this.value = value
            //执行compile中绑定的回调，更新视图
            this.cb.call(this.vm, value, oldValue)
        }
    },
    get: function(){
        Dep.target = this
        var value = this.vm[exp]
        Dep.target = null
        return value
    }
}

实例化watcher，就意味建立了某个属性与组件中某个结点（元素结点或文本结点）的关联：watcher执行updata()方法，执行compile中定义的回调函数，进而操作对应的DOM结点。

所以，什么时候实例化watcher呢？

compile

compile主要做：

建立虚拟DOM
将虚拟DOM挂载到浏览DOM上，由浏览器渲染页面
给每个vue指令对应的结点绑定更新回调函数，每个回调函数对应一个watcher订阅者，watcher主动触发回调函数，更改虚拟DOM，并重新挂载到浏览器DOM上。

至于什么是虚拟DOM，什么是浏览器DOM，看代码解释。

//compile.js
//el是真实的浏览器DOM对象
function compile(el){
    this.$el = this.isElementNode(el)?el:document.querySelection(el)
    if(this.$el){
        //this.$fragment就是虚拟DOM
        this.$fragment = this.node2Fragment(this.$el)
        this.init()
        this.$el.appendChild(this.$fragment)
    }
}
compile.prototype = {
    init: function(){
        this.compileElement(this.$fragment)
    },
    node2Fragment: function(el){
        //pass
    },
    //compileElement方法将遍历所有结点及其子结点，进行扫描解析编译，调用对应的指令渲染函数进行数据渲染，
    //并绑定指定的指令更新函数。
    compileElement: function(){
        //pass
    }
}

MVVM

MVVM作为数据绑定的入口，整合了observer，compile和watcher三者，通过observer监听自己model数据的变化，通过compile解析编译模板指令，最终利用watcher搭起observer和compile之间的通信桥梁，达到数据变化->视图更新，视图交互变化->数据model变化的双向绑定效果。

//mvvm.js
function MVVM(options){
    this.$options = options
    var data = this._data = this.$options.data
    observer(data, this)
    this.$compile = new compile(options.el || document.body, this)
}

但是有一个问题，这里监听的数据对象是options.data，每次更新视图，则必须通过vm._data.name = 'dmq'的方式，而不是vm.name = 'dmq'。

所以这里需要给MVVM实例添加一个属性代理的方法，使访问vm的属性代理为访问vm._data的属性。

//mvvm.js
function MVVM(options){
    this.$options = options
    var data = this._data = this.$options.data
    var me = this
    Object.keys(data).forEach(key=>{
        me._proxy(key)
    })
    observer(data, this)
    this.$compile = new compile(options.el || document.body, this)
}
MVVM.protype = {
    _proxy: function(key){
        var me = this
        Object.defineProperty(me, key, {
            enumerable: true,
            configurable: false,
            get: function proxyGetter(){
                return me._data[key]
            },
            set: function proxySetter(newValue){
                me._data[key] = newValue
            }
        })
    }
}

展开全文 >>

C语言基础

2020-09-29

C语言输入输出

scanf() & printf()

头文件：#include<stdio.h>

1
2
3

//in: 1 2
int x = scanf("%d%d%d",&a,&b,&c);
//out: a=1,b=2,c保持不变,x=3

当扫描到文件结束符后，就自动结束输入

x为正确接收到值的变量个数。当scanf函数的第一个变量格式不正确时返回值为0，即，当scanf函数的第n个变量格式不正确时，返回值为n-1；当scanf在扫描到了合法字符之前扫描到了输入结束符，则返回-1。

输入浮点数

double f;
scanf("%lf",&f);

float f2;
scanf("%f",&f2);

上面的lf格式对应double数据类型，f格式对应float数据类型。

输入16进制数

//int: A
int a;
scanf("%X",&a);
printf("%d",a);
//out: 10

输入多个单词

1
2
3

while(scanf("%d",&a) > 0){
    printf("%d\n",a);
}

输出填充字符

int main()
{
    //%0xld:要是输出小于x位，用0补上，使输出达到x位；否则正常输出。
    printf("%02ld\n",1);
    printf("%02ld\n",111);

    printf("------\n"); 
    //%xld:要是输出小于x位，用空格补上，使输出达到x位；否则正常输出。
    printf("%2ld\n",1);
    printf("%2ld\n",111);
}

getchar() & putchar()

头文件：#include<stdio.h>

函数 int getchar(void) 函数读取下一个可用的字符，若到达了文件的结尾，则返回-1。

#include<stdio.h>
int main(){
    int c = getchar();
}

int putchar(void) 函数在同一个时间把一个字符输出到屏幕上。

fgets()和cin.get()

头文件：#include<stdio.h>

函数 char *fgets(char *str, int n, FILE* stream) 从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止。

#include <stdio.h>
char *fgets(char *s, int size, FILE *stream); //size是自定义读入字符的最大个数，包括\0
//如果size=5，而输入是abc\n，则缓冲区中为abc\n\0
//如果size=4，而输入是abc\n，则缓冲区中为abc\0
//如果size=3，而输入为abc\n，则缓冲区为ab\0

//输入
const in MAXNUM = 105;
char str[MAXNUM];
cin >> str; // 遇到空白字符停止

fgets(str, MAXNUM, stdin); // 可以把换行符也输入进来
                           // MAXNUM参数表示最多只能输入多少个字符,包括\0
                           // 在没有达到MAXNUM个，且遇到了回车符，就停止输入，同时也把回车符加入到str中

cin.get(str, MAXNUM); // 默认遇到换行符停止

// 输出
cout<<str<<endl;

puts(str); // 默认在结尾输出换行

cin.ignore()

cin.ignore()函数是C++标准输入流（cin）中的一个方法。cin.ignore()函数中有两个参数，分别为数值型的a 和字符型的 ch ，即cin.ignore( a, ch )。它表示从输入流 cin 中提取字符，提取的字符被忽略，不被使用。而每抛弃一个字符，它都要进行计数和比较字符：如果计数值达到 a 或者被抛弃的字符是 ch ，则cin.ignore() 函数执行终止；否则，它继续等待。

它的一个常用功能就是用来清除以回车结束的输入缓冲区的内容，消除上一次输入对下一次输入的影响。例如可以这么用，cin.ignore(1024, ‘\n’)，通常把第一个参数设置得足够大，这样实际上是为了只有第二个参数 ‘\n’ 起作用，所以这一句就是把回车（包括回车）之前的所以字符从输入缓冲流中清除出去。

1	cin.ignore(INT_MAX, '\n');

例子：

#include<iostream>
#include<climits>
using namespace std;
#define MAXN 10005
int main(){
    char a[MAXN], b;
    cin.sync_with_stdio(false); // 增加输入输出的速度
	cin.get(a, MAXN);
    cin.ignore(INT_MAX, '\n'); 
    cin>>b;
    cout<<a<<","<<b<<endl;
    return 0;
}
// 输入：
// 1234567890
// fight
// 输出：
// ?

getline()

需要额外引入string包。

只能用来给string类型输入字符串。

不把分隔符读入string中，同时把分隔符从缓冲区中移出。

#include<iostream>
#include<climits>
#include<string>
using namespace std;
#define MAXN 10005
int main(){
	string a;
    char b;
    cin.sync_with_stdio(false); // 增加输入输出的速度
    // cin.ignore(INT_MAX, '\n'); 
    cin>>b;
    cout<<a<<","<<b<<endl;
    return 0;
}

sscanf() & sprintf()

1 2	char str[] = "123" sscanf(str,"%d",&a);

从字符串中读入数组。由此看来，sscanf()和scanf()有很多相似之处。

1
2
3

double a = 12.123;
char str[20];
sprintf(str,"%.3lf",a);

将数字输出到字符串中。

C语言字符串

头文件：#include<string.h>

C语言字符串操作要保证给字符串开足够大的空间。

strcpy()

1
2
3

char s1[10];
char s2[10];
strcpy(s1,s2); //复制字符串s2到s1

strcat()

1
2
3

char s1[10];
char s2[10];
strcat(s1,s2); //连接字符串s2到s1的末尾

strlen()

1	strlen(s1); //返回s1的长度

strcmp()

1 2	strcmp(s1,s2); //如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。

strchr()

返回字符首次出现的指针位置。

char s1[10] = "123";
int pos =0 ;
strchr(s1+pos,'1')-s1; 
//从s1的pos位置开始查找，找到第一个'1'字符的位置。out: 0

可以通过strchr()函数实现C++中string对象的find()函数的操作。

strncpy()

函数格式：char *strncpy(char *dest, const char *src, size_t n)

n：要从源中复制的字符数

#include <stdio.h>
#include <string.h>
 
int main()
{
   char src[40];
   char dest[12];
  
   memset(dest, '\0', sizeof(dest));
   strcpy(src, "This is runoob.com");
   strncpy(dest, src, 10);
 
   printf("最终的目标字符串： %s\n", dest);
   
   return(0);
}
//out: 最终的目标字符串： This is ru

注意：strncpy不会在最后加上\0结束符。

指针

void*指针

在使用C语言进行开发的过程中，经常会遇到void*这样一个特殊的指针。

下面是void *指针的使用场景。

用作泛型，接收任意数据类型指针

void*用于指向特定地址，而无需关心这个地址上存放着什么类型的数据。例如常见的memcpy等函数就用到void*，函数原型如下:

1	void memcpy(void des, void *src, size_t n);

此处的void des和void src可以接收任意类型的数据类型指针，既然是内存拷贝，入参就不应该限制传入什么类型的指针，逻辑上十分合理。

动态内存申请与释放

动态内存申请函数返回值一般都是void*，如果申请成功则返回的是申请的内存块的首地址，申请失败则返回一个空指针NULL，NULL相当于（void *）0。C库的malloc函数原型如下：

1	void *malloc(size_t size);

一般申请完内存之后会与指针类型强制转换一起使用，如下所示。

typedef struct 
{
    char    *name;
    int     age;
    ...
}animal, *animal_t;
 
animal_t dog = (animal_t )malloc(sizeof(animal));
if(!dog)
{
    printf("malloc failed\n");
}

函数指针

如果在程序中定义了一个函数，那么在编译时系统就会为这个函数代码分配一段存储空间，这段存储空间的首地址称为这个函数的地址。而且函数名表示的就是这个地址。既然是地址我们就可以定义一个指针变量来存放，这个指针变量就叫作函数指针变量，简称函数指针。

定义一个指向函数的指针变量 p，p的类型是int(*)(int，int):

1	int(*p)(int, int);

例子：

# include <stdio.h>
int Max(int, int);  //函数声明
int main(void)
{
    int(*p)(int, int);  //定义一个函数指针
    int a, b, c;
    p = Max;  //把函数Max赋给指针变量p, 使p指向Max函数
    printf("please enter a and b:");
    scanf("%d%d", &a, &b);
    c = (*p)(a, b);  //通过函数指针调用Max函数
    printf("a = %d\nb = %d\nmax = %d\n", a, b, c);
    return 0;
}
int Max(int x, int y)  //定义Max函数
{
    int z;
    if (x > y)
    {
        z = x;
    }
    else
    {
        z = y;
    }
    return z;
}

输出：

please enter a and b:3 4
a = 3
b = 4
max = 4

指向函数的指针变量没有 ++ 和 — 运算

预处理语句

ifndef

在.h文件中，经常会看到这样的代码：

// a.h
#ifdef __A_H_
#define __A_H_

// your declaration

#endif

假如：

1 2	// b.h #include "a.h"

1
2
3

// c.c
#include "a.h"
#include "b.h"

当我们编译a.h，a.c，b.h，b.c, c.c时，如果没有a.h文件中的预处理语句ifndef，那么a.h中的代码就会出现两次，导致重复声明；当有了ifndef预处理语句时：包含a.h会使得__A_H_常量被定义并且将它的代码包含再c.c中，然后再包含b.h时由于__A_H_时，就由于__A_H_被定义，所以不会再包含重复的代码了。

展开全文 >>

hello world

Go语言开发环境搭建

安装

windows下GOPATH配置

项目结构

适合个人开发者

流行的项目结构

适合企业开发者

VS code

go install错误

go语言基础

变量和常量

字符串

数组

切片Slice

append()

copy()

判断切片是否相等

map

例子

循环

for循环

函数

defer

结构体

值接收者和指针接收者

import

接口

接口的实现

空接口

通过断言判断空接口的动态类型

文件操作

strconv包

time包

reflect包

it’s all relative

interface 和 反射

Golang的反射reflect

reflect的基本功能TypeOf和ValueOf

从relfect.Value中获取接口interface的信息

已知原有类型【进行“强制转换”】

未知原有类型【遍历探测其Filed】

通过reflect.Value设置实际变量的值

通过reflect.ValueOf来进行方法的调用

Golang的反射reflect性能

总结

参考链接

encoding/base64包

type Encoding

func (*Encoding) EncodeToString

func (*Encoding) DecodeString

func (*Encoding) DecodedLen

func (*Encoding) Decode

举例：

func (*Encoding) EncodedLen

func (*Encoding) Encode

func NewEncoder（可写Write）

func NewDecoder（可读-Read）

bytes包

go test的使用

并发编程

goroutine

sync.WaitGroup

channel

select

sync.Cond

go语言使用rpc

net/rpc库实现rpc的例子

package

引用

类型

typeof

Object.prototype

基线

vertical-align

垂直居中的方法

css2

水平居中

margin 0 auto

垂直居中

interface 和反射