初始化提交

golang/Go语言变量作用域.md

@@ -0,0 +1,26 @@
+# Go 语言变量作用域
+    作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。
+    Go 语言中变量可以在三个地方声明：
+    函数内定义的变量称为局部变量
+    函数外定义的变量称为全局变量
+    函数定义中的变量称为形式参数
+    接下来让我们具体了解局部变量、全局变量和形式参数。
+## 局部变量
+    在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。
+    以下实例中 main() 函数使用了局部变量 a, b, c：    
+
+## 全局变量
+    在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。    
+    编译器初始化的推断 未使用的常量不会引发编译错误
+    
+    
+    
+## 形式参数
+    形式参数会作为函数的局部变量来使用   
+   
+## 初始化局部和全局变量
+    不同类型的局部和全局变量默认值为：
+    数据类型	初始化默认值
+    int	0
+    float32	0
+    pointer	nil    

golang/centos8换源.md

@@ -0,0 +1,107 @@
+# CentOS 8 换源，设置dnf / yum镜像
+    aliyun更新了centos8的说明
+    
+    1、备份
+    mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
+    
+    2、下载新的CentOS-Base.repo 到/etc/yum.repos.d/
+    curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-8.repo
+    
+    3、生成缓存
+    yum makecache
+    
+    
+    4 配置镜像的。
+    
+    cd /etc/yum.repos.d
+    #备份
+    cp CentOS-Base.repo CentOS-Base.repo.bak;
+    cp CentOS-AppStream.repo CentOS-AppStream.repo.bak;
+    cp CentOS-Extras.repo CentOS-Extras.repo.bak;
+    
+    sed -i 's/mirrorlist=/#mirrorlist=/g' CentOS-Base.repo CentOS-AppStream.repo CentOS-Extras.repo;
+    sed -i 's/#baseurl=/baseurl=/g' CentOS-Base.repo CentOS-AppStream.repo CentOS-Extras.repo;
+    sed -i 's/http:\/\/mirror.centos.org/https:\/\/mirrors.aliyun.com/g' CentOS-Base.repo CentOS-AppStream.repo CentOS-Extras.repo
+    
+# ssh 生成密钥
+    ssh-keygen -q -t rsa -b 2048 -f /etc/ssh/ssh_host_rsa_key -N '' ; 
+    ssh-keygen -q -t ecdsa -f /etc/ssh/ssh_host_ecdsa_key -N '';
+    ssh-keygen -t dsa -f /etc/ssh/ssh_host_ed25519_key -N '';
+    
+    8、配置ssh无密码登录
+    先退出 ssh客户端
+    ssh-keygen -t rsa
+    cd ~/.ssh
+    cat id_rsa.pub >> authorized_keys
+    
+# 安装 wxWidgets
+    先安装 
+        安装wxWidgets相关依赖，不装这个就会报以下错误
+        yum -y install ncurses-devel unixODBC-devel openssl-devel  gcc gcc-c++ autoconf automake
+        yum -y install gtk2-devel binutils-devel
+          
+    编译安装 
+    ./configure --with-regex=builtin --with-gtk --enable-unicode --disable-shared --prefix=/usr/local/wxWidgets
+    make && make install  
+    sudo ldconfig      
+    
+# erlang 简单安装 
+    wxWidgets插件
+    1- 添加源
+          # wget http://packages.erlang-solutions.com/erlang-solutions-1.0-1.noarch.rpm
+          # rpm -Uvh erlang-solutions-1.0-1.noarch.rpm
+          # rpm --import http://packages.erlang-solutions.com/rpm/erlang_solutions.asc
+    
+    2- 看一下新装上的源
+          # vim /etc/yum.repos.d/erlang_solutions.repo
+                [erlang-solutions]
+                name=Centos $releasever - $basearch - Erlang Solutions
+                baseurl=http://packages.erlang-solutions.com/rpm/centos/$releasever/$basearch
+                gpgcheck=0
+                gpgkey=http://packages.erlang-solutions.com/debian/erlang_solutions.asc
+                enabled=1
+    
+    3- 安装
+          # yum install erlang erlang-wx
+    
+          按照源的地址在网页上下载
+          http://packages.erlang-solutions.com/rpm/centos/7/x86_64/
+          erlang-18.0-1.el7.centos.x86_64.rpm 和 erlang-wx-18.0-1.el7.centos.x86_64.rpm
+          # yum install erlang-18.0-1.el7.centos.x86_64.rpm erlang-wx-18.0-1.el7.centos.x86_64.rpm    
+    
+# erlang编译安装
+        安装 erlang
+        3 安装java环境 
+        3.1 下载java安装文件 wget http://download.oracle.com/otn-pub/java/jdk/7u1-b08/jdk-7u1-linux-i586.rpm 
+        3.2 使用rpm 安装 rpm -ivh jdk-7u1-linux-i586.rpm 
+        yum -y install ncurses-devel unixODBC-devel openssl-devel  gcc gcc-c++ autoconf automake libxslt gtk3-devel.x86_64 
+        
+        运行configure配置 
+        ./configure --prefix=/usr/local/erlang  --with-ssl  -enable-threads -enable-smmp-support -enable-kernel-poll  --enable-hipe  --without-javac
+        
+        fop is missing可以忽略
+        
+        运行make install安装 
+        8 安装 
+        8.1 将erlang源码包解压到/root目录下（一定要/root目录, 非/root目录需要配置参数，还没搞明白) 
+        8.2 运行./configrue 
+        8.3 运行 make install 
+        
+        CentOS添加环境变量
+        在Linux CentOS系统上安装完php和MySQL后，为了使用方便，需要将php和mysql命令加到系统命令中，如果在没有添加到环境变量之前，执行“php -v”命令查看当前php版本信息时时，则会提示命令不存在的错误，下面我们详细介绍一下在linux下将php和mysql加入到环境变量中的方法（假设php和mysql分别安装在/usr/local/webserver/php/和/usr/local/webserver/mysql/中）。
+        
+        方法一：直接运行命令export PATH=$PATH:/usr/local/webserver/php/bin 和 export PATH=$PATH:/usr/local/webserver/mysql/bin
+        
+        使用这种方法，只会对当前会话有效，也就是说每当登出或注销系统以后，PATH 设置就会失效，只是临时生效。
+        
+        方法二：执行vi ~/.bash_profile修改文件中PATH一行，将/usr/local/webserver/php/bin 和 /usr/local/webserver/mysql/bin 加入到PATH=$PATH:$HOME/bin一行之后
+        
+        这种方法只对当前登录用户生效
+        
+        方法三：修改/etc/profile文件使其永久性生效，并对所有系统用户生效，在文件末尾加上如下两行代码
+        PATH=$PATH:/usr/local/webserver/php/bin:/usr/local/webserver/mysql/bin
+        PATH=$PATH:/usr/local/erlang/bin
+
+        export PATH
+        
+        最后：执行 命令source /etc/profile或 执行点命令 ./profile使其修改生效，执行完可通过echo $PATH命令查看是否添加成功。

golang/goPanicRecover.md

@@ -0,0 +1,28 @@
+# 作用
+    pacin用来主动抛出错误
+    recover用来捕捉panic抛出的错误
+
+# 基本概念
+    函数签名
+    panic(i interface)
+    recover() interface{}
+    
+    引发panic有两种情况 一种是程序主动调用panic函数，另外一种就是程序产生运行时的错误，由运行是检测并抛出
+    
+    发生panic后 程序会从调用panic的函数位置或发生panic的地方立即返回， 逐层向上执行函数的defer语句，
+    然后逐层打印函数调用堆栈， 直到被recover捕获或运行到最外层函数而退出
+    
+    panic的参数是个空的接口类型interface{} 所以任意类型的变量都可以传参给panic
+    panic 不但可以在函数正常流程中抛出， 在defer逻辑里也可以再次调用panic或抛出panic
+    defer里面的panic能够被后续执行的defer捕获
+    recover()用来捕获panic,阻止panic继续向上传递， recover()和defer一起使用，但是recover()
+    只有在defer后面的函数体内被直接调用才能捕获panic终止异常， 否则返回nil， 异常继续向外传递
+    
+    
+    
+    
+    
+    
+    
+    
+        

golang/gomap.md

@@ -0,0 +1,16 @@
+# KeyValue限制
+    Key一定要是是可比较类型（可以理解为支持 == 的操作）
+    非法类型的Key 如果是非法的key类型，会报错：invalid map key type xxx。
+    
+    可比较类型	                不可比较类型
+    boolean	                    slice
+    numeric	                    map
+    string	                    func
+    pointer	
+    channel	
+    interface	
+    包含前文类型的array和struct
+
+# 函数传递
+    Golang中是没有引用传递的，均为值传递。这意味着传递的是数据的拷贝。
+    那么map本身是引用类型，作为形参或返回参数的时候，传递的是值的拷贝，而值是地址，扩容时也不会改变这个地址。    

golang/go并发相关.md

@@ -0,0 +1,8 @@
+# goroutine特性
+    go的执行是非阻塞的, 不会等待
+    go后面的函数返回值会被忽略。
+    调度器不能保证多个goroutine的执行次序
+    没有父子goroutine的概念 所有的goroutine是平等的被调度和执行的
+    Go程序在执行的时候会单独为main函数创建一个goroutine, 遇到其他go关键字时再去创建其他的goroutine
+    Go没有暴露goroutine Id给用户， 所以不能在一个goroutine里面显式的地操作另外一个gorontine,
+    不过runtine包提供了一些函数访问和设置gorontine的相关信息

golang/go打印堆栈.md

@@ -0,0 +1,4 @@
+# 打印堆栈
+    fmt.Printf("%s", debug.Stack())
+    debug.PrintStack()
+    可以通过 debug.PrintStack() 直接打印，也可以通过 debug.Stack() 方法获取堆栈然后自己打印。

golang/go接口.md

@@ -0,0 +1,60 @@
+# 接口
+    接口类型是对其他类型行为的概括和抽象，通过使用接口我们可以写出更加灵活和通用的函数
+    这些函数不用绑定在一个特定的类型实现上
+    
+    对于一个具体类型 无须声明他实现了哪些接口，只要提供接口所必需的方法即可
+
+# 接口即约定
+    之前介绍的类型都是具体类型， 具体类型指定了他所含的数据的精确布局
+    还暴露了基于这个精确布局的内部操作，比如对于数值有算术造作
+    对于slice类型有索引append range等
+    具体类型还会通过其他方法来提供额外的能力
+    总之你知道了一个具体类型的数据 你就精确的知道了他是什么以及他能干什么
+    
+    Go中还有另外一种类型称为接口类型， 他是一种抽象类型， 并没有暴露所含的数据的布局或者内部结构， 当然也没有那些数据的基本操作
+    他所提供仅仅是一些方法而已。如果你拿到一个接口类型的值 你无从知道他是什么 仅仅知道他能做什么或者更精确的讲仅仅是他提供哪些方法
+    
+# 接口类型
+    一个接口类型定义一套方法
+    如果一个具体类型要实现该接口
+    那么必须实现接口类型定义的所有方法
+    接口还可以通过组合得到新的接口
+    另外接口类型中方法的定义的顺序是无意义的，真正有意义的只有接口的方法集合
+    
+# 实现接口
+    如果一个类型实现了一个接口要求的所有方法， 那么这个类型实现了这个接口
+    通常所说的 具体类型是一个特定的接类型 这就代表这改具体类型实现了改接口
+    
+# 接口赋值规则
+    仅当一个表达式实现了一个接口时 这个表达式才可以赋值给该接口
+            
+# 空接口类型 interface{}
+    可以把任何值赋给控接口类型
+    这样函数就能接受任意类型的参数了啦啦啦啦啦啦
+    当然我们创建一个执行布尔值 浮点数 字符串 map 指针或其他类型的interface{}接口 也无法直接使用其中的值
+    毕竟这个接口不包含任何方法 我们需要一个方法从空接口中还原出实际值  
+    判断是否实现接口只需要毕竟具体类型和接口类型的方法 所以没必要在具体类型的定义中声明这种关系
+ 
+# 接口值
+    从概念上讲 一个接口类型的值简称接口值 其实有两个部分 一个具体类型和该类型的一个值 二者称为接口的动态类型和动态值
+    接口的零值就是把它的动态类型和值都设置为nil  可以用 ==nil 或者 ！= nil来检测一个接口值是否为nil 
+    调用一个nil接口的任何方法都会导致崩溃
+    一般来讲 在编译时 无法知道接口值的动态类型是什么， 所以通过接口来做调用必然需要使用动态分发
+    编译器必须生成一段代码来从类型描述符拿到名为write的方法地址 在间接调用该方法地址 调用这接收就是接口值的动态值
+    
+    一个接口值可以指向任意大的动态值 
+    接口值是可以比较的 所以他可以作为map的key 也可以作为switch的语句操作数（仅仅能确认接口值包含动态值可以比较时 才能比较接口值 不然会崩溃）
+    
+    P158
+    
+    
+    
+    
+    
+    
+    
+    
+              
+    
+     
+    

golang/go方法.md

@@ -0,0 +1,17 @@
+# 方法申明
+    方法的声明和普通哈数的什么类似， 只是在函数名字前面多了一个参数。
+    这个参数把这个方法绑定到这个参数对应的类型上
+    
+    命名类型（Point）与指向它们的指针 是唯一可以出现在接收这声明处的类型
+    而且为防止混淆 不允许本身是指针的类型进行方法声明
+    type P *int
+    func (p P) f() {/* ... */} //编译错误 非法的接受者类型
+    
+# 方法集
+    类型有一个与之相关的方法集（method set） 这决定了他是否实现了某个接口
+    
+    类型T方法集包含了所有 receiver T方法
+    类型*T方法集包含了所有receiver T + *T方法
+    匿名嵌入S， T方法集包含了所有 receiver S方法
+    匿名嵌入*S, T方法集包含了所有receiver S + *S方法
+    匿名嵌入S或*S, *T方法集包含了所有receiver S+ *S方法

golang/go语言函数.md

@@ -0,0 +1,56 @@
+# Go语言函数
+    函数时基本的代码块 用于执行一个任务
+    Go语言 最少有个main()函数
+    你可以用过函数来划分不同的功能 逻辑上每个函数执行的是知道的任务
+    函数声明告诉了编译器函数的名称 返回类型和参数
+    Go语言标准库提供了多种可动用的内置函数  例如 len()函数可以接受不同参数类型的并返回该类型的长度
+    如果传入的是字符串则返返回字符串的长度 如果传入的是数组 则返回数组的元素个数
+    
+# 函数定义格式
+    func function_name([参数列表]) [返回类型]{
+      函数体
+    }    
+    
+    函数定义解析：
+    func：函数由 func 开始声明
+    function_name：函数名称，函数名和参数列表一起构成了函数签名。
+    parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
+    return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
+    函数体：函数定义的代码集合。
+    
+## 函数参数
+    函数如果使用参数，该变量可称为函数的形参。
+    
+    形参就像定义在函数体内的局部变量。
+    
+    调用函数，可以通过两种方式来传递参数：
+    
+    传递类型	描述
+    值传递	值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
+    引用传递	引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
+    默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
+    
+    函数用法
+    函数用法	描述
+    函数作为另外一个函数的实参	函数定义后可作为另外一个函数的实参数传入
+    闭包	闭包是匿名函数，可在动态编程中使用
+    方法	方法就是一个包含了接受者的函数    
+    
+# 匿名函数
+    匿名函数是指没有定义名字符号的函数
+    除没有名字外 匿名函数和普通函数完全相同 最大的区别是 我们可以在匿名函数内定义匿名函数
+    形成类似嵌套效果。匿名函数可直接调用， 保存到变量， 作为函数参数和返回值   
+    将匿名函数赋值给变量 与普通函数提供的名字标识符有着根本的区别， 编译器会为匿名函数生成一个随机的符号名
+    
+    普通函数和匿名函数都可以作为结构体或经过通道传递
+    
+    未使用的匿名函数会被编译器当做错误
+     
+# 延迟函数
+    语句defer 向当前函数注册稍后执行的函数调用， 这些调用成为延迟调用
+    它们知道当前函数执行结束才被执行 常用语资源释放 接触锁定 以及错误处理等操作
+    FILO
+    性能:
+        相比直接调用call，延迟调用则会花费更大代价， 其中包括注册 调用等操作还有额外的缓存
+        因此对于性能要求较高的场合 因避免使用延迟函数
+             

golang/go语言切片.md

@@ -0,0 +1,15 @@
+# Go语言切片
+    Go语言切片是对数组的抽象
+    Go数组的长度不可改变 在特定场景中这样的集合就不在适用 而切片即使一个长度不固定 可以最佳元素 追加是可能使切片容量增大
+    
+## 定义切片
+    你可以声明一个未指定大小的数组来定义切片
+    var identifier []type
+    切片不需要说明长度
+    也可以使用make()函数来创建切片
+    var slice1 []type = make([]type, len)
+    也可以简写
+    clice1 := make([]type, len)
+    也可以指定容量， 其中capacity为可选参数
+    make([]T, length, capacity)
+    这里len是数组的长度并且也是切片的初始长度    

golang/go语言基础.md

@@ -0,0 +1,320 @@
+# Go语言结构
+    go语言的基础组成有一下几个部分组成
+        包声明             指明文件属于哪个包 其中package main表示一个可独立执行的程序 每个go应用程序都包含一个名为main的包
+        引入包             告诉go编译器这个程序需要引入的包或其他元素
+        函数              
+        变量
+        语句&表达式
+        注释              // 单行注释   /* .. */(不可嵌套)多行注释
+        
+        当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用
+        （客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，
+        但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
+        
+# 关于包
+    关于包，根据本地测试得出以下几点：
+    
+     文件名与包名没有直接关系，不一定要将文件名与包名定成同一个。
+     文件夹名与包名没有直接关系，并非需要一致。
+     同一个文件夹下的文件只能有一个包名，否则编译报错。 
+
+# go语言基础语法
+## Go标记
+    Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。如以下 GO 语句由 6 个标记组成：
+    
+## 行分割符
+    在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。
+    如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。    
+    
+## 注释
+    注释不会被编译，每一个包应该有相关注释。
+    单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾。
+    
+## 标识符
+    标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
+    以下是有效的标识符：
+    mahesh   kumar   abc   move_name   a_123
+    myname50   _temp   j   a23b9   retVal    
+    
+## 字符串连接
+    Go语言的字符串可以通过 + 实现
+    
+## 关键字
+     下面列举了 Go 代码中会使用到的 25 个关键字或保留字：
+     
+     break	default	func	interface	select
+     case	defer	go	map	struct
+     chan	else	goto	package	switch
+     const	fallthrough	if	range	type
+     continue	for	import	return	var
+     除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符：
+     
+     append	bool	byte	cap	close	complex	complex64	complex128	uint16
+     copy	false	float32	float64	imag	int	int8	int16	uint32
+     int32	int64	iota	len	make	new	nil	panic	uint64
+     print	println	real	recover	string	true	uint	uint8	uintptr
+     程序一般由关键字、常量、变量、运算符、类型和函数组成。
+     
+     程序中可能会使用到这些分隔符：括号 ()，中括号 [] 和大括号 {}。
+     
+     程序中可能会使用到这些标点符号：.、,、;、: 和 …。
+     
+## Go语言的空格
+      Go 语言中变量的声明必须使用空格隔开，如：
+      var age int;
+      语句中适当使用空格能让程序更易阅读。
+      无空格：
+      fruit=apples+oranges;
+      在变量与运算符间加入空格，程序看起来更加美观，如：
+      fruit = apples + oranges;     
+      
+# Go语言数据类型
+     在 Go 编程语言中，数据类型用于声明函数和变量。
+     数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
+     Go 语言按类别有以下几种数据类型： 
+        序号	类型和描述
+        1	布尔型
+        布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
+        2	数字类型
+        整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
+        3	字符串类型:
+        字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
+        4	派生类型:
+        包括：
+        (a) 指针类型（Pointer）
+        (b) 数组类型
+        (c) 结构化类型(struct)
+        (d) Channel 类型
+        (e) 函数类型
+        (f) 切片类型
+        (g) 接口类型（interface）
+        (h) Map 类型   
+        
+        
+        数字类型
+        Go 也有基于架构的类型，例如：int、uint 和 uintptr。
+        
+        序号	类型和描述
+        1	uint8
+        无符号 8 位整型 (0 到 255)
+        2	uint16
+        无符号 16 位整型 (0 到 65535)
+        3	uint32
+        无符号 32 位整型 (0 到 4294967295)
+        4	uint64
+        无符号 64 位整型 (0 到 18446744073709551615)
+        5	int8
+        有符号 8 位整型 (-128 到 127)
+        6	int16
+        有符号 16 位整型 (-32768 到 32767)
+        7	int32
+        有符号 32 位整型 (-2147483648 到 2147483647)
+        8	int64
+        有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) 
+        
+        浮点型
+        序号	类型和描述
+        1	float32
+        IEEE-754 32位浮点型数
+        2	float64
+        IEEE-754 64位浮点型数
+        3	complex64
+        32 位实数和虚数
+        4	complex128
+        64 位实数和虚数
+        
+        其他数字类型
+        以下列出了其他更多的数字类型：
+        
+        序号	类型和描述
+        1	byte
+        类似 uint8
+        2	rune
+        类似 int32
+        3	uint
+        32 或 64 位
+        4	int
+        与 uint 一样大小
+        5	uintptr
+        无符号整型，用于存放一个指针
+        
+# Go语言变量
+      变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。
+      变量可以通过变量名访问。
+      Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
+      声明变量的一般形式是使用 var 关键字：
+      var identifier type
+      可以一次声明多个变量：
+      var identifier1, identifier2 type      
+      
+## 变量声明
+    第一种，指定变量类型，如果没有初始化，则变量默认为零值。 零值就是变量没有做初始化时系统默认设置的值。
+        var v_name v_type
+        v_name = value  
+        var v_name v_type = value
+    
+    数值类型（包括complex64/128）为 0
+    布尔类型为 false
+    字符串为 ""（空字符串）
+    以下几种类型为 nil：   
+    var a *int
+    var a []int
+    var a map[string] int
+    var a chan int
+    var a func(string) int
+    var a error // error 是接口
+    
+    第二种，根据值自行判定变量类型。
+        var v_name = value
+        
+    第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：
+        v_name := value    
+    IE
+        var intVal int 
+        intVal :=1 // 这时候会产生编译错误
+        intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，
+        注意：：：：因为 := 是一个声明语句
+
+
+## 多变量声明
+    //类型相同多个变量, 非全局变量
+    var vname1, vname2, vname3 type
+    vname1, vname2, vname3 = v1, v2, v3
+    var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断
+    vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误
+    // 这种因式分解关键字的写法一般用于声明全局变量
+    var (
+        vname1 v_type1
+        vname2 v_type2
+    )        
+      
+## 值类型和引用类型
+     所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值：
+     当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝：   
+     你可以通过 &i 来获取变量 i 的内存地址，例如：0xf840000040（每次的地址都可能不一样）。值类型的变量的值存储在栈中。
+     内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。
+     更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。
+     一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。 
+     这个内存地址为称之为指针，这个指针实际上也被存在另外的某一个字中。
+     同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），这也是计算效率最高的一种存储形式；也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。
+     当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。
+     如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。
+     
+## 简短形式，使用 := 赋值操作符
+    我们知道可以在变量的初始化时省略变量的类型而由系统自动推断，声明语句写上 var 关键字其实是显得有些多余了，因此我们可以将它们简写为 a := 50 或 b := false。
+    a 和 b 的类型（int 和 bool）将由编译器自动推断。
+    这是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。使用操作符 := 可以高效地创建一个新的变量，称之为初始化声明。     
+    注意事项
+    如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。
+    
+    如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。
+    
+    如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：
+    
+    实例
+    package main
+    
+    import "fmt"
+    
+    func main() {
+       var a string = "abc"
+       fmt.Println("hello, world")
+    }
+    尝试编译这段代码将得到错误 a declared and not used。
+    
+    此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用
+    
+    fmt.Println("hello, world", a)
+    会移除错误。
+    
+    但是全局变量是允许声明但不使用。 同一类型的多个变量可以声明在同一行，如：
+    
+    var a, b, c int
+    多变量可以在同一行进行赋值，如：
+    
+    var a, b int
+    var c string
+    a, b, c = 5, 7, "abc"
+    上面这行假设了变量 a，b 和 c 都已经被声明，否则的话应该这样使用：
+    
+    a, b, c := 5, 7, "abc"
+    右边的这些值以相同的顺序赋值给左边的变量，所以 a 的值是 5， b 的值是 7，c 的值是 "abc"。
+    
+    这被称为 并行 或 同时 赋值。
+    
+    如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。
+    
+    空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
+    
+    _ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。
+    
+    并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)。  
+        
+# Go语言常量
+    常量是一个简单值的标识符，在程序运行时，不会被修改的量。
+    
+    常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
+    
+    常量的定义格式：
+    
+    const identifier [type] = value
+    你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。
+    
+    显式类型定义： const b string = "abc"
+    隐式类型定义： const b = "abc"
+    多个相同类型的声明可以简写为：
+    
+    const c_name1, c_name2 = value1, value2
+    
+    常量还可以用作枚举：
+    
+    const (
+        Unknown = 0
+        Female = 1
+        Male = 2
+    )
+    数字 0、1 和 2 分别代表未知性别、女性和男性。
+    
+    常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：
+    
+## iota
+   iota，特殊常量，可以认为是一个可以被编译器修改的常量。
+   iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
+   iota 可以被用作枚举值：
+   const (
+       a = iota
+       b = iota
+       c = iota
+   )    
+   
+   包级别的初始化  在main执行之前
+        
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+                
+        

golang/go语言循环语句.md

@@ -0,0 +1,64 @@
+# Go 语言循环语句
+    在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。
+    
+    以下为大多编程语言循环程序的流程图： 
+    
+    Go 语言提供了以下几种类型循环处理语句：
+    
+    循环类型	描述
+    for 循环	重复执行语句块
+        for init; condition; post { }
+            init： 一般为赋值表达式，给控制变量赋初值；
+            condition： 关系表达式或逻辑表达式，循环控制条件；
+            post： 一般为赋值表达式，给控制变量增量或减量。
+        for condition { } 
+        for { }     
+    循环嵌套	在 for 循环中嵌套一个或多个 for 循环
+        以下为 Go 语言嵌套循环的格式：
+        
+        for [condition |  ( init; condition; increment ) | Range]
+        {
+           for [condition |  ( init; condition; increment ) | Range]
+           {
+              statement(s);
+           }
+           statement(s);
+        }
+    循环控制语句
+    循环控制语句可以控制循环体内语句的执行过程。
+    
+    GO 语言支持以下几种循环控制语句：
+    
+    控制语句	描述
+    break 语句	经常用于中断当前 for 循环或跳出 switch 语句
+        Go 语言中 break 语句用于以下两方面：
+        用于循环语句中跳出循环，并开始执行循环之后的语句。
+        break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
+        在多重循环中，可以用标号 label 标出想 break 的循环。
+    continue 语句	跳过当前循环的剩余语句，然后继续进行下一轮循环。
+        Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。
+        for 循环中，执行 continue 语句会触发 for 增量语句的执行。
+        在多重循环中，可以用标号 label 标出想 continue 的循环。
+    goto 语句	将控制转移到被标记的语句。
+        Go 语言的 goto 语句可以无条件地转移到过程中指定的行。
+        goto 语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。
+        但是，在结构化程序设计中一般不主张使用 goto 语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。
+        语法
+        goto 语法格式如下：
+        goto label;
+        ..
+        .
+        label: statement;
+    无限循环
+    如果循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环：
+    
+    实例
+    package main
+    
+    import "fmt"
+    
+    func main() {
+        for true  {
+            fmt.Printf("这是无限循环。\n");
+        }
+    }

golang/go语言指针.md

@@ -0,0 +1,23 @@
+#Go 语言指针
+    Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。
+    接下来让我们来一步步学习 Go 语言指针。
+    我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。
+    Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
+    
+# 什么是指针
+    一个指针变量指向了一个值的内存地址。
+    类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：
+    var var_name *var-type  
+    
+# 如何使用指针
+    指针使用流程：
+    定义指针变量。
+    为指针变量赋值。
+    访问指针变量中指向地址的值。
+    在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。  
+    
+# Go 空指针
+    当一个指针被定义后没有分配到任何变量时，它的值为 nil。
+    nil 指针也称为空指针。
+    nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。
+    一个指针变量通常缩写为 ptr。        

golang/go语言数组.md

@@ -0,0 +1,25 @@
+# Go 语言数组
+    Go 语言提供了数组类型的数据结构。
+    数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。
+    相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。
+    数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。
+    
+## 声明数组
+    Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：
+    var variable_name [SIZE] variable_type
+    以上为一维数组的定义方式。例如以下定义了数组 balance 长度为 10 类型为 float32：
+    var balance [10] float32   
+    
+## 初始化数组
+    var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 56.0}
+    初始化数组中 {} 中的元素个数不能大于 [] 中的数字。    
+    如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
+    var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
+    该实例与上面的实例是一样的，虽然没有设置数组的大小。
+    balance[4] = 50.0
+    
+## 访问数组元素    
+
+    
+     
+     

golang/go语言条件语句.md

@@ -0,0 +1,76 @@
+# Go 语言条件语句
+    条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。
+    
+    下图展示了程序语言中条件语句的结构：
+    
+    Go 语言条件语句
+    Go 语言提供了以下几种条件判断语句：
+    
+    语句	描述
+    if 语句	if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
+        if 布尔表达式 {
+           /* 在布尔表达式为 true 时执行 */
+        }
+    
+    if...else 语句	if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
+        if 布尔表达式 {
+           /* 在布尔表达式为 true 时执行 */
+        } else {
+          /* 在布尔表达式为 false 时执行 */
+        }
+    if 嵌套语句	你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
+        if 布尔表达式 1 {
+           /* 在布尔表达式 1 为 true 时执行 */
+           if 布尔表达式 2 {
+              /* 在布尔表达式 2 为 true 时执行 */
+           }
+        }
+    switch 语句	switch 语句用于基于不同条件执行不同动作。
+        switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。
+        
+        switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。
+        
+        switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。
+        
+        语法
+        Go 编程语言中 switch 语句的语法如下：
+        
+        switch var1 {
+            case val1:
+                ...
+            case val2:
+                ...
+            default:
+                ...
+        }
+        变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
+        
+        您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。
+    select 语句	select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。
+        select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。
+        
+        select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。
+        
+        语法
+        Go 编程语言中 select 语句的语法如下：
+        
+        select {
+            case communication clause  :
+               statement(s);      
+            case communication clause  :
+               statement(s); 
+            /* 你可以定义任意数量的 case */
+            default : /* 可选 */
+               statement(s);
+        }
+        以下描述了 select 语句的语法：
+        
+        每个 case 都必须是一个通信
+        所有 channel 表达式都会被求值
+        所有被发送的表达式都会被求值
+        如果任意某个通信可以进行，它就执行，其他被忽略。
+        如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。 
+        否则：
+        如果有 default 子句，则执行该语句。
+        如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。
+    注意：Go 没有三目运算符，所以不支持 ?: 形式的条件判断。

golang/go语言结构体.md

@@ -0,0 +1,33 @@
+# Go 语言结构体
+    Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。
+    结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
+    
+## 定义结构体
+    结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：
+    
+    type struct_variable_type struct {
+       member definition
+       member definition
+       ...
+       member definition
+    }
+    一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：
+    
+    variable_name := structure_variable_type {value1, value2...valuen}
+    或
+    variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}    
+    
+## 访问结构体成员
+    如果要访问结构体成员，需要使用点号 . 操作符，格式为：
+    结构体.成员名"   
+    
+## 结构体指针
+    你可以定义指向结构体的指针类似于其他指针变量，格式如下：
+    
+    var struct_pointer *Books
+    以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：
+    
+    struct_pointer = &Book1
+    使用结构体指针访问结构体成员，使用 "." 操作符：
+    
+    struct_pointer.title     

golang/go语言运算符.md

@@ -0,0 +1,88 @@
+#Go 语言运算符
+    Go语言内置的运算符有
+        算术运算符
+        关系运算符
+        逻辑运算符
+        位运算符
+        赋值运算符
+        其他运算符
+        
+        
+## 算术运算符
+    +	相加	A + B 输出结果 30
+    -	相减	A - B 输出结果 -10
+    *	相乘	A * B 输出结果 200
+    /	相除	B / A 输出结果 2
+    %	求余	B % A 输出结果 0
+    ++	自增	A++ 输出结果 11
+    --	自减	A-- 输出结果 9    
+    如果想除法得到小数 将其中一个数转为浮点数再相除就行
+    
+    注意：：：： Go 的自增，自减只能作为表达式使用，而不能用于赋值语句。
+    a++ // 这是允许的，类似 a = a + 1,结果与 a++ 相同
+    a-- //与 a++ 相似
+    a = a++ // 这是不允许的，会出现变异错误 syntax error: unexpected ++ at end of statement
+     
+## 关系运算符
+    下表列出了所有Go语言的关系运算符。假定 A 值为 10，B 值为 20。
+    
+    运算符	描述	实例
+    ==	检查两个值是否相等，如果相等返回 True 否则返回 False。	(A == B) 为 False
+    !=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。	(A != B) 为 True
+    >	检查左边值是否大于右边值，如果是返回 True 否则返回 False。	(A > B) 为 False
+    <	检查左边值是否小于右边值，如果是返回 True 否则返回 False。	(A < B) 为 True
+    >=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。	(A >= B) 为 False
+    <=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。	(A <= B) 为 True     
+    
+## 逻辑运算符
+    下表列出了所有Go语言的逻辑运算符。假定 A 值为 True，B 值为 False。
+    
+    运算符	描述	实例
+    &&	逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。	(A && B) 为 False
+    ||	逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。	(A || B) 为 True
+    !	逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。         
+    
+## 位运算符
+    Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：
+    
+    运算符	描述	实例
+    &	按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。	(A & B) 结果为 12, 二进制为 0000 1100
+    |	按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或	(A | B) 结果为 61, 二进制为 0011 1101
+    ^	按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。	(A ^ B) 结果为 49, 二进制为 0011 0001
+    <<	左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	A << 2 结果为 240 ，二进制为 1111 0000
+    >>	右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。     
+    
+## 赋值运算符
+    下表列出了所有Go语言的赋值运算符。
+    
+    运算符	描述	实例
+    =	简单的赋值运算符，将一个表达式的值赋给一个左值	C = A + B 将 A + B 表达式结果赋值给 C
+    +=	相加后再赋值	C += A 等于 C = C + A
+    -=	相减后再赋值	C -= A 等于 C = C - A
+    *=	相乘后再赋值	C *= A 等于 C = C * A
+    /=	相除后再赋值	C /= A 等于 C = C / A
+    %=	求余后再赋值	C %= A 等于 C = C % A
+    <<=	左移后赋值	C <<= 2 等于 C = C << 2
+    >>=	右移后赋值	C >>= 2 等于 C = C >> 2
+    &=	按位与后赋值	C &= 2 等于 C = C & 2
+    ^=	按位异或后赋值	C ^= 2 等于 C = C ^ 2
+    |=	按位或后赋值	C |= 2 等于 C = C | 2    
+    
+## 其他运算符    
+    运算符	描述	实例
+    &	返回变量存储地址	&a; 将给出变量的实际地址。
+    *	指针变量。	*a; 是一个指针变量
+    
+    
+## 运算符优先级
+    有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：
+    
+    优先级	运算符
+    5	* / % << >> & &^
+    4	+ - | ^
+    3	== != < <= > >=
+    2	&&
+    1	||
+    当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。
+    
+        

golang/go闭包讲解.md

@@ -0,0 +1,13 @@
+# 闭包
+    概念： 闭包是由函数及其引用环境组合而成，一般通过在匿名函数中引用外部函数的局部变量或全局变量构成
+    所以： 闭包=函数 + 引用环境
+    闭包对闭包外的环境引入是直接引用，编译器检测到闭包，会将闭包使用的外部变量分配到堆上
+    如果函数返回的闭包使用了该函数的局部变量(参数或函数内部变量):
+        1. 多次调用该函数，返回的多个闭包所引用的外部变量是多个副本， 原因是每次调用函数都会为局部变量分配内存
+        2. 用一个闭包函数多次， 如果该闭包修改了其使用的外部变量， 则每一次调用改闭包对该外部变量都有影响，因为闭包函数共享外部引用
+        
+    如果一个函数调用返回的闭包使用全局变量，则每次调用都会影响全局变量
+    如果函数返回的闭包引用的是全局变量a，则多次调用该函数返回的多个闭包引用的都是同一个a， 同理调用一个闭包多次用的也是同一个a,此时如果闭包
+    中修改了a值的逻辑则每次闭包调用都会影响全局变量a的值， 使用闭包的目的是为了减少全局变量，所以闭包引用全局变量不是好的编程方式。
+    同一个函数返回的多个闭包共享该函数的局部变量 
+