第一、战前准备

1. 一台优质的计算机
2. 一个有基础的互联网新贵
3. 每天拿出来点时间
4. 安装环境
5. 下载编辑器 ps：推荐goland，免费就选择vscode

第二、开始战斗

注释

一个好的程序员都是从注释开始的,它和ts都是谷歌弄的，你别说，风格真像啊，编程语言的尽头会是谷歌么
// 单行注释
/* 
多
行
注
释
*/

尾椎为.go的文件构成

// 包声明 一个项目就只能有一个main  一般情况下都是目录名 
package main
// 导入部分
import "fmt"
// 其他函数
func p(num int)int{
	fmt.Println(num)
	return num
}




// 主函数 一个目录下是最多只能有一个main了,都是从这里开始的 而且main 必须不能有参数 不能有返回值
func main() {
	var a = 1
	p(a)
}

变量声明

var s int = 1 
var 是声明关键字 
s 是变量名 
int 是类型 ps：类型也可以省略，会根据右面的值推导出来左面的类型
1 肯定是值了


a := 1
推断赋值，根据右面的值推导出来左面的类型

全局变量和局部变量

package main


import "fmt"
import "build/src/app"


// 全局变量
var test = 2




// 主函数
func main()  {
	var a = 3 * 5
	defer app.Window(a)
	fmt.Println("this is main")
	defer app.Window(test)
	// 局部变量
	var test = 3
	// 调用的局部变量
	defer app.Window(test)
    // 局部变量
	test++
	defer app.Window(test)
}
重点（期末会考）：注册在全局的变量，看要不要被其他的文件调用，要是被其他文件调用的话需要首字母大写，golang这个点比较神奇，
只有首字母大写的才可以被其他文件调用相当于抛出

变量与常量

常量是什么意思呢，就是有一个固定的值你总要调用，然后它就被提取出来，放在前头下次改的时候省的一个一个改
const xxx = 456456465
声明常量时就要直接赋值，因为它不许别人更改他，天王老子来了也不行，耶稣说的。

指针类型

var v int = 4
var d *int = &value
fmt.Println(d,*d) // 0xc00000a0a8 4
取地址符这个就需要有点基础的人来学习了，这个变量吧指向的是一个地址，变量的值呢就是这个地址里头的值
重点来了，这两个符号要记住 一个是指针 * 一个是取地址符 & 
言简意赅，一个是取到这个变量的地址，一个是去这个地址看值

基础数据类型

有符号整数
int 8 // 1字节
int 16 // 1字节 * 2 
int 32  // 1字节 * 3
int 64 // ****
无符号整数
uint 8 // 1字节
uint 16 // 1字节 * 2 
uint 32  // 1字节 * 3
uint 64 // ****
布尔
bool
字节
byte
字符串
string
浮点数
float32 
float64
复数
complex64
complex128
字符
unicode
rune
指针
uintptr

分支

if xxx > yyy {
  巴拉巴拉巴拉
}


if xxx < yyy {
  巴拉巴拉巴拉
} else {
  拉巴拉巴拉巴
}


if xxx == yyy {
  巴拉巴拉巴拉
} else if qwe > ewq {
 啊吧啊吧啊吧
}
if a := 1;a > 0{  // if后还可以跟一步推导赋值，这样a就是if的局部变量
   小鬼子！
}
// if就这样用奥，ps golang没有三目哦~ 
switch xxx  {
case 0,1,2,3:  // 多个这个值呢，用英文逗号隔开 
  啦啦啦啦
case 4:        // case 后头虽然可以跟多个值了，但是在一个switch里出现了一个重复的都运行不了
  巴拉巴拉
  fallthrough    // 其他语言都是执行之后 需要你去break，go是直接跳，但是你可以用这个挽留它，会向下接着执行
default:
  啊吧啊吧       // 这个就是没有匹配的时候执行的了
}
这个xxx呢可以直接就是值,变量 表达式
比如: 
1
a
a := 1; a  // 这个时候 a 就是switch的局部变量了
也可以直接省略掉
switch {
case a > b:
  aqeb()
case a < b:
  aleb()
}
ps： 还有一种暂时用不到，想知道自行百度或者等后续

循环

golang里呢是没有这个while 和 do while的，因为大门说大神们有这个关键字洁癖，整那么多关键字没用，所以只有for了
那就直接开始演示了,
for {
  啊吧啊吧啊吧
} // 对 他就是这么简单 你说这连个条件都不写是不是不好看


for true {
  巴拉巴阿巴拉
} // 行了 满足你
for i := 0; i < 10 ; i++{
  正常点
} // 这是正常版的
// 跳出和跳过 还是没变的 break continue
strings := []string{"Hello","world"} // 声明一个字符串数组 还是叫迭代器吧 这个不只是数组可以迭代
for index,value := range strings{        // python ts？  就是遍历这个 数组 解出来了两个参数 第一个是下标，第二个是值
	fmt.Println(index)
	fmt.Println(value)
}

高级变量(数组)

	/*
	 声明一个数组
	*/
	// int数组生命时候 数组内元素都默认为0
	var a = [3]int{7,8,9}      // 基本操作
	var b = [...]int{9,10,11} //不指定数组长度，自动计算长度, [...]
	var c = [...]int{0:9,2:10,1:11} // 指定下标赋值
	var d = new([2]int)        // new 一个数组
	var e [2]int
	var f = &e					// 这个 f 操作 等于上面 那个new
	var g = [][]int{{1,2},{12,3}}
	// make  类型 长度 容量 容量可以省略 默认和 长度相同
	var h = make([]int,5,10) // 初始长度5的int 数组 容量为10 切片可以取到10 会动态扩容 元素爆掉的时候自动扩充容量 用cap查看容量 第一次扩容会自动扩大一倍 第二次按照大小扩容
	d[0] = 1
	d[1] = 2
	f[0] = 3
	f[1] = 4
	k := h[1:2]  // 起始点  终点  最大容量
	h = append(h,1,2,3,4,5,7,8,78,5,9,5,4,1,1,4,4,1,4,5,4,1,1,4,8,7,5)
	fmt.Println(a[0:3])
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(*d)
	fmt.Println(*f)
	fmt.Println(g)
	fmt.Println(h)
	fmt.Println(h[0:])
	fmt.Println(h[0:9:10])
	fmt.Println(cap(h))
	fmt.Println(k)
	// 字符串声明时 为空字符串
	var q = []string{"j","q"}
	var w [3]string
	fmt.Println(q)
	fmt.Println(w[0] == "")
	// 默认为false
	var r [3]bool
	fmt.Println(r)
	var u = map[string]interface{}{
		"req": []interface{}{0, "all", []interface{}{0}},
	}
	var i = []interface{}{1,2,"ALL"}
	fmt.Println(u)
	fmt.Println(i)