GO语言基础语法

GO语言基础语法

• 关键字，标识符，注释，基础结构
• package，import别名，路径，”.”，”_”的使用
• GO变量，函数可见性规则

Go语言的语言符号又称记法元素，共包括5类，标签符（identifier）、关键字（keyword）、操作符（operator）、分隔符（delimiter）、字面量（literal），它们是组成Go语言代码和程序的最基本单位。

Go语言的所有源代码都必须由 Unicode 编码规范的 UTF-8 编码格式进行编码。

一、关键字，标识符

GO中保留关键字

break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	swith
const	fallthrough	if	range	type
continue	for	import	return	var

1. 程序声明：import、package
2. 程序实体声明和定义：chan、const、func、interface、map、struct、type、var
3. 程序流程控制：go、select、break、case、continue、default、defer、else、fallthrough、for、goto、if、range、return、switch

标识符

在Go语言代码中，每一个标识符可以代表一个变更或者一个类型（即标识符可以被看作是变量或者类型的代号或者名称），标识符是由若干字母、下划线（_）和数字组成的字符序列，第一个字符必须为字母。同时，使用一个标识符在使用前都必须先声明。在一个代码块中，不允许重复声明同一个标识。

代码包声明（package PKG_NAME）并不算是一个声明，因为代码包名称并不出现在任何一个作用域中，
代码包声明语句的目的只是为了鉴别若干源码文件是否属于同一个代码包，或者指定导入代码包时的默认代码包引用名称。

一个限定标识符代表了对另一个代码包中的某个标识符的访问，这需要两个条件：
    1.另一个代码包必须事情由Go语言的导入声明 import 导入；
    2.某个标识符在代码包中是可导出的。

标识符可导出的前提条件有下面这两个：
    1.标识符名称中的第一个字符必须是大写；
    2.标识必须是被声明在一个代码包中的变量或者类型的名称，或者是属于某个结构体类型的字段名称或者方法名称。

• GO中36个预定的标识符，包括基础数据关系类型和系统内嵌函数

append	bool	byte	cap	close	copy
recover	false	TRUE	panic	print	println
iota	len	make	new	nil	real
int	int8	int16	int32	int64	string
uint	uint8	uint16	uint32	uint64	uintprt
complex	complex64	complex128	float32	float64	imag

分类如下：
1. 所有基本数据类型的名称
2. 接口类型 error
3. 常量 true、false 以及 iota
4. 所有内置函数的名称，即 append、cap、close、complex、copy、delete、imag、len、make、new、panic、print、println、real和 recover

类型

==18个基本数据类型：==
string 、bool、byte、int/uint、int8/uint8、int16/uint16、int32/uint32、int64/uint64、float32、float64、complex、complex64、complex128，基本类型的名称都必须预定义标识符。除了 bool 与 string 外，其它的都称为数值类型。

大类	序号	类型	描述
整型	1	uint8	无符号8位整形（0到256） // 2的8次方（1字节，8位一个字节）
	2	uint16	无符号16位整形（0到65535） // 2的16次方
	3	uint32	无符号32位整形（0到4294967295） // 2的32次方
	4	uint64	无符号64位整形（0到18446744073709651615） // 2的64次方
	5	int8	有符号8位整形（-128到127）
	6	int16	有符号16位整形（-32758到32767）
	7	int32	有符号32位整形（-2147483648到2147483647）
	8	int64	有符号64位整形（-9223372036854775808到9223372036854775807）
浮点	1	float32	1EEE-754 32位浮点型数 （4字节）
	2	float32	1EEE-754 64位浮点型数 （8字节）
复数	1	complex64	32位实数和虚数
	2	complex128	64位实数和虚数
其他	1	byte	类似uint8
	2	rune	类似int32
	3	uint	32位或64位（根据操作系统来，32位操作系统占4字节，64位操作系统占8字节）
	4	int	与uint一样大小（根据操作系统来，32位操作系统占4字节，64位操作系统占8字节）
	5	uintptr	无符号整型，用于存放一个指针
	6	string	==字符串类型string，编码统一为“UTF-8”==
	7	bool	布尔类型，值为常量true或false

- string类型默认为空值（空字符串）
- bool类型默认为false
- 数值类型默认为0

==8个复合类型：==
Array（数组）、Struct（结构体）、Function（函数）、Interface（接口）、Slice（切片）、Map（字典）、Channel（通道）以及Pointer（指针）。

复合类型一般由若干（包括0）个其他已被定义的类型组合而成，如定义一本书的结构体：

type Book struct {
     Name string
     ISBN string
     Press string
     TotalPages uint16
}

Go语言中的类型又可以分为静态类型和动态类型，一个变量的静态类型是指在变量声明中示出的那个类型，绝大多数类型的变量都只拥有静态类型，唯独接口类型的变量例外，它除了拥有静态类型之外，还拥有动态类型，这个动态类型代表了在运行时与该变量绑定在一起的值的实际类型。

每一个类型都会有一个潜在类型，如果这个类型是一个预定义的类型（也就是基本类型），或者是一个由类型字面量构造的复合类型，那么它的潜在类型就是它自身，比如 string 类型的潜在类型就是 string，在上面提到的 Book 的潜在类型就是 Book，但是如果一个类型并不属于上述情况，那么这个类型的潜在类型就是在类型声明中的那个类型的潜在类型，比如我们按以下方式声明一个 MyString 类型：

type MyString string

MyString 类型的潜在类型就是 string 类型的潜在类型，实际上，我们可以将 MyString 看作是 string 类型的一个别名，在Go 语言中的基本数据类型 rune 类型就是如此，它可以看作是 uint32 类型的一个别名类型，其潜在类型就是 uint32 ，但是一类要注意， MyString 与 string 却并不是一个相同的类型。
潜在类型在声明过程中是具有可传递性的，如下面我们再声明一个 iString 类型：

type iString MyString

iString 类型的潜在类型同样就是 string 类型。

注释

1. // 单行注释
2. /*...
    ... 多行注释
    */
3. 一般来说，单行注释较多

基础结构

基础结构

// 包名称package只能出现在文件开头
package main

// 导入包
import "fmt"

// 常量定义
const NAME = "kingWang"

// 变量定义
var a = "king"

// main 函数
func main() {
    var b string = "king b"
    fmt.Println(b)
}

复杂结构

// 程序所属包
package main

// 导入依赖包
import "fmt"

// 常量定义
const NAME string = "我是常量"

// 全局变量的声明与赋值
var a string = "全局变量声明域赋值"

// 一般类型声明
type kingInt int

// 结构声明
type Learn struct {
}

// 结构声明
type ILearn interface {
}

// 函数定义
func learnKing () {
    fmt.Println("我是普通函数")
}

// main函数
func main() {
    fmt.Println("我是主函数");
}

package

• package是最基本的分发单位和工程管理中依赖关系的体现
• 每个GO语言源代码文件开头都拥有一个package声明，表示源码文件所属代码包
• 要生成GO语言可执行程序，必须要有main的package包，且必须在改包下面有mian()函数
• 同一个路径下只能存在一个package，一个package可以拆分成多个源文件

import

• 作用：import语句可以导入源码文件所依赖的package包
• 原则：不得导入源码文件没有用的package包，否则会报错
• 写法形式两种

// 写法1
import "fmt"
import "time"

// 写法2
import (
    "fmt"
    "time"
)

原理

• 如果一个main导入其他包，包将被顺序导入
• 如果导入的包中依赖其他包，会首先导入其他包，然后初始化其他包中的常量和变量，最后如果其他包中有init，会自动执行init()方法
• 所有包导入完成后，才会对main中常量和变量进行初始化，然后执行main中的init函数（如果存在），最后执行main函数
• 如果一个包被导入多次，则该包只会执行一次

特殊用法

• 别名操作的含义：将导入的包命名为另一个容易记忆的别名
• 点（.）操作的含义是：点（.）标识的包导入后，调用该包中函数时，可以省略前缀包名
• 下划线（_）操作的含义是：导入该包，但不导入整个包，而是执行该包中的init函数，因此无法通过包名来调用包中的其他函数。使用下划线下划线（_）操作往往是为了注册包里的引擎，让外部可以方便地调用

语言变量

变量声明和初始化

• 单个变量声明和赋值
  
  1. 变量声明格式： var <变量名> [变量类型]
  2. 变量赋值格式： <变量名> = <值， 表达式， 函数等>
  3. 声明和赋值： var <变量名> [变量类型] = <值， 表达式， 函数等>
  4. 分组声明格式：

    var (
        i int
        j float32
        name string
    )

• 同一行声明多个变量和赋值：var a,b,c int = 1,2,3 或者 a,b := 1,2
• 全局变量的声明必须使用var关键字，局部变量则可以省略
• 特殊变量下划线”_”（表示值放入回收站，后续程序运行中不在需要这个变量）

类型转化

• GO中不存在隐式转化，类型转化必须是显式的
• 类型转化只能发生在两种兼容类型之间
• 类型转化格式：<变量名> [:] = <目标类型>(<需要转化的变量>) // 冒号可有可无

变量可见性规则

• 大写字母开头的变量在其他包可见，是公共变量
• 小写字母开头的就是不可见的，是私有变量

常量定义形式

• 从定义上可以分为显示和隐式：
  
  • 显示：const identifier [type] = value
  • 隐式：const identifier = value （通常叫无类型常量）
• 可以使用内置表达式定义，如：len()，unsafe.Sizeof()等
• 常量的范围目前只支持布尔型、数字型（整型、浮点型和复数）和字符串型