go语言开发环境搭建

1|0安装go开发包

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

2|0mac下载对应的go安装文件

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

3|0检测版本

go version

4|0配置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

5|0编译

• 使用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目录下面

6|0交叉编译

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

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

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

7|0代码解析

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

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

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

8|0变量和常量

8|1变量

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  同一个作用域({这里面就是作用域})不能重复声明同一个变量
}

8|2常量

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)
}

9|0八进制&十六进制

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)
}

10|0浮点型

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类型
	
}

11|0复数

complex64和complex128

12|0布尔值

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

13|0fmt

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)
}

14|0字符串

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, "+"))

}

15|0字符串修改

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

__EOF__

本文作者：404 Not Found
本文链接：https://www.cnblogs.com/weiweivip666/p/13945536.html
关于博主：可能又在睡觉
版权声明：转载请注明出处
声援博主：如果看到我睡觉请喊我去学习