第一个go程序

[code]package mainimport \"fmt\"func main() {/* 这是我的第一个简单的程序 */fmt.Println(\"Hello, World!\")}

• 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
• 下一行 import \”fmt\” 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
• 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
• 下一行 /*…*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，多行注释一般用于包的文档描述或注释成块的代码片段。
• 下一行 fmt.Println(…) 可以将字符串输出到控制台，并在最后自动增加换行字符 \\n。
• 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。

数据类型

Go语言的基本类型有：

• bool
• string
• int、int8、int16、int32、int64
• uint、uint8、uint16、uint32、uint64、uintptr
• byte // uint8 的别名
• rune // int32 的别名 代表一个 Unicode 码
• float32、float64
• complex64、complex128

变量

Go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。

1）声明变量的一般形式是使用 var 关键字：var name type

Go和许多编程语言不同，它在声明变量时将变量的类型放名称后。这样做的好处就是可以避免像C语言中那样含糊不清的声明形式，例如：

int* a, b;

 。其中只有 a 是指针而 b 不是。如果你想要这两个变量都是指针，则需要将它们分开书写。而在 Go 中，则可以和轻松地将它们都声明为指针类型：var a, b *int

多变量声明

[code]var (a intb stringc []float32d func() boole struct {x int})

2）除 var 关键字外，还可使用更加简短的变量定义和初始化语法。

名字 := 表达式

需要注意的是，简短模式（short variable declaration）有以下限制：

• 定义变量，同时显式初始化。
• 不能提供数据类型。
• 只能用在函数内部。

和 var 形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量：

i, j := 0, 1

3）根据值自行判定变量类型。

[code]package mainimport \"fmt\"func main() {var d = truefmt.Println(d)}

算术运算符

[code]package mainimport \"fmt\"func main() {var a int = 21var b int = 10var c intc = a + bfmt.Printf(\"第一行 - c 的值为 %d\\n\", c )c = a - bfmt.Printf(\"第二行 - c 的值为 %d\\n\", c )c = a * bfmt.Printf(\"第三行 - c 的值为 %d\\n\", c )c = a / bfmt.Printf(\"第四行 - c 的值为 %d\\n\", c )c = a % bfmt.Printf(\"第五行 - c 的值为 %d\\n\", c )a++fmt.Printf(\"第六行 - a 的值为 %d\\n\", a )a=21   // 为了方便测试，a 这里重新赋值为 21a--fmt.Printf(\"第七行 - a 的值为 %d\\n\", a )}

[code]第一行 - c 的值为 31第二行 - c 的值为 11第三行 - c 的值为 210第四行 - c 的值为 2第五行 - c 的值为 1第六行 - a 的值为 22第七行 - a 的值为 20

位运算符

位运算符对整数在内存中的二进制位进行操作。

下表列出了位运算符 &, |, 和 ^ 的计算：

假定 A = 60; B = 13; 其二进制数转换为：

A = 0011 1100B = 0000 1101-----------------A&B = 0000 1100A|B = 0011 1101A^B = 0011 0001

 赋值运算符

下表列出了所有Go语言的赋值运算符。

其他运算符

以下实例演示了其他运算符的用法：

实例

[code]package mainimport \"fmt\"func main() {var a int = 4var b int32var c float32var ptr *int/* 运算符实例 */fmt.Printf(\"第 1 行 - a 变量类型为 = %T\\n\", a );fmt.Printf(\"第 2 行 - b 变量类型为 = %T\\n\", b );fmt.Printf(\"第 3 行 - c 变量类型为 = %T\\n\", c );/*  & 和 * 运算符实例 */ptr = &a     /* \'ptr\' 包含了 \'a\' 变量的地址 */fmt.Printf(\"a 的值为  %d\\n\", a);fmt.Printf(\"*ptr 为 %d\\n\", *ptr);}

以上实例运行结果：

第 1 行 - a 变量类型为 = int第 2 行 - b 变量类型为 = int32第 3 行 - c 变量类型为 = float32a 的值为  4*ptr 为 4

运算符优先级

由上至下代表优先级由高到低：

循环

普通for循环

[code]package mainimport \"fmt\"func main() {sum := 0for i := 0; i <= 10; i++ {sum += i}fmt.Println(sum)}

 foreach

这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。

[code]package mainimport \"fmt\"func main() {strings := []string{\"google\", \"runoob\"}for i, s := range strings {fmt.Println(i, s)}numbers := [6]int{1, 2, 3, 5}for i,x:= range numbers {fmt.Printf(\"第 %d 位 x 的值 = %d\\n\", i,x)}}

函数

[code]func function_name( [parameter list] ) [return_types] {函数体}

• func：函数由 func 开始声明
• function_name：函数名称，函数名和参数列表一起构成了函数签名。
• parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
• return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
• 函数体：函数定义的代码集合。

[code]/* 函数返回两个数的最大值 */func max(num1, num2 int) int {/* 声明局部变量 */var result intif (num1 > num2) {result = num1} else {result = num2}return result}

返回多个值

[code]package mainimport \"fmt\"func swap(x, y string) (string, string) {return y, x}func main() {a, b := swap(\"Google\", \"Runoob\")fmt.Println(a, b)}

引用传参

[code]package mainimport \"fmt\"func main() {/* 定义局部变量 */var a int = 100var b int= 200fmt.Printf(\"交换前，a 的值 : %d\\n\", a )fmt.Printf(\"交换前，b 的值 : %d\\n\", b )/* 调用 swap() 函数* &a 指向 a 指针，a 变量的地址* &b 指向 b 指针，b 变量的地址*/swap(&a, &b)fmt.Printf(\"交换后，a 的值 : %d\\n\", a )fmt.Printf(\"交换后，b 的值 : %d\\n\", b )}func swap(x *int, y *int) {var temp inttemp = *x    /* 保存 x 地址上的值 */*x = *y      /* 将 y 值赋给 x */*y = temp    /* 将 temp 值赋给 y */}

数组

声明：

语法格式如下：

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, 50.0}

初始化数组中 {} 中的元素个数不能大于 [] 中的数字。

如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

该实例与上面的实例是一样的，虽然没有设置数组的大小。

balance[4] = 50.0

初始化二维数组：

[code]a = [3][4]int{{0, 1, 2, 3} ,   /*  第一行索引为 0 */{4, 5, 6, 7} ,   /*  第二行索引为 1 */{8, 9, 10, 11},   /* 第三行索引为 2 */}

注意：以上代码中倒数第二行的 } 必须要有逗号，因为最后一行的 } 不能单独一行，也可以写成这样：

[code]a = [3][4]int{{0, 1, 2, 3} ,   /*  第一行索引为 0 */{4, 5, 6, 7} ,   /*  第二行索引为 1 */{8, 9, 10, 11}}   /* 第三行索引为 2 */

指针

和c一样

[code]package mainimport \"fmt\"func main() {var a int= 20   /* 声明实际变量 */var ip *int        /* 声明指针变量 */ip = &a  /* 指针变量的存储地址 */fmt.Printf(\"a 变量的地址是: %x\\n\", &a  )/* 指针变量的存储地址 */fmt.Printf(\"ip 变量储存的指针地址: %x\\n\", ip )/* 使用指针访问值 */fmt.Printf(\"*ip 变量的值: %d\\n\", *ip )}

[code]a 变量的地址是: 20818a220ip 变量储存的指针地址: 20818a220*ip 变量的值: 20

空指针判断：

if(ptr != nil)     /* ptr 不是空指针 */if(ptr == nil)    /* ptr 是空指针 */

多重指针： 

[code]package mainimport \"fmt\"func main() {var a intvar ptr *intvar pptr **inta = 3000/* 指针 ptr 地址 */ptr = &a/* 指向指针 ptr 地址 */pptr = &ptr/* 获取 pptr 的值 */fmt.Printf(\"变量 a = %d\\n\", a )fmt.Printf(\"指针变量 *ptr = %d\\n\", *ptr )fmt.Printf(\"指向指针的指针变量 **pptr = %d\\n\", **pptr)}

[code]变量 a = 3000指针变量 *ptr = 3000指向指针的指针变量 **pptr = 3000