共计 2725 个字符，预计需要花费 7 分钟才能阅读完成。
一.Go 语言的基础组成有以下几个部分：
1. 包声明 2. 引入包 3. 函数 4. 变量 5. 语句 & 表达式 6. 注释
// 当前程序的包名
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!”)
}
// 前面加个点表示省略调用，那么调用该模块里面的函数，可以不用写模块名称了:
import . “fmt”
func main (){
Println(“hello,world”)
}
通过 const 关键字来进行常量的定义。通过在函数体外部使用 var 关键字来进行全局变量的声明和赋值。通过 type 关键字来进行结构 (struct) 和接口 (interface) 的声明。通过 func 关键字来进行函数的声明。Go 语言中变量的声明必须使用空格隔开如：var age int;
2. 可见性规则：
Go 语言中，使用大小写来决定该常量、变量、类型、接口、结构或函数是否可以被外部包所调用。函数名首字母小写即为 private :func getId() {}
函数名首字母大写即为 public :func Printf() {}
3.Print、Println、Printf 三者的区别：
func main() {
fmt.Print(“a”, “b”, 1, 2, 3, “c”, “d”, “\n”)
fmt.Println(“a”, “b”, 1, 2, 3, “c”, “d”)
fmt.Printf(“ab %d %d %d cd\n”, 1, 2, 3)
// ab1 2 3cd
// a b 1 2 3 c d
// ab 1 2 3 cd
if err := percent(30, 70, 90, 160); err != nil {
fmt.Println(err)
}
// 30%
// 70%
// 90%
// 数值 160 超出范围（100）
}
3.1 Println 深度理解：
package main
import (
“fmt”
“strings”
)
func main() {
str := “ 这里是 www\n.runoob\n.com”
fmt.Println(“——– 原字符串 ———-“)
fmt.Println(str)
// 去除空格
str = strings.Replace(str, ” “, “”, -1)
// 去除换行符
str = strings.Replace(str, “\n”, “”, -1)
fmt.Println(“——– 去除空格与换行后 ———-“)
fmt.Println(str)
}
输出结果为：
——– 原字符串 ———-
这里是 www
.runoob
.com
——– 去除空格与换行后 ———-
这里是 www.runoob.com
4.Go 标记
Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。
5.Go 语言数据类型
1. 布尔型: 布尔型的值只可以是常量 true 或者 false。2. 数字类型: 整型 int8~64、uint8~64、和 uintptr。和浮点型 float32~64，complex64~128，Go 语言还支持其他数字类型 byte 类似 uint8 rune 类似 int32 uint32 或 64 位 int 与 uint 一样大小 uintptr 无符号整型，用于存放一个指针。3. 字符串类型: 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF- 8 编码标识 Unicode 文本。4. 派生类型:(a) 指针类型（Pointer）(b) 数组类型(c) 结构化类型(struct)(d) Channel 类型(e) 函数类型(f) 切片类型(g) 接口类型（interface）(h) Map 类型
6.Go 语言变量
变量声明第一种，指定变量类型，声明后若不赋值，使用默认值。
var v_name v_type
v_name = value
第二种，根据值自行判定变量类型。
var v_name = value
第三种，省略 var, 注意 := 左侧的变量不应该是已经声明过的，否则会导致编译错误。
v_name := value
// 例如
var a int = 10
var b = 10
c := 10
多变量声明
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
7.GO 语言常量
多个相同类型的声明可以简写为：
const c_name1, c_name2 = value1, value2
常量还可以用作枚举：
const (
Unknown = 0
Female = 1
Male = 2
)
iota，特殊常量，可以认为是一个可以被编译器修改的常量。在每一个 const 关键字出现时，被重置为 0，然后再下一个 const 出现之前，每出现一次 iota，其所代表的数字会自动增加 1。iota 可以被用作枚举值：
func main() {
const (
aa = iota
bb = iota
cc = iota
)
fmt.Println(“aa=,bb=,cc=”, aa, bb, cc)
//0 1 2
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
const (
j = 1 << iota
k = 3 << iota
l
m
)
fmt.Println(“j=”, j)
fmt.Println(“k=”, k)
fmt.Println(“l=”, l)
fmt.Println(“m=”, m)
/*iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），
即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。
简单表述:
i=1：左移 0 位, 不变仍为 1;
j=3：左移 1 位, 变为二进制 110, 即 6;
k=3：左移 2 位, 变为二进制 1100, 即 12;
l=3：左移 3 位, 变为二进制 11000, 即 24。*/
}
