GO程序设计1——快速入门

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支持如下数据类型

本文来自:CSDN博客

感谢作者:liangzhao_jay

查看原文:GO程序设计1——快速入门

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。