go语言学习之路（一）

Go 语言简介

Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。

Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。

1、Go 语言特色

• 简洁、快速、安全
• 并行、有趣、开源
• 内存管理、v数组安全、编译迅速

2、Go 安装

安装包下载地址为：https://golang.org/dl/。本文以1.4.2为例

3、Windows 系统下安装

Windows 下可以使用 .msi 后缀(在下载列表中可以找到该文件，如go1.4.2.windows-amd64.msi)的安装包来安装。

默认情况下.msi文件会安装在 c:Go 目录下。你可以将 c:Goin 目录添加到 PATH 环境变量中。添加后你需要重启命令窗口才能生效。

4、安装测试

创建工作目录 C:>Go_WorkSpace。

文件名: test.go，代码如下：

package main
 
import "fmt"
 
func main() {
   fmt.Println("Hello, World!")
}

使用 go 命令执行以上代码输出结果如下：

C:Go_WorkSpace>go run test.go
 
Hello, World!

让我们来看下以上程序的各个部分：

1. 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

2. 下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。

3. 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

4. 下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。

5. 下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 。 
   使用 fmt.Print("hello, world ") 可以得到相同的结果。 
   Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。

6. 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 private ）。

5、执行 Go 程序

让我们来看下如何编写 Go 代码并执行它。步骤如下：

1. 打开编辑器如Sublime2，将以上代码添加到编辑器中。

2. 将以上代码保存为 hello.go

3. 打开命令行，并进入程序文件保存的目录中。

4. 输入命令 go run hello.go 并按回车执行代码。

5. 如果操作正确你将在屏幕上看到 "Hello World!" 字样的输出。

注释

注释不会被编译，每一个包应该有相关注释。

单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾。如：

// 单行注释
/*
 Author by shouce.ren菜鸟教程
 我是多行注释
 */

6、标识符

以下是无效的标识符：

• 1ab（以数字开头）
• case（Go 语言的关键字）
• a+b（运算符是不允许的）

7、关键字

下面列举了 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

程序一般由关键字、常量、变量、运算符、类型和函数组成。

程序中可能会使用到这些分隔符：括号 ()，中括号 [] 和大括号 {}。

程序中可能会使用到这些标点符号：.、,、;、: 和 …。

8、Go 语言的空格

Go 语言中变量的声明必须使用空格隔开，如：

var age int;

在 Go 编程语言中，数据类型用于声明函数和变量。

数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。

Go 语言按类别有以下几种数据类型：

布尔型  --> 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。

整数型  --> 整型 int 和浮点型 float，Go 语言支持整型和浮点型数字，并且原生支持复数，其中位的运算采用补码。

字符串  --> 字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本。

派生型  --> (a) 指针类型（Pointer）、(b) 数组类型、(c) 结构化类型(struct)、(d) 联合体类型 (union)、(e) 函数类型、(f) 切片类型、(g) 接口类型（interface）、(h) Map 类型、 (i) Channel 类型

变量

1、变量声明

第一种，指定变量类型，声明后若不赋值，使用默认值。

1. var v_name v_type
2. v_name = value　     

var v_name v_type
v_name = value

第二种，根据值自行判定变量类型。

var v_name = value

第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误。

v_name := value
 
// 例如
var a int = 10
var b = 10
c : = 10

实例如下：

package main
var a = "张岩林很帅"
var b string = "https://www.cnblogs.com/aylin/"
var c bool
 
func main(){
    println(a, b, c)
}

以上实例执行结果为：

张岩林很帅 https://www.cnblogs.com/aylin/ false

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
)

如下：

package main
 
var x, y int
var (  //这种只能出现在全局变量中，函数体内不支持
    a int
    b bool
)
 
var c, d int = 1, 2
var e, f = 123, "hello"
 
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
 
func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

以上实例执行结果为：

0 0 0 false 1 2 123 hello 123 hello

如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：

func main() {
   var a string = "abc"
   fmt.Println("hello, world")
}

尝试编译这段代码将得到错误 a declared and not used。

此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用

fmt.Println("hello, world", a)

但是全局变量是允许声明但不使用。

Go 语言常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

const identifier [type] = value

多个相同类型的声明可以简写为：

const c_name1, c_name2 = value1, value2

以下实例演示了常量的应用：

package main
 
import "fmt"
 
func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int
   const a, b, c = 1, false, "str" //多重赋值
 
   area = LENGTH * WIDTH
   fmt.Printf("面积为 : %d", area)
   println()
   println(a, b, c)   
}

以上实例运行结果为：

面积为 : 50
1 false str

常量还可以用作枚举：

const (
    Unknown = 0
    Female = 1
    Male = 2
)

数字 0、1 和 2 分别代表未知性别、女性和男性。

常量可以用len(), cap(), unsafe.Sizeof()常量计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

package main
 
import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)
 
func main(){
    println(a, b, c)
}

以上实例运行结果为：

abc 3 16

1、ota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。

iota 可以被用作枚举值：

const (
    a = iota
    b = iota
    c = iota
)

2、iota 用法

package main
 
import "fmt"
 
func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

以上实例运行结果为：

0 1 2 ha ha 100 100 7 8