Go学习笔记-go语言基础

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 

程序的一般结构:

通过 package 定义包名

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

通过 import 关键字导入非 main 包

通过 const 关键字定义常量

通过 var 关键字声明变量

通过 type 关键字和 struct 或 interface 搭配定义结构或接口

通过 func 关键字定义函数和方法

单行注释：// 注释内容

多行注释：/* 注释内容 */

导入外部包的两种方法：

import "fmt" 

import "os" 

import (
"fmt" 
"os" 

)

通过格式 <PackageName>.<ObjectName> 来对包中的对象进行调用

如果导入包但未调用包中的任何对象，则会报出编译错误
imported and not used

当两个外部包的名称过于相近或相同时，可以使用导入别名来区分

import f "fmt"

还可以在调用某个外部包的内容时，省略包名直接调用

import . "fmt"

在 Go 语言中，使用 首字母大小 写来决定该对象是否可以被外部包所调用

1）如果首字母为 小写，则表示私有的

func privateFunc

2）如果首字母为 大写，则表示公开的

func PublicFunc

该规则适用于 所有的 Go 语言对象，无论是内置的还是用户自己创建的

###########

Go类型与变量

布尔型：bool

长度：1 位

取值范围：true – false

注意事项：不可以用数字表示

整型：int/uint
1) 根据平台不同可以为 32 或 64 位

8 位整型：int8/uint8

1) 长度：1 字节

2) 取值范围：-128 - 127/0 - 255

字节型：byte（uint8 的别名）

16 位整型：int16/uint16

长度：2 字节

取值范围：-32768 - 32767/0 – 65535

32 位整型：int32（rune）/uint32

1) 长度：4 字节

2) 取值范围：-232/2 - 232/2-1/0 - 233-1

64 位整型：int64/uint64

1) 长度：8 字节

2) 取值范围：-264/2 - 264/2-1/0 - 265-1

浮点型：float32/float64

长度：4/8 字节

小数位：精确到 7/15 小数位

复数型：complex64/complex128

长度：8/16 字节

 指针型：uintptr

足够保存指针的 32 或 64 位整型

 其它值类型：

数组（array）

结构（struct）

字符串（string）

引用类型（非传统引用）：

切片（slice）

类哈希表（map）

管道（chan）

接口型（interface）

函数型（func）

零值并不等价于空值(NULL)，是指在变量被声明为某种类型之后自动获得的默认值。

int ->
0
bool ->
false
float64
-> 0.0
string
-> ""（空字符串）
结构 ->
空结构
引用类型 ->
nil（空指针）

##类型别名

类型别名可以为某个类型赋予新的合法名称

类型别名并不是单纯的重命名或指向，而是用源类型作为底层类型，定义了一个全新的类型

新类型与源类型之间需要类型转换，属于相互兼容的类型

新类型可以拥有属于自己的一套方法

新类型不会继承源类型的方法，而需要进行类型转换后才可调用

##变量的声明与赋值

单个变量的声明与赋值：

声明格式：var <变量名称> <变量类型>

赋值格式：<变量名称> = <表达式>

声明并赋值（类型推断）：

var <变量名称> [变量类型] = <表达式>

<变量名称> := <表达式>

使用下划线（_）抛弃赋值：_ = <表达式>

多个变量的声明与赋值

可以使用 var() 的形式进行简写

可以使用并行赋值（变量的类型是相同的）：

var <变量1>, <变量2> [变量类型] = <表达式1>, <表达式2>

<变量1>, <变量2> := <表达式1>, <表达式2>

##对变量进行类型转换

Go 语言不存在隐式转换，所有类型转换必须显式声明

类型转换只能发生在两种相互兼容的类型之间（例如：整型和整型之间）

类型转换的格式：

<变量2> [:]= <类型2>(<变量1>)

##常量与运算符

常量的值在编译时就已经确定

常量的定义格式与变量基本相同

使用 const 关键字来定义常量

使用 const() 关键字来定义常量组

常量等号右侧必须是常量或者常量表达式

常量表达式所涉及的函数必须是内置函数

##常量组的自动赋值特性

在定义常量组时，如果不提供初始值，则默认使用上一行的表达式

使用相同的常量表达式不代表具有相同的值

const(
a = "A"
b

)

##iota 计数器的使用

iota 是常量组的计数器

iota 从 0 开始，每行递增 1

每个新的常量组都会将 iota 的值重置为 0

通过常量的初始化规则和 iota 计数可达到枚举的效果

const(
a = iota
b

)

##运算符的操作方法

Go 语言中的运算符均是从左至右结合

运算符具有优先级（从高到底）：

! （一元运算符）

*  / %
<< >>
& &^

+  - |
^

==   != <
<= >= >

<- （专门用于 channel）

&& （二元运算符）

||

1.  取反：!
1）!false

四则运算：+ - * /
1）1 + 2 * 3 / 4

取余：%
1）8 % 5

左移/右移：<< / >>
1）1 << 10
2）1000 >> 2

按位与：&
1） 3 & 2

按位与非：&^
1）6 &^ 11

按位或：|
1）5 | 3

按位异或（XOR）：^
1）5 ^ 2

逻辑运算符：
1）==   !=
< <= >=
>
2）&&  ||

<- 专门用于 channel

管道传入/取出：<-
1）<-chan
2）chan<- true

###

Go语言控制语句

###

##Go语言控制语句 if

Go 语言中的判断语句 if 包含以下特性：

条件表达式两侧不需要括号

左大括号必须和条件语句或 else 语句在同一行

支持一个初始化表达式（可以是并行赋值）

初始化语句中的变量为 block 级别（包括 else 代码块）

##循环语句 for

Go 语言中的循环语句只有一个 for 关键字，其包含以下特性：

左大括号必须和条件语句在同一行

支持无限循环、条件循环和步进表达式

初始化和步进表达式可以是多个值

条件语句每次循环都会被检查，因此建议尽量使用常量和变量代替函数

##选择语句 switch

Go 语言中的选择语句使用关键字 switch，其包含以下特性：

左大括号必须和条件语句在同一行

支持一个初始化表达式（可以是并行赋值）

可以使用任何类型或表达式作为条件语句

不需要显示调用 break，一旦条件符合就会结束判断

如果希望继续执行下一个 case，则需要显示调用 fallthrough 语句

##跳转语句

Go 语言中的跳转语句包括关键字 goto、break 和 continue，主要包含以下特性：

三种语法都可以配合标签使用

标签名区分大小写，不适用标签则会导致编译错误

break 和 continue 关键字与标签的组合可用于跳出多层循环

goto 关键字的作用是调整执行位置，与其它两个关键字的原理并不相同