这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记，学习了第一次go语言上手的课，同时上网参考其他go语言教程的文章写出来的一篇小笔记。

GO

什么是Go语言？

高性能，高并发
语法简单，学习曲线平缓
丰富的标准库
静态链接
快速编译
跨平台
垃圾回收

go语言支持交叉编译。

交叉编译是在一个平台上生成另一个平台上的可执行代码。

基础语法

Hello go

package main //表明这个文件属于mian包

import ( 
    "fmt"
) // 导包

func main() {
    fmt.Println("hello world")
} //main函数

变量

变量声明

单变量

go语言的单变量声明有3种

第一种

//go会进行自动推导
var a = "abc" 
var b = 123

第二种

//你也可以显示的声明
var a int = 123
var b string = "abc"

第三种

//冒号声明，也是可以进行自动推导
a := 123
b := "abc"
/*补充：
冒号声明的方法只能在函数体内实现
也就是说全局声明不可以使用这种方法
*/

补充

若变量声明不赋值，则默认值为0

多变量

var a, b int = 1, 2
var c, d int string = 3, "aaa"

//一般用于声明全局变量
var{
    a int 
    b bool
}

常量

常量是一个简单值的标识符，在程序运行中不可以被修改

常量中的数据类型只能是bool类型，数字类型，字符串类型

const a int = 123
const b = "string"

优雅的常量 iota

常量可以枚举

const {
    a = 123
    b = "v"
}

可以使用iota进行自增长

const {
    a = iota    //0
    b           //1
    c           //2
    d           //3

}

可以使用iota作用于表达式

const {
    a = 1 << iota   //1 << 0 00000001 
    b               //1 << 1 00000010
    c               //1 << 2 00000100
    d               //1 << 3 00001000
}

函数

go的函数可以返回多个值

func swap(a, b string) (string, string) {
    return b, a
}

init函数和main函数

init函数可以出现在任意的package中，可以在同一个package出现多次，但是一般只写一个。

main函数只能在 main package包中出现，且只能有一个。

go语言是如何执行的？

go语言-init.jpg

函数参数

函数中如果有参数，那么这些参数就是形参

形参就像在函数里定义的局部变量

一般函数参数的传递有两种：

值传递

值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

即使用指针

条件控制

循环

go语言只有一种循环，for循环

//死循环
for {
    fmt.Println("go")
}
//传统循环
for j :=1; j<10; j++ {
    fmt.Println(j);
}
//类while
i :=1
for i <= 3 {
    fmt.Println(i)
    i += 1
}

if

if不带括号

i := 3
if i <= 3 {
    fmt.Println(i)
    i += 3
}

switch

switch语句相比其他的语言有更多的功能

且不需要在每一个case后面加上break

i := 1
switch {
    case i< 2:
        fmt.Println("i less than 2")
    default:
        fmt.Println("i oooooo")
}

数组

在go里面可以定义数组

但是使用数组的意义不大

var a [5]int
a[4] = 5 //未赋值的元素默认为0
fmt.Println("a[4]=", a[4])
for i := 0; i < len(a); i++ {
    fmt.Println(a[i])
}

切片

go语言的数组长度不可改变，在某些特点的场合下这样的集合不适用

于是go提供了另一种方式创建一个动态数组，即切片

声明

//不声明数组长度时，默认创建一个切片
slice1 := []int{}
//也可以使用make方法创建一个切片,此时可以指定切片的容量len
slice2 := make([]string, len)

初始化

slice1 := []string {"ad", "ac", "aa" }

初始化切片也可以通过引用数组实现

len()和cap() 函数

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

切片截取

可以通过设置下限及上限来设置截取切片

numbers := []int{0, 1, 2, 3, 4, 5}
fmt.Println("numbers=",numbers) //打印原始切片
//切片截取,打印从索引1到索引4(不包括4)
fmt.Println("numbers[1:4]=",numbers[1:4])

剩下还有许多其他内容，先总结到这里。

Go语言基础 | 青训营笔记

GO