一、配置get源镜像
bash
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct二、命令行执行go文件
2.1 源码:demo.go
go
package main //必须有一个main包
import "fmt" // 导入包，必须使用
func main() {
fmt.Println("hello word")
}2.2 生成exe方式运行
生成demo.exe
bash
go build demo.go
bash
demo.exe2.3 直接运行
bash
go run demo.go三、变量的使用
声明方法：var
3.1 单重赋值
go
package main
import "fmt"
func main() {
// 声明一个变量a,其类型为整型,默认为0
var a int
a = 10 // 给a赋值
fmt.Println(a)
// 声明多个相同类型变量
var b, c int
b = 20
c = 30
fmt.Println(b, c)
// 声明多个不同类型的变量
var (
x int
y float64
)
x = 100
y = 3.14
fmt.Println(x, y)
// 自动推导类型(只能声明一次，不能再写成 d := 50,可以正常 d = 50)，声明一个变量d,并且赋值40
d := 40
fmt.Println(d)
}3.2 多重赋值
go
package main
import "fmt"
func main() {
// 多重赋值
a, b, c := 10, 20, 30
fmt.Println(a, b, c)
}3.3 匿名变量
go
package main
import "fmt"
// 定义一个测试函数
func test() (a, b, c int) {
return 1, 2, 3
}
func main() {
// 多重赋值
d, e, f := 10, 20, 30
fmt.Println(d, e, f)
// _ 匿名变量 例如：调用test返回的3个值中的第二个值，重新给e赋值
_, e, _ = test()
fmt.Println(d, e, f)
}四、常量的使用
go
package main
import "fmt"
func main() {
const a = 10 // 声明一个常量a，其值为10
a = 20 // 常量不能改变，故不能重新赋值，会出现：cannot assign to a (declared const)的错误
fmt.Println(a)
}五、iota枚举
go
package main
import "fmt"
func main() {
// 1、iota常量自动生成器，每隔一行，自动累加1
// 2、iota给常量赋值使用
const (
a = iota
b = iota
c = iota
)
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c) // a = 0, b = 1, c = 2
// 3、iota遇到const，重置为0
const d = iota
fmt.Printf("d = %d\n", d) // d = 0
// 4、可以只写一个iota
const (
a1 = iota
b1
c1
)
fmt.Printf("a1 = %d, b1 = %d, c1 = %d\n", a1, b1, c1) // a1 = 0, b1 = 1, c1 = 2
// 5、如果是同一行，值都一样
const (
i = iota
j1, j2, j3 = iota, iota, iota
k = iota
)
fmt.Printf("i = %d, j1 = %d, j2 = %d, j3 = %d, k = %d\n", i, j1, j2, j3, k) // i = 0, j1 = 1, j2 = 1, j3 = 1, k = 2
}六、函数
go
package main
import "fmt"
func foo1(a string, b int) int {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
c := 100
return c
}
//返回多个返回值，匿名的
func foo2(a string, b int) (int, int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
return 666, 777
}
//返回多个返回值， 有形参名称的
func foo3(a string, b int) (r1 int, r2 int) {
fmt.Println("---- foo3 ----")
fmt.Println("a = ", a)
fmt.Println("b = ", b)
//r1 r2 属于foo3的形参， 初始化默认的值是0
//r1 r2 作用域空间 是foo3 整个函数体的{}空间
fmt.Println("r1 = ", r1)
fmt.Println("r2 = ", r2)
//给有名称的返回值变量赋值
r1 = 1000
r2 = 2000
return
}
func foo4(a string, b int) (r1, r2 int) {
fmt.Println("---- foo4 ----")
fmt.Println("a = ", a)
fmt.Println("b = ", b)
//给有名称的返回值变量赋值
r1 = 1000
r2 = 2000
return
}
func main() {
c := foo1("abc", 555)
fmt.Println("c = ", c)
ret1, ret2 := foo2("haha", 999)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
ret1, ret2 = foo3("foo3", 333)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
ret1, ret2 = foo4("foo4", 444)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
}七、指针
7.1 值传递
go
package main
import "fmt"
func swap(a int ,b int) {
var temp int
temp = a
a = b
b = temp
}
func main() {
var a int = 10
var b int = 20
swap(a, b)
fmt.Println("a = ", a, " b = ", b) // a = 10 b = 20
}7.2 内存地址传递
go
package main
import "fmt"
func swap(pa *int, pb *int) {
var temp int
temp = *pa //temp = main::a
*pa = *pb // main::a = main::b
*pb = temp // main::b = temp
}
func main() {
var a int = 10
var b int = 20
swap(&a, &b)
fmt.Println("a = ", a, " b = ", b) // a=20 b=10
}八、defer用法
8.1 defer执行顺序:先进后出
go
package main
import (
"fmt"
)
func func1() {
fmt.Println("A")
}
func func2() {
fmt.Println("B")
}
func func3() {
fmt.Println("C")
}
func main() {
defer func1()
defer func2()
defer func3()
}8.2 defer和return执行顺序：return先执行，defer后执行
go
package main
import (
"fmt"
)
func func1() int {
fmt.Println("A")
return 0
}
func func2() int {
fmt.Println("B")
return 0
}
func test() int {
defer func1()
return func2()
}
func main() {
test()
}九、数组和动态数组（slice）
9.1 固定长度数组（值拷贝）
bash
package main
import "fmt"
func main() {
// 固定长度数组
var myArray1 [10]int // 默认值为0
for i :=0; i< len(myArray1); i++ {
fmt.Print(myArray1[i]) // 0000000000
}
}
go
package main
import "fmt"
func main() {
// 固定长度数组
myArray1 := [10]int{1, 2, 3, 4, 5}
for index, value := range myArray1 {
fmt.Println("index", index, "value:", value)
}
}9.2 动态数组（内存地址传递）
go
package main
import "fmt"
func printArray(myArray [] int) {
// 声明一个动态数组 []不指定长度就是动态数组
for _, value :=range myArray{
// _代表匿名变量不引用
fmt.Println("value",value)
}
myArray[0] = 1000
}
func main() {
// 固定长度数组
myArray1 := []int{1, 2, 3, 4, 5}
printArray(myArray1)
fmt.Println(myArray1)
}9.3 slice 4种声明方法
go
package main
import "fmt"
func main() {
//声明slice1是一个切片，并且初始化，默认值是1，2，3。 长度len是3
//slice1 := []int{1, 2, 3}
//声明slice1是一个切片，但是并没有给slice分配空间
var slice1 []int
//slice1 = make([]int, 3) //开辟3个空间 ，默认值是0
//声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0
//var slice1 []int = make([]int, 3)
//声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0, 通过:=推导出slice是一个切片
//slice1 := make([]int, 3)
fmt.Printf("len = %d, slice = %v\n", len(slice1), slice1)
//判断一个silce是否为0
if slice1 == nil {
fmt.Println("slice1 是一个空切片")
} else {
fmt.Println("slice1 是有空间的")
}
}9.4 slice切片追加
go
package main
import "fmt"
func main() {
var numbers = make([]int, 3, 5)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)
//向numbers切片追加一个元素1, numbers len = 4， [0,0,0,1], cap = 5
numbers = append(numbers, 1)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)
//向numbers切片追加一个元素2, numbers len = 5， [0,0,0,1,2], cap = 5
numbers = append(numbers, 2)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)
//向一个容量cap已经满的slice 追加元素，
numbers = append(numbers, 3)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)
fmt.Println("-=-------")
var numbers2 = make([]int, 3)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)
numbers2 = append(numbers2, 1)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)
}9.5 slice切片截取
go
package main
import "fmt"
func main() {
s := []int{1, 2, 3} //len = 3, cap = 3, [1,2,3]
s1 := s[0:2] // [1, 2]
fmt.Println(s1)
s1[0] = 100
fmt.Println(s)
fmt.Println(s1)
//copy 可以将底层数组的slice一起进行拷贝
s2 := make([]int, 3) //s2 = [0,0,0]
//将s中的值 依次拷贝到s2中
copy(s2, s)
fmt.Println(s2)
}十、map三种定义方式
go
package main
import "fmt"
func main() {
//===> 第一种声明方式
//声明myMap1是一种map类型 key是string， value是string
var myMap1 map[string]string
if myMap1 == nil {
fmt.Println("myMap1 是一个空map")
}
//在使用map前， 需要先用make给map分配数据空间
myMap1 = make(map[string]string, 10)
myMap1["one"] = "java"
myMap1["two"] = "c++"
myMap1["three"] = "python"
fmt.Println(myMap1)
//===> 第二种声明方式
myMap2 := make(map[int]string)
myMap2[1] = "java"
myMap2[2] = "c++"
myMap2[3] = "python"
fmt.Println(myMap2)
//===> 第三种声明方式
myMap3 := map[string]string{
"one": "php",
"two": "c++",
"three": "python",
}
fmt.Println(myMap3)
}十一、map使用方式
go
package main
import "fmt"
func printMap(cityMap map[string]string) {
//cityMap 是一个引用传递
for key, value := range cityMap {
fmt.Println("key = ", key)
fmt.Println("value = ", value)
}
}
func ChangeValue(cityMap map[string]string) {
cityMap["England"] = "London"
}
func main() {
cityMap := make(map[string]string)
//添加
cityMap["China"] = "Beijing"
cityMap["Japan"] = "Tokyo"
cityMap["USA"] = "NewYork"
//遍历
printMap(cityMap)
//删除
delete(cityMap, "China")
//修改
cityMap["USA"] = "DC"
ChangeValue(cityMap)
fmt.Println("-------")
//遍历
printMap(cityMap)
}十二、struct的使用
go
package main
import "fmt"
//声明一种行的数据类型 myint， 是int的一个别名
type myint int
//定义一个结构体
type Book struct {
title string
auth string
}
func changeBook(book Book) {
//传递一个book的副本
book.auth = "666"
}
func changeBook2(book *Book) {
//指针传递
book.auth = "777"
}
func main() {
/*
var a myint = 10
fmt.Println("a = ", a)
fmt.Printf("type of a = %T\n", a)
*/
var book1 Book
book1.title = "Golang"
book1.auth = "zhang3"
fmt.Printf("%v\n", book1)
changeBook(book1)
fmt.Printf("%v\n", book1)
changeBook2(&book1)
fmt.Printf("%v\n", book1)
}