回看下历史

谷歌工程师 Rob Pike
图标是他老婆设计的：
一只土拨鼠

是在2009年11月10日正式开源和发布的。
当然其实核心开发者还有很多，反正都是大佬，就懒得一一写出来了。
反正的语言就是强大的

Go 是一个静态语言类型

环境安装和开发工具：

安装环境：
https://studygolang.com/dl

选对应的
下载好之后，按照步骤安装就行

装好之后老规矩就可以看到版本

看看环境变量和安装目录和工作目录
安装目录

工作目录

保存Go的代码和各种包的
可以通过go env 命令去看看go 的环境变量
开发软件就是Goland

老规矩，写个hello world

package main  
  
import (  
   "fmt"  
   _ "fmt"  
)  
  
func main() {  
   fmt.Println("hello world!")  
}

go的main包是有特殊含义的。一个项目就是只有一个main包。程序在构建过程中会去找main包，在其中也会去寻找main函数。

基础语法：

go的注释：

/*  
注释  
*/  
  
//注释

变量

写在前面：
未使用错误
go语言的神奇之处，编译器会将未使用的局部变量当做错误，虽说知道它的初衷是好的，不过刚开始会难受，但这有助于培养良好的编程习惯。

变量（variable）表示没有固定值且可以改变的数（数学定义），也可以说是一段或者多段用来存储数据的内存。（计算机系统定义）

作为静态类型语言，go变量总是有固定的数据类型，类型决定了变量内存的长度和存储格式，可以改变变量值（类型转换或指针操作），无法改变类型。

定义：

关键字var用于定义变量，类型放在变量名后。运行时内存分配操作会确保变量自动初始化为二进制零值（zero value），避免出现不可控行为。 如显式提供初始化值，可省略变量类型，有编译器推断。

var 变量名 变量类型

var x int     //自动初始化为0
var y = false //自动推断为bool类型

可一次定义多个变量，包括用不同初始值定义不同类型

package main  
  
import (  
   "fmt"  
   _ "fmt"  
)  
  
func main() {  
   fmt.Println("hello world!")  
   var x int     //自动初始化为0  
   var y = false //自动推断为bool类型  
   var name = "simple"  
   name = "thanks"       //改变量  
   var a, b int          //相同类型的多个变量  
   var c, d = 100, "abc" //不同类型的初始化值,这里 c是100 d是abc  
   /*      按照编程习惯，建议以组的方式整理多行变量定义，即用大括号美观一点。  
   */   var (  
      a1, b1 int  
      c1, d1 = 100, "abc"  
   )  
   fmt.Println(name, x, y, a, b, c, d)  
   fmt.Println(a1, b1, c1, d1)  
}

简短定义模式

除var关键词外，还能使用如下模式

func main(){
  x := 100
  a, s :=1, "abc"
}

简短模式限制

1. 定义变量，同时显式初始化
2. 不能提供数据类型
3. 只能用于函数内部

package main  
  
import "fmt"  
  
func main() {  
   x := 1  
   name := "simple"  
   age := 18  
   fmt.Println(x)  
   fmt.Println(name)  
   fmt.Println(age)  
}

简短模式不一定总是重新定义变量，也可能是部分退化的赋值操作。 退化赋值的前提条件是 最少有一个新变量被定义且必须是同一作用域。

func main(){
  x := 100
  println(&x)

  x := 200                      //错误：no new variable on left side of :=
  println(&x, x)
}

打印变量的内存地址和类型

func main() {  
   x := 100  
   //输出变量的内存地址和值  
   println(&x, x)  
   fmt.Printf("%d,%p", x, &x)  
   println()  
   //得出变量的类型  
   fmt.Printf("%T", x)  
}

😀

Go的变量交换

package main  
  
import "fmt"  
  
func main() {  
   a := 100  
   b := 200  
   b, a = a, b  
   fmt.Println(a, b)  
}

匿名变量（空白标识符）：

为什么会有这个东西？
因为他可以用来增加代码的灵活性。

匿名变量就是一个下划线__

匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

package main  
  
import "fmt"  
  
func test() (int, int) {  
   return 100, 200  
}  
func main() {  
   a, _ := test()  
   fmt.Println(a)  
  
}

变量的作用域：

局部变量：
函数中定义的就是局部变量。
全局变量：
在函数外定义的就是全局的。

package main  
  
var quanjv = 100  
  
func main() {  
   jvbu := 200  
   println(jvbu)  
   println(quanjv)  
}```

## 常量：
常量的数据类型只可以是布尔类型，数字类型，字符串类型

>const 常量名 常量数据类型 = 值

```go
package main  
  
func main() {  
  
   const name = "simple"  
   println(name)  
}

package main  
  
import "fmt"  
  
func main() {  
   const (  
      //在常量组中如不能指定类型和初始化值，则与上一行非空常量右值（表达式文本）相同。  
      x uint16 = 120  
      y        //与上一行x类型，右值相同  
      s = "abc"  
      z //与s的类型，右值相同  
   )  
  
   fmt.Printf("%T, %v\n", y, y)  
   fmt.Printf("%T, %v\n", z, z)  
}

输出：

uint16, 120
string, abc

iota常量计数器

特殊常量：iota是go 语言中的常量计数器。
iota在const出现时被置为0（const内部的第一行之前），const中每增加一行常量声明将使iota计数一次。

package main  
  
import "fmt"  
  
func main() {  
   const (  
      a = iota  
      b = 3  
      c = iota  
      d  
      e      f   )  
   fmt.Println(a, b, c, d, e, f)  
  
   const (  
      g = iota  
   )  
   fmt.Println(g)  
}

输出：
0 3 2 3 4 5
0

所以可以看见，当常量没有被赋值的时候，就会自动赋值成iota的值
iota会计数每一次定义常量.
定义一次常量iota就加一。

可以看见下一组const中iota会重置为0

数据类型

布尔类型

bool
两个值真和假

数值型

整数

package main  
  
import "fmt"  
  
func main() {  
   var age int = 18  
  
   fmt.Println(age)  
   fmt.Printf("%T", age)
   }

浮点数

package main  
  
import "fmt"  
  
func main() {  
   var money float64 = 3.14  
   fmt.Printf("%T,%.1f", money, money)   
}

尽量使用float64

字符串类型

定义String

package main  
  
import "fmt"  
  
func main() {  
   //双引号  
   var name string = "simple"  
   fmt.Printf("%T,%s\n", name, name)  
   // 单引号 字符  
   v1 := '1'  
   v2 := 's'  
  
   fmt.Printf("%T,%d\n", v1, v1)  
   fmt.Printf("%T,%s\n", v2, v2)  
   // 字符串拼接  
   fmt.Println("hello " + "world")  
}

输出：

string,simple
int32,49            
int32,%!s(int32=115)
hello world  

双引号是字符串类型
单引号中是单个字符，但是go中没有这样单独的，他直接默认成int32类型。保存的是他的ascii码。

字符串连接是直接用加号拼接

常见的别名：

在官方的规范中，专门提到有两个别名：

 byte alis for uint8
 tune alis for int32

别名类型无需转换，可直接赋值。

数据类型转换：

格式：

valueofTypeB = TypeB(valueofTypeA)
说人话就是：
int类型 = int（‘a’)

package main  
  
func main() {  
   a := 5  
   b := float64(a)  
   //c := bool(a) 转化不了的  
   println(a, b)  
  
}

小变大是正常的，但是大变小就会造成精度丢失。

运算符

算术运算符

注意自增和自减只有A++ 或A-- 没有++A --A

关系运算符

和其他语言差不多

package main  
  
func main() {  
   a := 10  
   b := 11  
  
   if a == b {  
      println("yes a == b ")  
   } else {  
      println("NO ")  
   }  
  
}

逻辑运算符

位运算

赋值运算符：

流程控制：

选择

if

package main  
  
func main() {  
   a := 10  
   if a > 10 {  
      print("yes")  
   } else if a == 10 {  
      print("middle")  
   } else {  
      print("no")  
   }  
}

switch

switch默认是自带break的

package main  
  
func main() {  
   x := 100  
   switch x {  
   case 10:  
      print("10")  
   case 100:  
      print("100")  
   case 1000:  
      print("1000")  
   default:  
      print("nono")  
   }  
  
}

如果要取消这个break就需要用fallthroug关键字

package main  
  
func main() {  
   a := true  
  
   switch a {  
   case true:  
      println("yes")  
      fallthrough  
   case false:  
      //if a == true {  
      // print("hell")      //}      print("no")  
   default:  
      print("final")  
   }  
}

可以看到这个关键字，直接到了下一个case不管条件的。

循环

for

package main  
  
func main() {  
   for i := 0; i < 10; i++ {  
      println(i)  
   }  
}

go 的for循环也有break和continue两个关键字。

键盘输入输出

package main  
  
import "fmt"  
  
func main() {  
   var x int  
   var y int  
  
   fmt.Scanf("%d,%d", &x, &y)  
   println(x, y)  
  
  
}

和C、C++ 很像 。

遍历String

package main  
  
import "fmt"  
  
func main() {  
   name := "simple"  
   for i := 0; i < len(name); i++ {  
      fmt.Printf("%c ", name[i])  
   }  
}