1.GO语言开发环境搭建                                             

1.1编译环境安装

点击链接http://code.google.com/p/go/downloads/list

选择一个版本，本人下载的是go1.0.3.windows-386.msi

双击安装，选择安装一个安装主目录：例如，C:\Go，不需要配置什么东西。

1.2集成开发环境IDE安装配置

打开链接：http://code.google.com/p/golangide/downloads/list

下载一个版本：如liteidex17.windows.7z

下载完毕后在某个目录下解压即可

点击liteide.exe，打开开发界面。

配置环境变量                 

菜单：查看→选项，选择LiteEnv，配置环境变量，有三个文件，system.env,win32.env,win32-user-env需要配置，配置很简单，只需要修改上一步安装的编译环境目录即可，三个文件都一样。

　　GOROOT=C:\Go
　　GOBIN=C:\Go\bin
　　取消掉PAHT前的#号，其他的不用修改
选择查看→设置GOPATH，刷新就可以看到system 的GOPATH，浏览自定义的GOPATH，设置存放代码的空间目录，开发环境就搭建好了

2.HelloWorld！                                                 

　　语言"出生"后"说"的的第一句话都是，Hello World！

　　使用GO语言，是这样说的：

1 package main
2 
3 import (
4     "fmt"
5 )
6 
7 func main() {
8     fmt.Println("Hello World!")
9 }

　　编译后运行即可出现：Hello World！

3.初见GO语言                                                               

　　GO语言Google开发的新语言。有如下特性
　　自动垃圾回收、更丰富的内置数据类型、函数多返回值、错误处理、匿名函数和闭包、类型和接口、并发编程、反射、多语言混合编程

1 package main   
2 
3 // 我们需要使用fmt包中的Println()函数 
4 import "fmt"
5  
6 func main() {      
7     fmt.Println("Hello, world！")  
8 } 

3.1代码解析                        

package main

　　每个GO源代码文件的开头声明该Go代码所属的包，包是Go语言里最基本的分发单位，要生成可执行程序，必须建立一个名字为main的包，并且在该包中包含一个叫main()的函数(该函数是Go可执行程序的执行起点)。
func main()

　　主函数main()，该函数是执行程序的起点，不能带参数，也不能定义返回值。命令传入的参数在os.Args变量中保存。如果需要支持命令行开关，使用flag包。

import 导包

　　导入该程序所需要的其他包。由于用到了系统函数Println()，所以导入该函数所属的fmt包。

注意

　　不能把源代码文件中没有用到的包导进去，否则Go编译器会报编译错误

func关键字
　　所有的Go函数(包括在对象编程中会提到的类型成员函数)以关键字func开头。一个常规的函数定义如下：

1 func 函数名(参数列表)(返回值列表){
2  //函数体
3 }

　　可以看出Go语言与其他语言定义函数的区别，它把返回值列表也列在里面。
对应示例：

1 func Compute(value1 int,value2 float64)(result float64,err error){
2  //函数体
3 }

　　Go支持多个返回值。上面的函数Compute()返回了两个值，一个叫result，一个是err，并不是所有返回值都必须赋值，如果没有明确赋值的返回值被设置为默认值，会根据基本数据类型对返回值初始化，float64为0.0, error为nil，也就是result是0.0 err为nil
注释：
Go程序的代码注释有两种：块注释和行注释
　　/*
　　块注释
　　*/
　　//行注释

语句结束符号

　　关于语句结束符号：Go程序不要求开发者在每个语句后面加上分号表示语句结束，当然加上也可以，但Google提供的IDE开发工具在加上分号；后编译时会自动消掉分号
大括号位置
 　　在Java程序设计里面有提到过大括号怎么放。Go语言中，在函数的返回值后面紧着函数体的左大括号，不能另起一行，这一点与Java通常用法是一致的，也有人把同一个级别的函数体左括号单独起一行，与右括号放在一列，这样在Go语言中是不行的。

1 func 函数名(参数列表)(返回值列表)
2 {
3  //函数体
4 }

　　其实可以发现左括号放在返回值列表后面是有一个好的地方是：在很多编辑器里面，比如notepad，它把左括号和右括号之间用线连起来，显得是一个整体，如果把左括号单独起一行，会显得函数定义时候func行不与函数体一起，而把左大括号放在func行，会显得整个函数浑然一体。

3.2若干命令                        

查看go版本
　　cmd —— go version输出 go version go1.0.3
编译源程序
 　　go build HelloWorld.go
运行编译后代码
 　　HelloWorld.exe

函数的单元测试
xxx.go对应的单元测试是xxx_test.go，这是go工程里的命名规则

2. 顺序编程                                                                  

2.1 变量                              

　　从根本上说，变量是对一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后通过调用（引用）变量名来使用这块存储空间

2.1.1 变量定义               

　　Go语言的变量声明方式与其他语言相差比较大。引入了一个关键字var(但不是必须的)，表示一个变量

定义语法

　　var 变量名 变量类型
示例：var name string

　　这种方式其实更符合英语习惯 可以把上面的定义方式扩展成英语：the variable name is a string 变量name是一个string，如果去掉动词、量词就可以看出var name string 比较近似我们平时使用的英语语法结构。

类似地：

 1 var v1 int
 2 var v2 string
 3 var v3 [10]int   //定义一个固定长度的数组
 4 var v4 []int   //定义一个可变长度的数组
 5 var v5 struct{
 6  f int
 7 }
 8 var v6 *int    //指针
 9 var v7 map[string]int //字典，或者说关联数组与Java的map类似，key为string类型，value为int类型
10 var v8 func(a int) int

变量块

可以使用var关键字声明若干个关键字，形成一个变量块

1 var(
2  v1 int
3  v2 string
4 )

   从上面多出的var关键字可以看出，有一个var关键字更加符合英语习惯，不仅如此，可以同时声明多个变量，把变量用一个关键字var包起来，形成一个整块，这样可读性更好，不会让变量乱放。

2.1.2变量赋值                         

1  //定义一个变量
2  var v1 int
3  //对一个变量初始化赋值
4  v1 = 10

　　上面的两步可以合成，也就是定义加初始化用一个语句完成。 

 有三种方式
 

1 var v1 int = 10 //正确使用方式1
2 var v2 = 10     //正确使用方式2，编译器可以自动推导出v2的类型
3 v3 := 10     //正确使用方式3，编译器可以自动推导v3的类型

　　 :=这个运算符包含了定义和初始化两步操作。出现这个运算符的变量不应该是已经被定义过的，否则会编译错误。
 　　指定变量类型不是必须的，看起来有点像动态类型语言。但实际是静态语言。
 　　Go语言提供了多重赋值功能，例如进行i，j的值交换，这样可以避免很多无关的变量都定义了，影响代码可读性
 　　i,j = j,i

2.1.3匿名变量             

　　我们在使用传统的强类型语言编程时，经常会出现这种情况，即在调用函数时为了获取一个值，却因为该函数返回多个值而不得不定义一堆没用的变量。在Go中这种情况可以通过结合使
用多重返回和匿名变量来避免这种丑陋的写法，让代码看起来更加优雅。 

 2.2 常量

 　　常量是指编译期间已知且不可改变的值，常量可以是数值类型(包括整型、浮点型和复数类型)、布尔类型、字符串类型

2.2.1 字面常量                     

　　字面常量是指程序中硬编码的常量，如
无类型 2   //由于2在许多数值类型定义域内，并且没有规定2的类型，因此是一个无类型，当然也可以指定2L，是一个long型的
浮点型 3.1415926
复数型 3.2+12i
布尔型 true
字符串 "true"

2.2.2常量定义                     

　　通过const关键字，可以指定字面常量名字

1 const Pi float64 = 3.1432423424234
2 const zero = 0.0
3 const(
4  size int64 = 1024
5  eof = -1//无类型整型常量
6 )
7 const u,v float32 = 0.3 //定义多重赋值
8 const a,b,c = 3,4,"true" //a = 3,b = 4,c = "true"，无类型整型和字符串常量

　　常量定义的右值也可以是一个编译期运算的常量表达式
　　const mask = 1 <<3
　　常量的赋值是一个编译期行为，所以右值不能出现任何需要运行期才能得出结果的表达式(否则就不是常量了)
下面的例子就会导致编译错误,常量就是运行前就已经确定的值。
const Home = os.GetEnv("HOME") 

 2.2.3 预定义常量    

　　Go语言预定义了这些常量true、false和iota.iota比较特殊，可以被认为是一个可被编译器修改的常量，在每一个const关键字出现时被重置为0，然后在下一个const出现之前，每出现一次iota，其所代表的数字会自动增1。
　　从以下的例子可以基本理解iota的用法： 

 1 const (            // iota被重设为0 
 2     c0 = iota   // c0 == 0 
 3     c1 = iota     // c1 == 1 
 4     c2 = iota     // c2 == 2  
 5 )   
 6  
 7 const ( 
 8     a = 1 << iota   // a == 1 (iota在每个const开头被重设为0) 
 9     b = 1 << iota    // b == 2 
10     c = 1 << iota    // c == 4  
11 )   
12  
13 const ( 
14     u         = iota * 42   // u == 0 
15     v float64 = iota * 42   // v == 42.0 
16  w         = iota * 42  // w == 84  
17 )   
18 const x = iota     // x == 0 (因为iota又被重设为0了)  
19 const y = iota     // y == 0 (同上) 

如果两个const的赋值语句的表达式是一样的，那么可以省略后一个赋值表达式。因此，上面的前两个const语句可简写为： 

 1 const (       // iota被重设为0 
 2     c0 = iota      // c0 == 0 
 3     c1      // c1 == 1 
 4     c2       // c2 == 2 
 5 ) 
 6  
 7 const ( 
 8     a = 1 <<iota     // a == 1 (iota在每个const开头被重设为0) 
 9     b      // b == 2 
10     c      // c == 4 
11 ) 

　　个人认为iota未必是一个好的数据类型 

2.2.4枚举              

　　枚举指一系列相关的常量，比如下面关于一个星期中每天的定义。通过上一节的例子，我们看到可以用在const后跟一对圆括号的方式定义一组常量，这种定义法在Go语言中通常用于定义
枚举值。Go语言并不支持众多其他语言明确支持的enum关键字。
　　下面是一个常规的枚举表示法，其中定义了一系列整型常量：

 1 const ( 
 2     Sunday = iota 
 3     Monday 
 4     Tuesday 
 5     Wednesday 
 6     Thursday 
 7     Friday 
 8     Saturday 
 9     numberOfDays        // 这个常量没有导出  
10 )  

　　同Go语言的其他符号（symbol）一样，以大写字母开头的常量在包外可见。 以上例子中numberOfDays为包内私有，其他符号则可被其他包访问。

2.3 数据类型                      

Go支持如下数据类型