go学习 | SYBlog

下载地址

Go官网下载地址：https://golang.org/dl/ (打开有点慢)
- 一定要记住安装位置

配置GOPATH

GOPATH是一个环境变量，用来表明你写的go项目的存放路径
GOPATH路径最好只设置一个，所有的项目代码都放到GOPATH的src目录下。

windows设置环境变量

我的电脑->属性->高级系统设置
- 检查一下你的电脑里面是否存在GOPATH并且设置值为你要存go代码的目录
- 如果没有新建一个GOPATH，同时将值设置为你go项目的根目录
- 同时在path里面添加go的安装目录和GOPATH目录

编译命令

go命令行工具
- go build:编译当前目录下的所有文件，生成可执行文件（会生成.exe文件，使用dir能够获取生成.exe文件的位置）
- go run:编译并运行当前目录下的所有文件
- go install:编译并安装当前目录下的所有文件
- go get:从github上下载依赖包
- go test:测试当前目录下的所有文件
- go fmt:格式化代码
- go doc:查看文档
- go env:查看环境变量
- go mod:管理依赖包
- go clean:清除编译生成的文件
- go list:列出当前目录下的所有文件
- go generate:生成代码
- go tool:查看工具
- go help:查看帮助
- go version:查看go版本
- go install:编译并安装当前目录下的所有文件
- go build -o hello.exe:编译当前目录下的所有文件，生成可执行文件（会生成.exe文件）
- go run main.go:编译并运行当前目录下的所有文件
- go mod init:初始化go项目
- go mod tidy:更新依赖包
- go mod vendor:将依赖包下载到本地

第一个go程序

在go程序中新建三个文件夹分别是：bin(用来存放编译后生成的可执行文件)、pkg(用来存放编译后生成的归档文件)、src(用来存放源码文件)

在src目录下创建一个hello目录，在hello目录中创建一个main.go文件：

package main          //声明main包，表名当前是一个可执行程序

import "fmt"          //导入内置 fmt

func main(){  // main函数，是程序执行的入口
    fmt.Println("Hello World!")  // 在终端打印 Hello World!
}

Golang变量

变量声明案例

:=声明变量

package main
import "fmt"
func main() {

    sum,sub := getVal(30,30)
    fmt.Println("sum=",sum,"sub=",sub)
    sum2,_ := getVal(10,30)
    fmt.Println("sum=",sum2)
}

func getVal(num1 int,num2 int) (int, int){    //注意方法中声明的返回值类型
sum := num1 + num2
sub := num2 - num2
return sum,sub
}

变量介绍

变量的概念
- 变量相当于内存中一个数量存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到这个房间，同样道理，通过变量名可以访问变量（值）。
变量的使用步骤
- 声明变量（也叫：定义变量）
- 初始化变量（也叫：赋值变量）
- 非变量赋值
- 使用变量

变量入门案例

案例

package main
import "fmt"
func main() {
//定义变量/声明变量
var i int
//给i赋值
i = 10
//使用变量
fmt.Println("i=",i)
//输出结果：i = 10
}

变量使用注意事项

变量表示内存中的一个存储区域
该区域有自己的名称（变量名）和类型（数据类型）

Golang变量使用的三种方式

第一种：指定变量类型，声明后若不赋值，使用默认值


package main
import "fmt"
func main() {

//golang的变量使用方法1
//第一种：指定变量类型，声明后若不赋值，使用默认值
//int 的默认值是0
var i int
fmt.Println("i=",i)

}

第二种：根据值自行判定变量类型（类型推导）

package main
import "fmt"
func main() {
//根据值自行判定变量类型（类型推导）
var num = 10.11
fmt.Println("num=",num)
}

第三种：省略var，注意:=左侧的变量不应该是已经声明过的，否则会导致编译错误

package main
import "fmt"
func main() {
//下面的方式等价 var name string name = "tom"
//:= 的 :不能省略，否则错误
name := "tom"
fmt.Println("name=",name)
}

多变量声明：在编程过程中，我们往往需要同时声明多个变量，此时我们可以使用逗号分隔符，例如：

package main
import "fmt"
func main() {
//该案例演示golang如何一次性声明多个变量
// var n1,n2,n3 int
// fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)

    //一次性声明多个变量的方式2
    // var n1,name,n3 = 100,"tom",888
    // fmt.Println("n1=",n1,"name=",name,"n3=",n3)

    //一次性声明多个变量的方式3，同样可以使用类型推荐
    n1,name,n3 := 100,"tom~",888 
    fmt.Println("n1=",n1,"name=",name,"n3=",n3)
}

如何一次性声明多个变量【在go中函数外部定义变量就是全局变量】

package main
import "fmt"
//定义全局变量
var n1 = 100
var n2 = 200
var name = "jack"
//上面的声明方式，也可以改成一次性声明
var (
n3 = 300
n4 = 900
name2 = "mary"
)

func main() {

    fmt.Println("n1=",n1,"n2=",n2,"name=",name,"n3=",n3,"n4=",n4,"name2=",name2)

}

该区域的数据值可以在同一类型范围内不断变化（重点）

package main
import "fmt"
//变量使用的注意事项
func main() {
//该区域的数据值可以在同一类型范围内不断变化
var i int = 10
i = 30
i = 50
fmt.Println("i=",i)
i = 1.2 //这个是错误的，原因是不能改变数据类型
}

变量在同一作用域（在一个函数或者在代码块）内不能重名

  
//变量在同一个作用域（在一个函数或者在代码块）内不能重名
var i int = 10
i := 30

变量=变量名+值+数据类型，这一点一定要注意！变量的三要素
Golang的变量如果没有赋初值，编译器会使用默认值，比如int默认值0 string默认值为空串，小数默认值为0

变量的声明，初始化和赋值

声明变量
- 基本语法：var变量名数据类型
- 示例：var i int 这就是声明一个变量，变量名是i，数据类型是int
- var num1 float32 这也是声明了一个变量，表示一个单精度类型的小数，变量名是num1，数据类型是float32
初始化变量
- 在声明变量的时候，就给值
- var a int = 45 这就是初始化变量 a
- 使用细节，如果声明时就直接赋值，可省略数据类型
- var b = 400
给变量赋值
- 比如你先声明了变量：var num int //默认 0
- 然后，再给值num = 780 这就是给边浪赋值

程序中 +号的使用

当左右两边都是数值型时，则做加法运算

当左右两边都是字符串，则做字符串拼接

package main
import "fmt"
//变量使用的注意事项
func main() {
    
    var i = 1
    var j = 2
    var r = i + j //做加法运算
    fmt.Println("r=",r) //输出 r= 3
    
    var str1 = "hello"
    var str2 = "world"
    var res = str1 + str2
    fmt.Println("res=",res)//输出res= helloworld
    
}

数据类型的基本介绍

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间
- 数据类型
  - 基本数据类型
    - 数值型
      - 整数类型(int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64)
      - 浮点类型(float32,float64)
    - 字符型(没有专门的字符型，使用byte来保存单个字母字符)
    - 布尔型(bool)
    - 字符串型(string)[官方将string归属到基本数据类型]
  - 派生/复杂数据类型
    - 指针(Pointer)
    - 数组
    - 结构体(struct)
    - 管道(channel)
    - 函数(也是一种类型)
    - 切片(slice)
    - 映射(map)
    - 接口(interface)

整数类型

基本介绍

简单的说，就是用于存放整数值的，比如0，-1,2345等等。
整数的各个类型

类型有无符号占用存储空间表数范围备注

int8 有 1字节 -128~127

int16 有 2字节 -2^15~2^15-1

int32 有 4字节 -2^31~2^31-1

int64 有 8字节 -2^63~2^63-1

类型	有无符号	占用存储空间	表数范围
int8	有	1字节	-128~127
int16	有	2字节	-2^15~2^15-1
int32	有	4字节	-2^31~2^31-1
int64	有	8字节	-2^63~2^63-1

package main
import "fmt"
//演示golang中整数类型使用
func main() {

    var i int = 1
    
    fmt.Println("i=",i)

    //测试一下int8的范围-128~127
    //其他的int16，int32，int64，类推...
    var j int8 = 127
 
    fmt.Println("j=",j)

}

int的其他类型的说明：

整型的类型

类型	有无符号	占用存储空间	表数范围	备注
int	有	32位系统4个字节 64位系统8个字节	-2^31 ~ 2^31-1 -2^63 ~ 2^63-1
uint	无	32位系统4个字节 64位系统8个字节	0 ~ 2^32-1 0 ~ 2^64-1
rune	有	4字节	-2^31~2^31-1	等价于int32，表示一个Unicode码
byte	无	1字节	0~255	当要存储字符时，可以使用byte来保存

package main
import "fmt"
//int,uint,byte的使用
func main() {

    var a int = 8900
    
    fmt.Println("a=",a)

    var b uint = 1
    var c byte = 255
 
    fmt.Println("b=",b,"c=",c)

}

类型的使用细节

Golang各整数类型分：有符号和无符号，int uint的大小和系统有关

Golang的整型默认声明为int型

package main
import "fmt"
//int,uint,byte的使用
func main() {

    var n1 = 100 //? n1 是什么类型
    //这里我们给介绍一下如何查看某个变量的数据类型
    //fmt.Printf()可以用于做格式化输出 (输出：n1 的 类型 int )
    fmt.Printf("n1 的 类型 %T \n",n1)

}