环境安装
参考菜鸟教程：
语言结构及基础语法
实列
Go 语言的基础组成有以下几个部分：
- 包声明
- 引入包
- 函数
- 变量
- 语句 & 表达式
- 注释
package main
import "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。
使用 fmt.Print(“hello, world\n”) 可以得到相同的结果。
Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。 - 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
执行Go程序
- go run text.go
- go build text.go生成二进制二进制文件text，然后 ./text执行
行分隔符
在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。
标识符
规则跟主流语言相同：一个标识符实际上就是一个或是多个字母(AZ和az)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
Go关键字
Go 代码中会使用到的 25 个关键字
- var ：变量声明
- const：常量的声明
- type：用于声明自定义类型
- package 和 import: 导入
- func： 用于定义函数和方法
- return ：用于从函数返回
- defer ：在函数退出之前执行
- go : 用于并行
- select：用于选择不同类型的通讯
- interface：用于定义接口
- struct：用于定义抽象数据类型
- break、case、continue、for、fallthrough、else、if、switch、goto、default： 流程控制
- chan：用于channel通讯
- map：用于声明map类型数据
- range：用于读取slice、map、channel数据
数据类型
- 布尔型：布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
- 数字类型：整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
- 字符串类型：字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
- 派生类型：指针类型（Pointer）、数组类型、结构化类型(struct)、Channel 类型、函数类型、切片类型、接口类型（interface）、Map 类型
数字类型
- uint8：无符号 8 位整型 (0 到 255)
- uint16：无符号 16 位整型 (0 到 65535)
- uint32：无符号 32 位整型 (0 到 4294967295)
- uint64：无符号 64 位整型 (0 到 18446744073709551615)
- int8：有符号 8 位整型 (-128 到 127)
- int16：有符号 16 位整型 (-32768 到 32767)
- int32：有符号 32 位整型 (-2147483648 到 2147483647)
- int64：有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
浮点型
- float32：IEEE-754 32位浮点型数
- float64：IEEE-754 64位浮点型数
- complex64：32 位实数和虚数
- complex128：64 位实数和虚数
其他数字类型
- byte：类似 uint8
- rune：类似 int32
- uint：32 或 64 位
- int：与 uint 一样大小
- uintptr：无符号整型，用于存放一个指针
Go语言变量
Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
声明变量的一般形式是使用 var 关键字：
var identifier type
var identifier1, identifier2 type //可以一次声明多个变量
示例：
package main
import "fmt"
func main() {
var a string = "Runoob"
fmt.Println(a)
var b, c int = 1, 2
fmt.Println(b, c)
}
执行结果：
Runoob
1 2
变量声明
第一种，指定变量类型，如果没有初始化，则变量默认为零值
var v_name v_type
默认值规则：
- 数值类型（包括complex64/128）为 0
- 布尔类型为 false
- 字符串为 “”（空字符串）
- 以下几种类型为 nil：
var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口
第二种，根据值自行判定变量类型。
var v_name = value
package main
import "fmt"
func main() {
var d = true
fmt.Println(d)
}
输出结果：
true
第三种，使用 := 声明变量。如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误，格式：
v_name := value
例：
//方式1
var intVal int
intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明
//方式2
intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
多变量声明
//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断
vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误
// 这种因式分解关键字的写法一般用于声明全局变量
var (
vname1 v_type1
vname2 v_type2
)
//示例代码----------------------------------------------
package main
var x, y int
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
println(x, y, a, b, c, d, e, f, g, h)
}
输出结果：
0 0 0 false 1 2 123 hello 123 hello
空白标识符
空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
例：
package main
import "fmt"
func main() {
_,numb,strs := numbers() //只获取函数返回值的后两个
fmt.Println(numb,strs)
}
//一个可以返回多个值的函数
func numbers()(int,int,string){
a , b , c := 1 , 2 , "str"
return a,b,c
}
输出：
2 str
Go 语言常量
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
常量的定义格式：
const identifier [type] = value
const c_name1, c_name2 = value1, value2 //多个相同类型的声明可以简写
- 显式类型定义： const b string = “abc”
- 隐式类型定义： const b = “abc”
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "str" //多重赋值
area = LENGTH * WIDTH
fmt.Printf("面积为 : %d", area)
println()
println(a, b, c)
}
运行结果：
面积为 : 50
1 false str
常量还可以用作枚举：
const (
Unknown = 0
Female = 1
Male = 2
)
在定义常量组时，如果不提供初始值，则表示将使用上行的表达式：
package main
import "fmt"
const (
a = 1
b
c
d
)
func main() {
fmt.Println(a)
// b、c、d没有初始化，使用上一行(即a)的值
fmt.Println(b) // 输出1
fmt.Println(c) // 输出1
fmt.Println(d) // 输出1
}
iota
iota，特殊常量，可以认为是一个可以被编译器修改的常量。
iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
const (
a = iota
b = iota
c = iota
)
//第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式
const (
a = iota
b
c
)
iota 用法示例：
package main
import "fmt"
func main() {
const (
a = iota //0
b //1
c //2
d = "ha" //独立值，iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100使用上一行的值， 同时iota +=1
h = iota //7,恢复计数
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i)
}
输出结果：
0 1 2 ha ha 100 100 7 8
一个有趣的例子：
package main
import "fmt"
const (
i=1<<iota
j=3<<iota
k
l
)
func main() {
fmt.Println("i=",i)
fmt.Println("j=",j)
fmt.Println("k=",k)
fmt.Println("l=",l)
}
输出结果：
i= 1
j= 6
k= 12
l= 24
iota 只是在同一个 const 常量组内递增，每当有新的 const 关键字时，iota 计数会重新开始：
package main
const (
i = iota
j = iota
x = iota
)
const xx = iota
const yy = iota
func main(){
println(i, j, x, xx, yy)
}
// 输出是 0 1 2 0 0
643
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
