diff --git a/2.2.md b/2.2.md
index 38b1ea28..1a36898d 100644
--- a/2.2.md
+++ b/2.2.md
@@ -1,26 +1,214 @@
 #2.2 GO基础
 
+这小节我们将要介绍如何定义变量、常量、GO内置类型以及一些GO设计中的技巧
+
 ##定义变量
 
+GO语言里面定义变量有好几种方式。
+
+最基本的定义变量如下，go变量定义，它的类型是跟在变量后面的，而不是像C一样放前面
+
+	//定义一个名称为“variable_name”、类型为"type"的变量
+	var variable_name type	
+
+定义多个变量
+
+	//定义三个类型都是"type"的三个变量
+	var vname1,vname2,vname3 type
+	
+定义变量并且带有初始化的值
+
+	//初始化“variable_name”的变量为“value”值，类型是"type"
+	var variable_name type = value
+
+同时初始化多个变量
+
+	/*
+	    定义三个类型都是"type"的三个变量,并且他们分别初始化相应的值
+	    vname1为v1，vname2为v2，vname3为v3
+	*/
+	var vname1,vname2,vname3 type= v1, v2, v3
+
+你是不是觉得上面这样的定义有点复杂，没关系，因为go语言的设计者也发现这样复杂了，那么让我们来让他变的简单一点，我们可以直接忽略类型这个申明，那么上面的什么变成了如下
+
+	/*
+	    定义三个变量，他们分别初始化相应的值
+	    vname1为v1，vname2为v2，vname3为v3
+	    然后他们的类型自动根据初始化的值来确定相应的类型，go会帮你做这件事
+	*/
+	var vname1,vname2,vname3= v1, v2, v3
+
+你还是觉得上面的复杂？好吧，我也觉得是，让我们继续简化
+
+	/*
+	    定义三个变量，他们分别初始化相应的值
+	    vname1为v1，vname2为v2，vname3为v3
+	    然后他们的类型自动根据初始化的值来确定相应的类型，go会帮你做这件事
+	*/
+	vname1,vname2,vname3 := v1, v2, v3
+	
+现在是不是看上去非常的简单了，`:=`这个定义直接替代了`var`和`type`,这样的代码是不是很简洁，但是`:=`有一个限制，那就是这个必须用在函数内部，不能在函数外部使用。
+
+一个特殊的变量名是`_`（下划线）。任何赋给它的值都被丢弃。在这个例子中，将赋值35赋值给b，同时丢弃34。

	_, b := 34, 35

Go的编译器对声明却未使用的变量会在编译阶段报错。下面的代码会产生一个错误：声明了i却未使用
+
	package main
+
	func main() {
		var i int
	}
+
+##常量
+
+所谓常量，也就是在编译阶段就确定下来的值，程序运行时无法改变该值，GO程序里面，常量定义可以是数字类型、Bool、字符串
+
+它的语法如下
+
+	const constant_name = value
+	
+下面是一些什么的例子
+
+	const PI = 3.1415927
+	const i = 10000
+	const Max_Thread = 10
+	const prefix = 'astaxie_'
+
+当然如果需要，可以明确指定常量的类型：
+
+	const PI float32 = 3.1415927
+
+
 ##内置基础类型
 
 ###Boolean
 
+对于布尔值，GO的bool类型(如C++)值有:`true`和`false`。他的类型是:`bool`
+
+	//示例代码
+	var isactive bool 
+	var enabled, disabled = true, false //忽略类型的申明
+	func test(){
+    	var available bool //一般的申明
+    	valid := false //忽略var和type的什么
+    	available = true //赋值操作
+	}
+
+
 ###数字类型
 
+对于整数类型，有无符号和有符号两种，GO同时支持`int`和`uint`,这两种类型会根据你的机器来决定是32还是64(32位硬件上是32位的；在64位硬件上是64位的。)。GO里面也有直接定义好位数的类型`rune`, `int8`, `int16`, `int32`, `int64`和`byte`, `uint8`, `uint16`, `uint32`, `uint64`。`rune`是`int`的别称。`byte`是`uint8`的别称。
+
+>注意一点就是这些类型之间的变量不允许相互之间赋值、操作，不然会引起编译器的错误。
+>
+>如下的代码会出现错误
+>	
+>	var a int8
+>	
+>	var b int32
+>	
+>	c:=a + b
+
+浮点类型的值有`float32`和`float64`(没有`float`类型)。
+
+这就是全部吗？NO！Go支持复数。它的变量类型是`complex128`（64位实数，64位虚数）。如果需要小一些的，还有`complex64`(32为实数，32位虚数)。复数写为`re + imi`，`re`是实数部分，`im`是虚数部分，而i 是标记`i`。使用复数的一个例子：

	var c complex64 = 5+5i;
+
	fmt.Printf("Value is: %v", c)

将会打印：(5+5i)
+
 ###字符串
 
-##常量
+前面一节里面说过，字符串都是UTF-8类型的，字符串通过一对`"`来定义，它的类型是string
+
+	//示例代码
+	var french_hello string //一般申明一个变量为字符串
+	var empty_string string = "" // 什么了一个字符串变量，初始化为空值
+	func test(){
+	    no, yes, maybe := "no", "yes", "maybe" //忽略var和type的申明，同时申明多个变量
+	    japanese_hello := "Ohaiou"  //同上
+	    french_hello = "Bonjour" //normal assignation
+	}
+	
+在Go中字符串是不可变的，例如如下的代码编译时会报错
+
+	var s string = "hello"
	s[0] = 'c'
+

那么如果真的想要修改怎么办呢？如下的代码可以实现
+
	s := "hello"
	c := []byte(s)
	c[0] = 'c' 
	s2 := string(c)
	fmt.Printf("%s\n", s2)
+

GO中可以使用`+`来链接两个字符串
+
+	s := "hello"
+	m := "world"
+	a := s + m
+    fmt.Printf("%s\n", a)
+ 
+如果要什么一个多行的字符串怎么办？第一种是通过`+`把字符串串联起来，第二种是通过`\'`来什么
+
+	s:= "hello" +
+	    "world"
+	m:=`hello
+		world`		
+	     
+    
+###GO数据底层的存储
+
+下面这张图来源于 Russ Cox介绍的GO数据结构，大家可以看到这些基础类型底层都是开辟了一块内存，然后存了相应的值
+
+![](images/2.2.basic.png?raw=true)
+
+###错误类型
+Go内置有一个`error`类型，专门用来处理错误信息，GO的package里面还专门有一个包errors来处理错误
+
+	err := errors.New("emit macho dwarf: elf header corrupted")
+	if err != nil {
+	    fmt.Print(err)
+	}
 
 ##一些技巧
 
 ###分组定义
+
+Go语言里面针对多个同时什么变量、常量或者import多个包的时候可以采用分组的方式来申明
+
+如下的代码
+
+	import "fmt"
+	import "os"
+
+	const i = 100
+	const pi = 3.1415
+	const prefix = "go_"
+
+	var i int
+	var pi float32
+	var prefix string
+
+可以通过分组的方式写成如下
+
+	import(
+	    "fmt"
+	    "os"
+	)
+
+	const(
+	    i = 100
+	    pi = 3.1415
+	    prefix = "go_"
+	)
+	
+	var(
+	    i int
+	    pi float32
+	    prefix string
+	)	
+	
+
 ###iota枚举
 
+GO里面有一个关键字`iota`，这个关键字用来什么enum的时候采用，它默认开始值是0，没调用一次加1
+
+	const(
+    	x = iota //x == 0
+    	y = iota //y == 1
+    	z = iota //z == 2
+    	w // 这里隐示的说w==iota,因此w==3,其实上面y和z可以同样不用=iota
+	)
+
 ## links
    * [目录](<preface.md>)
    * 上一章: [你好,GO](<2.1.md>)
-   * 下一节: [函数](<2.3.md>)
+   * 下一节: [流程和函数](<2.3.md>)
 
 ## LastModified 
    * $Id$
\ No newline at end of file
diff --git a/2.md b/2.md
index b5d3968b..6ab5970c 100644
--- a/2.md
+++ b/2.md
@@ -3,7 +3,7 @@
 ## 目录
    * 1. [你好，GO](2.1.md)
    * 2. [GO基础](2.2.md)
-   * 3. [函数](2.3.md)
+   * 3. [流程和函数](2.3.md)
    * 4. [混合类型](2.4.md)
    * 5. [高级类型](2.5.md)
    * 6. [面向对象](2.6.md)
diff --git a/images/2.2.basic.png b/images/2.2.basic.png
new file mode 100644
index 00000000..e1ed9ce7
Binary files /dev/null and b/images/2.2.basic.png differ
diff --git a/preface.md b/preface.md
index c2e34a97..27002466 100644
--- a/preface.md
+++ b/preface.md
@@ -7,7 +7,7 @@
 * 2.[GO语言基础](2.md)
  - 2.1. [你好，GO](2.1.md)
  - 2.2. [GO基础](2.2.md)
- - 2.3. [函数](2.3.md)
+ - 2.3. [流程和函数](2.3.md)
  - 2.4. [混合类型](2.4.md)
  - 2.5. [高级类型](2.5.md)
  - 2.6. [面向对象](2.6.md)