Golang特性
- 高性能、高并发
- 语法简单、学习曲线平缓
- 丰富的标准库
- 完善的工具链
- 静态链接
- 快速编译
- 跨平台
- 垃圾回收
基础语法
变量
- 声明变量的一般形式是使用
var关键字，可以一次声明多个变量，也可以根据值自行判定变量类型
var name type
var name1, name2 type
var number = 1 // int
:=也可以声明变量，自动识别变量类型，
number := 1 // int
注意
var intVal int
intVal := 1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明
// 可以直接拼接字符串
var str = "hello"
str2 := str + "world" // helloworld
if-else
if a := 20 ; a < 20 {
// 如果条件为 true 则执行以下语句
fmt.Printf("a 小于 20\n" );
} else {
// 如果条件为 false 则执行以下语句
fmt.Printf("a 不小于 20\n" );
}
循环
Go 语言的 for 循环有 3 种形式，只有其中的一种使用分号
- 死循环
sum := 0
for {
sum++ // 无限循环下去
}
fmt.Println(sum) // 无法输出
- 常规写法
for i := 0; i <= 10; i++ {
fmt.Println(i)
}
- 类似其他语言
while语句形式(go 没有while)
sum := 1
for sum <= 10{
sum += sum
}
fmt.Println(sum)
switch
switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break。
var marks int = 90
switch marks {
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}
- 支持多条件匹配
switch{
case 1,2,3,4:
default:
}
- 不同的 case 之间不使用 break 分隔，默认只会执行一个 case。
- 如果想要执行多个 case，需要使用 fallthrough 关键字，也可用 break 终止。
switch{
case 1:
...
if(...){
break
}
fallthrough // 此时switch(1)会执行case1和case2，但是如果满足if条件，则只执行case1
case 2:
...
case 3:
}
数组
声明一维数组
// 数组 balance 长度为 10 类型为 float32
var balance [10] float32
初始化数组
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
// 数组长度不确定，可以使用 ... 代替数组的长度，编译器会根据元素个数自行推断数组的长度
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
访问数组元素
var salary float32 = balance[9]
二维数组
var a [3][3] int
a[2][3] = 1
切片
使用make()函数来创建切片:
var s []int = make([]int, 3)
s := make([]int, 3)
s[0] = 1
切片初始化
s :=[] int {1,2,3 }
- len() 和 cap() 函数
切片是可索引的，并且可以由 len() 方法获取长度。 切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。
- append() 和 copy() 函数
var s []int
// 允许追加空切片
s = append(s, 0)
// 向切片添加一个元素
s = append(s, 1)
// 同时添加多个元素
s = append(s, 2,3,4)
// 创建切片 s1 是之前切片的两倍容量
s1 := make([]int, len(s), (cap(s))*2)
// 拷贝 s 的内容到 s1
copy(s1,s)
- 切片截取 可以通过设置下限及上限来设置截取切片
// 打印子切片从索引1(包含) 到索引4(不包含)
fmt.Println(s[1:4])// [1 2 3]
// 默认下限为 0
fmt.Println(s[:3])// [0 1 2]
// 默认上限为 len(s)
fmt.Println(s[4:])// [4 5 6 7 8]
map
Map 是一种无序的键值对的集合，遍历 Map 时返回的键值对的顺序是不确定的。
Map 是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
// 创建一个空的 Map
m := make(map[string]int)
// 创建一个初始容量为 10 的 Map
m := make(map[string]int, 10)
// 使用字面量创建 Map
m := map[string]int{
"apple": 1,
"banana": 2,
"orange": 3,
}
// 获取键值对
v1 := m["apple"]
v2, ok := m["pear"] // 如果键不存在，ok 的值为 false，v2 的值为该类型的零值
// 修改键值对
m["apple"] = 5
// 获取 Map 的长度
len := len(m)
// 遍历 Map
for k, v := range m {
fmt.Printf("key=%s, value=%d\n", k, v)
}
// 删除键值对
delete(m, "banana")
range
range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。key 和 value 是可以省略
for _, value := range oMap
for key, _ := range oMap
函数
函数定义后可作为另外一个函数的实参数传入
/* 声明函数变量 */
getSquareRoot := func(x float64) float64 {
return math.Sqrt(x)
}
闭包是匿名函数，可在动态编程中使用
func getSequence() func() int {
i:=0
return func() int {
i+=1
return i
}
}
递归函数，递归，就是在运行的过程中调用自己。
func recursion() {
recursion() /* 函数调用自身 */
}
func main() {
recursion()
}
指针
变量是一种使用方便的占位符，用于引用计算机内存地址，一个指针变量指向了一个值的内存地址。
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
var ip *int /* 指向整型*/
var fp *float32 /* 指向浮点型 */
指针使用流程：
- 定义指针变量。
- 为指针变量赋值。
- 访问指针变量中指向地址的值。
var a int= 20 /* 声明实际变量 */
var ip *int /* 声明指针变量 */
ip = &a /* 指针变量的存储地址 */
/* 使用指针访问值 */
fmt.Printf("*ip 变量的值: %d\n", *ip )
// *ip 变量的值: 20
结构体
Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
// 定义结构体
type Books struct {
book_id int
}
// 创建一个结构体
a:=Books{book_id:1}
访问结构体成员，需要使用点号 . 操作符
// 声明 Book1 为 Books 类型
var Book1 Books
Book1.book_id = 22
fmt.Printf(Book1)
结构体指针
var Book1 *Books
a: = &Book1
结构体方法
type Books struct {
book_id int
}
func (b Books) checkBookid(book_id int) bool{
return b.book_id == book_id
}
func (b *Books) resetBookid(book_id int) {
b.book_id == book_id
}
func main(){
a:=Book{book_id:1}
a.resetBookid(2)
fmt.Println(a.checkBookid(2))
}
错误处理
Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
type error interface {
Error() string
}
函数通常在最后的返回值中返回错误信息。使用 errors.New 可返回一个错误信息
func Sqrt(f float64) (float64, error) {
if f < 0 {
return 0, errors.New("math: square root of negative number")
}
// 实现
}
func main(){
result, err:= Sqrt(-1)
if err != nil {
fmt.Println(err)
}
}
