Go语言学习-基础语法

Go语言结构

Go 语言的基础组成有以下几个部分：

• 包声明

• 引入包

• 函数

• 变量

• 语句 & 表达式

• 注释

package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

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

只有 package 名称为 main 的包可以包含 main 函数。

一个可执行程序有且仅有一个 main 包。

通过 import 关键字来导入其他非 main 包。

可以通过 import 关键字单个导入:

import "fmt"
import "io"

也可以同时导入多个:

import {
    "fmt",
    "io"
}

使用 <PackageName>.<FunctionName>调用函数。

通过 const 关键字来进行常量的定义。

通过在函数体外部使用 var 关键字来进行全局变量的声明和赋值。

通过 type 关键字来进行结构(struct)和接口(interface)的声明。

通过 func 关键字来进行函数的声明。

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

Go 标记

Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。

行分隔符

在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。

标识符

标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。

以下是有效的标识符：

mahesh   kumar   abc   move_name   a_123
myname50   _temp   j   a23b9   retVal

以下是无效的标识符：

• 1ab（以数字开头）

• case（Go 语言的关键字）

• a+b（运算符是不允许的）

可见性规则

Go语言中，使用大小写来决定该常量、变量、类型、接口、结构或函数是否可以被外部包所调用。

函数名首字母小写即为 private :

func getId() {}

函数名首字母大写即为 public :

func Printf() {}

关键字

下面列举了 Go 代码中会使用到的 25 个关键字或保留字：

除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符：

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

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

程序中可能会使用到这些标点符号：

• .
• ,
• ;
• :
• …

Go 语言的空格

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

var age int;

语句中适当使用空格能让程序看易阅读。

无空格：

fruit=apples+oranges;

在变量与运算符间加入空格，程序看起来更加美观，如：

fruit = apples + oranges; 

数据类型

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

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

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

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

2. 数字类型
   整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且原生支持复数，其中位的运算采用补码。

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

4. 派生类型:
   包括：
   (a) 指针类型（Pointer）
   (b) 数组类型
   (c) 结构化类型(struct)
   (d) Channel 类型
   (e) 函数类型
   (f) 切片类型
   (g) 接口类型（interface）
   (h) Map 类型

常量

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

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

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

package main

import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main(){
    println(a, b, c)
}

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

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

使用iota能简化定义，在定义枚举时很有用。

• iota只能在常量的表达式中使用

fmt.Println(iota)  

编译错误： undefined: iota

• 每次 const 出现时，都会让 iota 初始化为0.

const a = iota // a=0 
const ( 
  b = iota     //b=0 
  c            //c=1 
)

• 自定义类型

自增长常量经常包含一个自定义枚举类型，允许你依靠编译器完成自增设置。

type Stereotype int

const ( 
    TypicalNoob Stereotype = iota // 0 
    TypicalHipster                // 1 
    TypicalUnixWizard             // 2 
    TypicalStartupFounder         // 3 
)

• 可跳过的值

设想你在处理消费者的音频输出。音频可能无论什么都没有任何输出，或者它可能是单声道，立体声，或是环绕立体声的。

这可能有些潜在的逻辑定义没有任何输出为 0，单声道为 1，立体声为 2，值是由通道的数量提供。

例如给 Dolby 5.1 环绕立体声定义输出值， 一方面，它有6个通道输出，但是另一方面，仅仅 5 个通道是全带宽通道（因为 5.1 称号 - 其中 .1 表示的是低频效果通道）。

不管怎样，我们不想简单的增加到 3。

我们可以使用下划线跳过不想要的值。

type AudioOutput int

const ( 
    OutMute AudioOutput = iota // 0 
    OutMono                    // 1 
    OutStereo                  // 2 
    _ 
    _ 
    OutSurround                // 5 
)

• 位掩码表达式

type Allergen int

const ( 
    IgEggs Allergen = 1 << iota // 1 << 0 which is 00000001 
    IgChocolate                         // 1 << 1 which is 00000010 
    IgNuts                              // 1 << 2 which is 00000100 
    IgStrawberries                      // 1 << 3 which is 00001000 
    IgShellfish                         // 1 << 4 which is 00010000 
)

这个工作是因为当你在一个 const 组中仅仅有一个标示符在一行的时候，它将使用增长的 iota 取得前面的表达式并且再运用它。在 Go 语言的 spec 中， 这就是所谓的隐性重复最后一个非空的表达式列表。

如果你对鸡蛋，巧克力和海鲜过敏，把这些 bits 翻转到 “on” 的位置（从左到右映射 bits）。然后你将得到一个 bit 值 00010011，它对应十进制的 19。

fmt.Println(IgEggs | IgChocolate | IgShellfish)

output:
19

• 定义数量级

type ByteSize float64

const (
    _           = iota                   // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota) // 1 << (10*1)
    MB                                   // 1 << (10*2)
    GB                                   // 1 << (10*3)
    TB                                   // 1 << (10*4)
    PB                                   // 1 << (10*5)
    EB                                   // 1 << (10*6)
    ZB                                   // 1 << (10*7)
    YB                                   // 1 << (10*8)
)

• 定义在一行的情况

const (
    Apple, Banana = iota + 1, iota + 2
    Cherimoya, Durian
    Elderberry, Fig
)

iota 在下一行增长，而不是立即取得它的引用。

Apple: 1
Banana: 2
Cherimoya: 2
Durian: 3
Elderberry: 3
Fig: 4

• 中间插队

const ( 
    i = iota 
    j = 3.14 
    k = iota 
    l 
)

那么打印出来的结果是i=0,j=3.14,k=2,l=3

运算符

运算符用于在程序运行时执行数学或逻辑运算。

Go 语言内置的运算符有：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符

• 其他运算符

  下表列出了Go语言的其他运算符。
  

条件语句

循环语句

GO 语言支持以下几种循环控制语句：

• break 语句 经常用于中断当前 for 循环或跳出 switch 语句。

• continue 语句 跳过当前循环的剩余语句，然后继续进行下一轮循环。

• goto 语句 将控制转移到被标记的语句。

无限循环

package main

import "fmt"

func main() {
    for true  {
        fmt.Printf("这是无限循环。\n");
    }
}

函数

Go 函数可以返回多个值，例如：

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

以上实例执行结果为：
Kumar Mahesh

函数用法

变量作用域

作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。

Go 语言中变量可以在三个地方声明：

• 函数内定义的变量称为局部变量

  在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。

• 函数外定义的变量称为全局变量

  在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。

  全局变量可以在任何函数中使用。

  Go 语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑。

• 函数定义中的变量称为形式参数

  形式参数会作为函数的局部变量来使用。

不同类型的局部和全局变量默认值为：