教做鞋的网站,邹城市住房和建设局网站,网站建设公司人员组成,百度上做网站需要钱吗基础
安装Go扩展 go build
在项目目录下执行go build go run
像执行脚本文件一样执行Go代码 go install
go install分为两步#xff1a;
1、 先编译得到一个可执行文件
2、将可执行文件拷贝到GOPATH/bin Go 命令
go build :编译Go程序
go build -o xx.exe…基础
安装Go扩展 go build
在项目目录下执行go build go run
像执行脚本文件一样执行Go代码 go install
go install分为两步
1、 先编译得到一个可执行文件
2、将可执行文件拷贝到GOPATH/bin Go 命令
go build :编译Go程序
go build -o xx.exe 编译成xx.exe文件
go run main.go: 像执行脚本一样执行main.go文件
go install: 先编译后拷贝 变量
3种声明方式 var name1 string var name2 沙河娜扎 函数内部专属name3:沙河小王子
常量
const PI 3.1415926
const UserNotExistErr 10000 iota:实现枚举
两个要点 iota在const关键字出现时将被重置为0 const中每新增一行常量声明iota累加1 基本数据类型
整型
无符号整型uint8、uint16、uint32、uint64
带符号整型:int8、int16、int32、int64
uint和int:具体是32位还是64位看操作系统
uintptr:表示指针
浮点型
float64和float32
Go语言中浮点数默认是float64
复数
complex128和complex64
布尔值
true和false
不能和其他的类型做转换
字符串
常用方法
字符串不能修改
byte和rune类型
都属于类型别名 复合数据类型 数组
数组的声明
// 数组是存放元素的容器 // 必须指定存放的元素的类型和容量长度 // 数组的长度是数组类型的一部分 var a1 [3]bool // [true false true] var a2 [4]bool // [true true false false]
fmt.Printf(a1:%T a2:%T\n, a1, a2)
数组的初始化
// 数组的初始化 // 如果不初始化默认元素都是零值布尔值false, 整型和浮点型都是0, 字符串 fmt.Println(a1, a2) // 1. 初始化方式1 a1 [3]bool{true, true, true} fmt.Println(a1) // 2. 初始化方式2根据初始值自动推断数组的长度是多少 // a10 : [9]int{0, 1, 2, 3, 4, 4, 5, 6, 7} a10 : [...]int{0, 1, 2, 3, 4, 4, 5, 6, 7} fmt.Println(a10) // 3. 初始化方式3根据索引来初始化 a3 : [5]int{0: 1, 4: 2} fmt.Println(a3)
数组的遍历
// 数组的遍历 citys : [...]string{北京, 上海, 深圳} // 索引0~2 citys[0],citys[1],citys[2] // 1. 根据索引遍历 for i : 0; i len(citys); i { fmt.Println(citys[i]) } // 2. for range遍历 for i, v : range citys { fmt.Println(i, v) }
二维数组
// 多维数组 // [[1 2] [3 4] [5 6]] var a11 [3][2]int a11 [3][2]int{ [2]int{1, 2}, [2]int{3, 4}, [2]int{5, 6}, } fmt.Println(a11)
// 多维数组的遍历 for _, v1 : range a11 { fmt.Println(v1) for _, v2 : range v1 { fmt.Println(v2) } } 数组是值类型
// 数组是值类型 b1 : [3]int{1, 2, 3} // [1 2 3] b2 : b1 // [1 2 3] CtrlC CtrlV 把world文档从文件夹A拷贝到文件夹B b2[0] 100 // b2:[100 2 3] fmt.Println(b1, b2) // b1:[1 2 切片slice
切片指向了一个底层的数组。
切片的长度就是它元素的个数。
切片的容量是底层数组从切片的第一个元素到最后一个元素的数量。
切片的定义
// 切片的定义 var s1 []int // 定义一个存放int类型元素的切片 var s2 []string // 定义一个存放string类型元素的切片 fmt.Println(s1, s2) fmt.Println(s1 nil) // true fmt.Println(s2 nil) // true
切片的初始化
// 初始化 s1 []int{1, 2, 3} s2 []string{沙河, 张江, 平山村} fmt.Println(s1, s2) fmt.Println(s1 nil) // false fmt.Println(s2 nil) // false
切片的长度和容量
// 长度和容量 fmt.Printf(len(s1):%d cap(s1):%d\n, len(s1), cap(s1)) fmt.Printf(len(s2):%d cap(s2):%d\n, len(s2), cap(s2)
make
make()函数用于创建指定长度和容量的切片。
s1 : make([]int, 5, 10) fmt.Printf(s1%v len(s1)%d cap(s1)%d\n, s1, len(s1), cap(s1))
s2 : make([]int, 0, 10) fmt.Printf(s1%v len(s1)%d cap(s1)%d\n, s2, len(s2), cap(s2))
切片的本质
切片就是一个框框住了一块连续的内存。
切片属于引用类型真正的数据都是保存在底层数组里的。
判断一个切片是否是空的要是用len(s) 0来判断
append
// 调用append函数必须用原来的切片变量接收返回值 // append追加元素原来的底层数组放不下的时候Go底层就会把底层数组换一个 // 必须用变量接收append的返回值 s1 append(s1, 广州) fmt.Printf(s1%v len(s1)%d cap(s1)%d\n, s1, len(s1), cap(s1)) s1 append(s1, 杭州, 成都) fmt.Printf(s1%v len(s1)%d cap(s1)%d\n, s1, len(s1), cap(s1)) ss : []string{武汉, 西安, 苏州} s1 append(s1, ss...) // ...表示拆开 fmt.Printf(s1%v len(s1)%d cap(s1)%d\n, s1, len(s1), cap(s1))
copy
a1 : []int{1, 3, 5} a2 : a1 // 赋值 var a3 make([]int, 3, 3) copy(a3, a1) // copy fmt.Println(a1, a2, a3) a1[0] 100 fmt.Println(a1, a2, a3)
指针
Go语言中不存在指针操作只需要记住两个符号 :取地址 *:根据地址取值
make和new的区别 make和new都是用来申请内存的 new很少用一般用来给基本数据类型申请内存string、int,返回的是对应类型的指针(*string、*int)。 make是用来给slice、map、chan申请内存的make函数返回的的是对应的这三个类型本身
map
map也是引用类型必须初始化之后才能使用。
func main() { var m1 map[string]int fmt.Println(m1 nil) // 还没有初始化没有在内存中开辟空间 m1 make(map[string]int, 10) // 要估算好该map容量避免在程序运行期间再动态扩容 m1[理想] 18 m1[jiwuming] 35 fmt.Println(m1) fmt.Println(m1[理想]) // 约定成俗用ok接收返回的布尔值 fmt.Println(m1[娜扎]) // 如果不存在这个key拿到对应值类型的零值 value, ok : m1[娜扎] if !ok { fmt.Println(查无此key) } else { fmt.Println(value) } // map的遍历 for k, v : range m1 { fmt.Println(k, v) } // 只遍历key for k : range m1 { fmt.Println(k) } // 只遍历value for _, v : range m1 { fmt.Println(v) } // 删除 delete(m1, jiwuming) fmt.Println(m1) delete(m1, 沙河) // 删除不存在的key }
函数
// 函数
// 函数存在的意义 // 函数是一段代码的封装 // 把一段逻辑抽象出来封装到一个函数中给它起个名字每次用到它的时候直接用函数名调用就可以了 // 使用函数能够让代码结构更清晰、更简洁。
// 函数的定义 func sum(x int, y int) (ret int) { return x y }
// 没有返回值 func f1(x int, y int) { fmt.Println(x y) }
// 没有参数没有返回值 func f2() { fmt.Println(f2) }
// 没有参数但有返回值的 func f3() int { ret : 3 return ret }
// 返回值可以命名也可以不命名
// 命名的返回值就相当于在函数中声明一个变量 func f4(x int, y int) (ret int) { ret x y return // 使用命名返回值可以return后省略 }
// 多个返回值 func f5() (int, string) { return 1, 沙河 }
// 参数的类型简写: // 当参数中连续多个参数的类型一致时我们可以将非最后一个参数的类型省略 func f6(x, y, z int, m, n string, i, j bool) int { return x y }
// 可变长参数 // 可变长参数必须放在函数参数的最后 func f7(x string, y ...int) { fmt.Println(x) fmt.Println(y) // y的类型是切片 []int }
// Go语言中函数没有默认参数这个概念
func main() { r : sum(1, 2) fmt.Println(r) _, n : f5() fmt.Println(n) f7(下雨了) f7(下雨了, 1, 2, 3, 4, 5, 6, 7) }
