go语言开发环境搭建

安装go开发包

Go官方镜像站（推荐）：​​https://golang.google.cn/dl/​​

mac下载对应的go安装文件

默认安装在/usr/local/go目录下

检测版本

go version

配置goproxy

# Go1.14版本之后，都推荐使用go mod模式来管理依赖环境了，也不再强制我们把代码必须写在GOPATH下面的src目录了，你可以在你电脑的任意位置编写go代码。（网上有些教程适用于1.11版本之前。）
默认GoPROXY配置是：GOPROXY=https://proxy.golang.org,direct，由于国内访问不到https://proxy.golang.org，所以我们需要换一个PROXY，这里推荐使用https://goproxy.io或https://goproxy.cn。
可以执行下面的命令修改GOPROXY：
go env -w GOPROXY=https://goproxy.cn,direct

编译

• 使用​​go build​​​ 1.在项目目录上执行​​go build​​,点击目录然后集成到终端，输入​​go build​​,会在当前目录下生产一个​​.exe​​结尾的可执行文件，直接执行这个文件即可
  
  
  2.在其它位置如果想编译的话，那么需要加路径，路径从​​src​​下一级开始
  ​​go build github.com/edsionxuanxuan/day01/helloworld​​,生成的执行文件就在你执行的路径下面
  3.指定生成后的可执行文件名
  ​​go build -o hello.exe​​
• 使用​​go run​​

1. 终端命令：​​go run main.go​​，直接打印

• 使用​​go install​​​ 一共做了两件事
  1.先会执行​​go build​​执行编译，生成可执行文件
  2.然后把可执行文件拷贝到bin目录下面

交叉编译

go支持跨平台编译
例如：在windows平台编译一共能在linux平台执行的可执行文件

SET CGO_ENABLED=0   //禁用CGO
SET GOOS=Linux   //目标平台是linux
SET GOARCH=amd64 //处理器架构

在执行​​go build​​就可以生成一个可在linux服务器上执行的可执行文件

代码解析

#package：所有的go文件都需要有一个package的声明
#main：包名，如果是main包说明代码最终会编译成一个可执行文件
package main  

import "fmt"  # 导入包，要用双引号
# 函数外只能放一些变量\常量\函数\类型的声明

func main()  {  # main函数 整个程序的入口
  fmt.Println("Hello World!")
}

变量和常量

变量

package main

import "fmt"

// go语言推荐使用驼峰式命名
var studentName string

// 声明变量
// var name string
// var age int
// var isOk bool

// 批量声明
var (
  name string // ""
  age  int    // 0
  isOk bool   //false
)

func main() {
  name = "理想"
  age = 16
  isOk = true
  // go语言中非全局变量声明了必须使用，不使用编译不过去
  fmt.Print(isOk)             //在终端中输出要打印的内容
  fmt.Printf("name:%s", name) // %s占位符 使用name这个变量的值取替换
  fmt.Println(age)            //打印完后会在最后面加一个换行符

  // 声明变量并同时赋值
  var s1 string = "王小小"
  fmt.Println(s1)
  // 类型推导（根据值判断该变量是什么类型）
  var s2 = "20"
  fmt.Println(s2)
  // 简短变量声明,只能在函数中使用下面声明方式
  s3 := "哈哈哈"
  fmt.Println(s3)
  // 匿名变量，不占用命名空间，不会分配内存，当返回多个值时，有些值不想使用,就可以用`_`来接收
  // s1 := 10  同一个作用域({这里面就是作用域})不能重复声明同一个变量
}

常量

package main

import "fmt"

const pi = 3.1415926

// 批量声明变量
const (
  statusOk = 200
  notFound = 404
)

// 批量声明常量时，如果某一行声明后没有赋值，说明它的值是跟上一行的值一样
const (
  n1 = 100
  n2
  n3
)
// iota
const (
  a1 = iota  //0
  a2   // 1
  a3   //2
)

const (
  b1 = iota //0
  b2   // 1
  _    // 2
  b3  // 3
)

// 插队 const中iota从0开始，每新增一行常量声明 iota+1
const (
  c1 = iota  //0
  c2 = 100 //100
  c3 = iota   //2
  c4  // 3
)
// 多个常量声明在一行
const (
  d1,d2 = iota+1,iota+2  // 1,2
  d3,d4 = iota+1,iota+2 // 2,3
)

// 定义数量级
const (
  _ = iota
  KB = 1 << (10*iota)  // 向左偏移10*iota位 1024
  MB = 1 << (10*iota)
  GB = 1 << (10*iota)
  TB = 1 << (10*iota)
  PB = 1 << (10*iota)

)

func main()  {
  fmt.Println("n1",n1)
  fmt.Println("n2",n2)
  fmt.Println("n3",n3)
  fmt.Println("a1",a1)
  fmt.Println("a2",a2)
  fmt.Println("a3",a3)
}

八进制&十六进制

go语言中无法直接定义二进制

package main

import "fmt"

// 整型
func main(){
  // 十进制
  var i1 = 101
  fmt.Printf("%d\n", i1)   // 直接打印
  fmt.Printf("%b\n", i1)  // 十进制转2进制
  fmt.Printf("%o\n", i1) // 把十进制转换为八进制
  fmt.Printf("%x\n", i1) // 把十进制转换为十六进制
  // 八进制
  i2 := 077
  fmt.Printf("%d\n", i2)  // 八进制转十进制
  // 十六进制
  i3 := 0x1234567
  fmt.Printf("%d\n", i3)  // 十六进制转十进制
  // 查看变量类型 T
  fmt.Printf("%T\n", i3)

  // 声明int8类型的变量
  i4 := int8(9)  //明确指定int8类型，否则就是默认为int类型
  fmt.Printf("%T", i4)
}

浮点型

float32和float64

package main

import "fmt"

// 浮点数



func main()  {
  // math.MaxFloat32   //32位浮点数最大数
  f1 := 1.23456
  fmt.Printf("%T\n", f1) // 默认go语言中的小数都是float64
  f2 := float32(1.23456)
  fmt.Printf("%T\n", f2) // 显示声明float32类型
  
}

复数

complex64和complex128

布尔值

1.只有​​true​​​和​​flase​​​两个值，默认声明的bool类型为false
2.不允许将整数转换为布尔型
3.布尔型无法参与数值运算，也无法与其他类型进行转换

fmt

package main

import "fmt"

// fmt占位符
func main(){
  var n = 100
  // %T 查看类型
  fmt.Printf("%T\n", n)
  // %v  查看值
  fmt.Printf("%v\n", n)
  // %b  查看二进制
  fmt.Printf("%b\n", n)
  // %d  查看十进制
  fmt.Printf("%d\n", n)
  // %o  查看八进制
  fmt.Printf("%o\n", n)
  // %x  查看十六进制
  fmt.Printf("%x\n", n)

  var s = "Hello World"
  // %s 查看字符串的值
  fmt.Printf("%s\n", s)
  // %v 查看值
  fmt.Printf("%v\n", s)
  // %#v 原型化输出，引号也会打印出来
  fmt.Printf("%#v\n", s)
}

字符串

go语言中字符串必须用双引号包裹
go语言中单引号包裹的是字符

s := "hello world"  // 字符串 
c1 := 'h'  //字符

字符串常用操作

package main

import (
  "fmt"
  "strings"
)

func main(){
  // \本来是具有特殊含义的，我应该告诉程序我写的\就是一个单纯的\
  path := "'D:\\Go\\src\\day01'"
  fmt.Println(path) // 打印结果为带单引号的路径

  s := "I'm ok"
  fmt.Println(s)
  // 多行的字符串
  s2 := `第一行
  第二行
  第三行
  `
  fmt.Println(s2)
  s3 := `D:\Go\src\day01`
  fmt.Println(s3)   // 打印结果为D:\Go\src\day01

  // 字符串相关操作
  fmt.Println(len(s3))  // 计算长度

  // 字符串拼接
  name := "理想"
  world := "dsb"
  // 方式1 + 拼接
  ss := name + world
  fmt.Println(ss)
  // 方式2 Sprintf 拼接
  ss1 := fmt.Sprintf("%s%s", name, world) //
  fmt.Println(ss1)

  // 分割
  ret := strings.Split(s3, "\\")
  fmt.Println(ret)

  // 包含
  fmt.Println(strings.Contains(ss,"理性")) // 返回false
  fmt.Println(strings.Contains(ss,"理想")) // 返回true

  // 前缀 以什么开头
  fmt.Println(strings.HasPrefix(ss, "理想")) // 返回true
  // 后缀 以什么结尾
  fmt.Println(strings.HasSuffix(ss, "理想")) // 返回false

  // 取索引下标 以0开始
  s4 := "abcdeb"
  fmt.Println(strings.Index(s4, "c"))  // 2
  // 判断最后出现的位置
  fmt.Println(strings.LastIndex(s4, "b"))  // 5

  // join拼接
  fmt.Println(strings.Join(ret, "+"))

}

字符串修改

默认字符串是不能修改的，如果要修改需要转换为另外一种类型的变量

-------------------------------------------

个性签名：代码过万，键盘敲烂！！！

如果觉得这篇文章对你有小小的帮助的话，记得“推荐”哦，博主在此感谢！