环境安装
参考菜鸟教程:
语言结构及基础语法
实列
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