Go 语言基础语法-Go

Go 标记

Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。如以下 GO 语句由 6 个标记组成：

fmt.Println("Hello, World!")

6 个标记是(每行一个)：

1. fmt
2. .
3. Println
4. (
5. "Hello, World!"
6. )

行分隔符

在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。

如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。

以下为两个语句：

fmt.Println("Hello, World!")
fmt.Println("菜鸟教程：runoob.com")

注释

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

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

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

标识符

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

以下是有效的标识符：

mahesh   kumar   abc   move_name   a_123
myname50   _temp   j   a23b9   retVal

以下是无效的标识符：

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

字符串连接

Go 语言的字符串可以通过 + 实现：

package main
import "fmt"
func main() {
    fmt.Println("Google" + "Runoob")
}

以上实例输出结果为：

GoogleRunoob

关键字

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

break
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

defaul
// 当 select 中的其他条件分支都没有准备好的时候，`default` 分支会被执行。

func
// 相当于函数，函数是结构化编程中最小的模块单元

 interface
// interface 是一种类型，从它的定义可以看出来用了 type 关键字

select
// 一个select语句用来选择哪个case中的发送或接收操作可以被立即执行。它类似于switch语句，但是它的case涉及到channel有关的I/O操作。

case
// 类似于JS的swtich的case,case后面可以带多个表达式，使用逗号间隔；
// case后面的表达式如果是常量值，则要求不能重复；
// case后面不需要带break，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default;

defer
// defer代码块会在函数调用链表中增加一个函数调用。这个函数调用不是普通的函数调用，而是会在函数正常返回，也就是return之后添加一个函数调用。因此，defer通常用来释放函数内部变量。

go
运行的意思，类似于npm 的作用（个人单纯理解）

map
// Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

struct
// go语言中没有像类的概念，但是可以通过结构体struct实现oop(面向对象编程）。struct的成员(也叫属性或字段)可以是任何类型，如普通类型、复合类型、函数、map、interface、struct等，所以我们可以理解为go语言中的“类”。

channels
// 一个 channels 是一个通信机制，它可以让一个 goroutine 通过它给另一个 goroutine 发送值信息。每个 channel 都有一个特殊的类型，也就是 channels 可发送数据的类型。一个可以发送 int 类型数据的 channel 一般写为 chan int。

if/else
// go的if/else流程控制语句,类似于JS的if else 

goto
// goto关键字，用来改变函数内代码的执行顺序，跳转到函数内指定的标签地方运行，goto不能跨函数代码块跳转。

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

switch
// 类似JS的swtich

const
// const用来定义常量，所谓常量，就是在定义之后，其值不允许被修改

fallthrough
// Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch
// 使用fallthrough强制执行后面的case代码。

range
// range 是 golang中特别常用的一种遍历方式

type
// 定义结构体
// 定义接口
// 类型定义
// 类型别名
// 类型查询

continue
// Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。
// for 循环中，执行 continue 语句会触发 for 增量语句的执行。
// 在多重循环中，可以用标号 label 标出想 continue 的循环。

for
// 与多数语言不同的是，Go语言中的循环语句只支持 for 关键字，而不支持 while 和 do-while 结构，关键字 for 的基本使用方法与C语言和 C++ 中非常接近：

import
// Go 中的程序由各种包组成。通常，包依赖于其它包，这些包内置于标准库或者第三方。包首先需要被导入才能使用包中的导出标识符。这是通过结构体调用 import 声明 来实现的：

return
// 退出执行，不指定返回值
// (1) 函数没有返回值
// (2) 函数返回值有变量名

var
// var关键字用来定义变量，不论定义什么类型的变量，都可以使用var来定义。
// 定义变量时，如果定义的变量没有初始化，则必须指定变量类型；如果变量定义时初始化，则可以不指定类型，由编译器自行推断变量类型。

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

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

append: // append函数是用来在slice末尾追加一个或者多个元素。
bool: // 布尔类型
byte: // Go语言中byte和rune实质上就是uint8和int32类型。byte用来强调数据是raw data，而不是数字；而rune用来表示Unicode的code point
cap
// 切片拥有长度和容量。
// 切片的长度是它所包含的元素个数。
// 切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。
// 切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。
close: // 内建函数， 用来关闭channel，这个channel要么是双向的， 要么是只写的（chan<- Type）。这个方法应该只由发送者调用， 而不是接收者。
complex64、complex128:
// Go语言中复数的类型有两种，分别是  complex128（64 位实数和虚数）和 complex64（32 位实数和虚数），其中 complex128 为复数的默认类型。
uint8、 uint16、uint32、uint64:
// 无符号 8 位整型 (0 到 255)
// 无符号 16 位整型 (0 到 65535)
// 无符号 32 位整型 (0 到 4294967295)
// 无符号 64 位整型 (0 到 18446744073709551615)
int8、int16、int32、int64
// 有符号 8 位整型 (-128 到 127)
// 有符号 16 位整型 (-32768 到 32767)
// 有符号 32 位整型 (-2147483648 到 2147483647)
// 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

大致这么多，其他的可以百度，太累了，懒得百度了

程序中可能会使用到这些分隔符：括号 ()，中括号 [] 和大括号 {}。程序一般由关键字、常量、变量、运算符、类型和函数组成。

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

Go 语言的空格

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

var age int;

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

无空格：

fruit=apples+oranges;

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

fruit = apples + oranges;

Go 程序的一般结构: basic_structure.go

// 当前程序的包名
package main

// 导入其他包
import . "fmt"

// 常量定义
const PI = 3.14

// 全局变量的声明和赋值
var name = "gopher"

// 一般类型声明
type newType int

// 结构的声明
type gopher struct{}

// 接口的声明
type golang interface{}

// 由main函数作为程序入口点启动
func main() {
    Println("Hello World!")
}

Go 程序是通过 package 来组织的。

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

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

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

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

import "fmt"
import "io"

也可以同时导入多个:

import (
    "fmt"
    "math"
)

例如：

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Println(math.Exp2(10))
}

使用 <PackageName>.<FunctionName> 调用:

package 别名：
// 为fmt起别名为fmt2
import fmt2 "fmt"

省略调用(不建议使用):

// 调用的时候只需要Println()，而不需要fmt.Println()
import . "fmt"

前面加个点表示省略调用，那么调用该模块里面的函数，可以不用写模块名称了:

import . "fmt"
func main (){
    Println("hello,world")
}

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

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

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

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

可见性规则

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

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

func getId() {}

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

func Printf() {}