go语言基础（一）

go安装

参照菜鸟教程 Go 语言环境安装
可以学习的博文 李文周GO

关于vscode配置go语言开发环境问题

go env -w GOPROXY=https://goproxy.cn,direct
安装完go后命令台执行这个指令
有什么用呢？
vscode扩展go后会有个像下图的提示，这时候install all，会发现下载失败，这就是没有输入上面那个指令的问题，卸载扩展go，去命令台输入指令，再安装后install all即可

语言结构

需要注意的一点是 { 不能单独放在一行，所以以下代码在运行时会产生错误：

package main

import "fmt"

func main()  
{  //错误，{ 不能在单独的行上
    fmt.Println("Hello, World!")
}

行分隔符

格式跟python一样，不需要分号结尾
因为go的编译器会自动添加，如果需要多个语句在同一行，就需要分号了，但实际开发过程中不提倡这么写

注释

跟c语言一样的，单行// 多行/**/

标识符

也就是命名变量的时候是否合法
不合法的：
1ab（以数字开头）
case（Go 语言的关键字）
a+b（运算符是不允许的）

格式化字符串

package main

import (
    "fmt"
)

func main() {
   // %d 表示整型数字，%s 表示字符串
    var stockcode=123
    var enddate="2020-12-31"
    var url="Code=%d&endDate=%s"
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)
}

Operation results：
Code=123&endDate=2020-12-31

数据类型

Go语言数据类型

我测试了一下如果超过变量类型存放的数据大小会怎样

package main

import "fmt"

func main(){
	var a uint8 = -1
	//查看变量类型
	fmt.Printf("type = %t\n",a)
}

发现go语言有个参数边界检测提示

“var”与“:=”的区别

定义变量格式：
var variableName type = value

定义了一个int类型的变量number，初始化为10
var number int = 10

由于go语言设计者觉得这样比较繁琐
所以缩短成了 var variableName = value ，这样直接忽略掉了变量类型
然后继续简化成了 variableName := value
相当于var variableName = value 语句和variableName := value语句等同

变量

单变量声明

第一种，指定变量类型，如果没有初始化，则变量默认为零值。

go语言变量未初始化的初始值
数值类型（包括complex64/128）为 0
布尔类型为 false
字符串为 “”（空字符串）
以下几种类型为 nil：
var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

第二种，根据值自行判定变量类型。

就是没定义变量类型，编译器会根据你的变量来设置变量类型

第三种，如果变量已经使用 var 声明过了

如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误

多变量声明

package main

var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

Operation results：
0 0 0 false 1 2 123 hello 123 hello

值类型和引用类型

所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值

当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝

go语言可以像c语言一样操作地址，用了&取地址符
值类型变量的值存储在堆中
更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。
一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。

当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。

如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响

数据交换

如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。
这样就不需要加个变量Buffer了。
往常c语言值的交换，就是Buffer = a ， a = b ，b = Buffer

iota

iota
常用来设置枚举类型

package main

import "fmt"

func main(){
	const (
		ColorRed      = iota
		ColorOrange      
		ColorYellow      
		ColorGrassland   
		ColorCyan            
		ColorBlue            
		ColorPurple      
	)

	fmt.Println(ColorOrange)
	fmt.Println(ColorPurple)
	const (
		a      = iota
		b     
	)
	fmt.Println(a)
	fmt.Println(b)
}

Opetion results：
1
6
0
1

运算符

跟c语言没区别，就不想写了

条件语句

多了个select(随机执行)，是为了避免饥饿问题
一般配合通道(chan)一起使用

package main

import "fmt"

func main() {
   var c1, c2, c3 chan int
   var i1, i2 int
   select {
      case i1 = <-c1:
         fmt.Printf("received ", i1, " from c1\n")
      case c2 <- i2:
         fmt.Printf("sent ", i2, " to c2\n")
      case i3, ok := (<-c3):  // same as: i3, ok := <-c3
         if ok {
            fmt.Printf("received ", i3, " from c3\n")
         } else {
            fmt.Printf("c3 is closed\n")
         }
      default:
         fmt.Printf("no communication\n")
   }    
}

循环

循环嵌套就循环套循环，没多大区别
循环控制语句也没啥区别，也是break，continue，goto