Go 语言基础学习(一）

golang

go语言
具有方便的垃圾收集机制和强大的运行时反射机制。 它是一个快速的、静态类型的编译型语言，感觉却像动态类型的解释型语言。

vscode配置

以下内容转载go配置

[注意]

1. Go语言区分大小写，模块中要导出的函数，首字母 必须 大写

fmt.Println("hello world")
// Println 的P 要大写！！！

2. 每行程序结束后不需要撰写分号（;）。
3. 大括号（{）不能够换行放置。
4. if 判断式和 for循环不需要以小括号包覆起来。

包

每个Go程序都是由包构成的。
程序从main包开始运行。

按照约定，包名与导入路径的最后一个元素一致。例如，"math/rand"包中的原始码以package rand语句开始。

记录我出现的错误
最开始创建了 hellogo.go 文件，后来创建了main.go 文件，所以把hellogo给注释了，但是这时报了个错误

后来经过查阅，发现是 这个目录下有空文件。所以删除一行注释或者把这个文件移除就可以啦~
修改完要保存ctrl+s，才会更新

咱们继续哈~

导入

使用 import 进行导入
多组导入可以使用()

import (
	"fmt"
	"math"
)

导出

名字开头字母是大写，说明是已导出的

在导入一个包时，你只能引用其中已导出的名字。任何“未导出”的名字在该包外均无法访问。

函数

1. 函数可以 无参 或 多个参数

类型在变量名后
函数返回值在参数后

func add(a int, b int )int {
return a+b
}

为什么要把函数参数类型放到变量后？
http://blog.go-zh.org/gos-declaration-syntax

这种从左到右的样式的优点之一是，随着类型变得越来越复杂，它的效果如何。这是一个函数变量的声明（类似于C中的函数指针）：

f func(func(int,int) int, int) int

或者，如果f返回一个函数：

f func(func(int,int) int, int) func(int, int) int

从左到右，它仍然清晰可见，并且始终清楚声明了哪个名称-名称在前。
类型和表达式语法之间的区别使在Go中编写和调用闭包变得容易。

2. 当连续多个 形参 类型 相同时，可以省略除最后一个形参的类型
3. 函数返回值 可以返回任意数量

func swap(x, y string) (string, string) {
	return y, x
}
func main() {
	a, b := swap("hello", "world")
	fmt.Println(a, b)
}

：= 是短变量声明 如果类型明确可以代替var声明
在函数外的声明必须用 var ，所以 ：= 结构不能用在函数外. 如下面main函数中所示

4.  返回值的名称应当具有一定的意义，它可以作为文档使用。
 如果 return 后没有参数，那么直接返回已命名的返回值。
 **直接返回可能会影响函数的可读性**

变量

使用 var 关键字 声明变量列表，参数放到最后。

var i int = 4    
var xixixi, c, java bool 
// int/float64 默认是0 
// bool类型的变量 默认是 false
// 如果初始化的值已经存在，可以省去类型
// 字符串默认是空串“ ”
var go = “yes！！”
func main(){
	i, j := 5, 49
	k := 3
	aa, bb, cc := true, false, true
	fmt.Println(i, xixi, chr, wm, naon, aa, bb, cc, j, k)
}
	

Go 的基本类型有

bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的别名
float32 float64
复数类型：complex64 complex128
字符类型：rune。//int32别名
错误类型：error。

复合类型

指针 pointer
切片 slice
通道 chan
接口 interface
字典 map
结构体 struct
数组 array

使用type关键字定义类型

type INT int  

将INT定义为新的类型，这个类型和int类型有着相同的功能。但是这两个不是同一个类型,所以也就不能直接赋值，只能通过强转

var b int = 4
var a INT = (INT) b

var a INT =3 //错误

var (
	x      bool       = false
	maxint uint64     = 1<<64 - 1
	z      complex128 = cmplx.Sqrt(-5 + 12i)
)

	fmt.Printf("Type: %T value:%v\n", x, x)
	fmt.Printf("Type: %T value:%v\n", maxint, maxint)
	fmt.Printf("Type: %T value:%v\n", z, z)
	
Type: bool value:false
Type: uint64 value:18446744073709551615
Type: complex128 value:(2+3i)

类型转换

1. 数值的转换

// 定义 int类型的i
var i int = 42 
//将i转换成 float64
var f float64 = float(i)
//将f转换成uint类型
var u uint = uint(f)
//另一种方式
i := 42
f := float64( i )
u := uint( f )

不同类型项之间的赋值需要进行显示转换
bool类型不能强制转换，也不可以被赋值成其他类型，也不接受自动转换

2. 整型转换
   由于 int 和 int32 也是不同类型，两者之间需要强转

var ii int32
ss := 4
ii = ss //报错
ii = int32(ss)  //将ss强转成int32,生成临时int32文件，在赋值给ii，但ss类型不变

逻辑比较也是这个情况，不能比较2个不同的类型的值
各种int类型的变量，都可以和字面常量（literal）比较。

*整型数据的运算，包括± /%以及移位等运算，*与C完全一样。唯一不同的是，C语言中的取反运算是~i，但是go语言中是^i。

4. 右值推导
   如果我们声明一个变量，却不定义类型的时候，这个变量的类型就会由右值推导得出。

var i int
// j根据右值推导可得出其类型是int类型
j:=i
//bool类型可以进行推导
var uu bool = true
ee := (1 == 2)

常量

const 关键字修饰
如果一个常量未指定类型，由上下文来决定类型

const (
	// 将 1 左移 100 位来创建一个非常大的数字
	// 即这个数的二进制是 1 后面跟着 100 个 0
	Big = 1 << 100
	// 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2
	Small = Big >> 99
)

循环

go 只有 for 循环

基本的 for 循环由三部分组成，它们用分号隔开：

初始化语句：在第一次迭代前执行
条件表达式：在每次迭代前求值
后置语句：在每次迭代的结尾执行

初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。

一旦条件表达式的布尔值为 false，循环迭代就会终止。

注意：Go 的 for 语句后面的三个构成部分外没有小括号， 大括号 { } 则是必须的。

package main
import "fmt"
func main(){
	sum := 0
	for i := 0;i < 10;++i {
		sum += i
	}
fmt.println(sum)
}

其中 i:=0 和++i 可以没有，也就是说初始化和后置语句可以没有。相当于while

func main(){
sum := 0
	for sum<10 {
		sum += sum
	}
	fmt.println(sum)
}

//无限循环
for {
}

判断

与 for 相同 ，可以在条件表达式前执行一个简单的语句

if v := math.Pow(x, n); v < lim {
		return v

defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

原理：推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

func main() {
	for i := 0; i < 10; i++ {
		defer fmt.Println(i)
	}
	fmt.Println("done")
}

输出结果
done
9
8
7
…

switch

case 语句 从上到下顺序执行，直到匹配成功
不过 Go 只运行选定的 case，而非之后所有的 case。 实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。 除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。
也就是说 case可以是 字符串或者任意类型

注释与文档工具Godoc

基本规则

The Go project takes documentation seriously! godoc

只要用一个常见的注释，直接加在声明前，并没有插入的空行，这样就可以自动文档化包，类型，接口，变量，常量…

1. 注释要紧跟声明
2. 多行注释中间不能空行

第一行为简短介绍，第二行及以后是详细介绍

// Add 两数相加（这一行会被截取为简短介绍）
// 两数相加的注意事项以及原理（这一行作为超级详细的介绍）
func Add(n1,n2 int)int{
    return n1+n2
}

具体一些规则 https://blog.csdn.net/qq_28057541/article/details/79890301