简介
Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。
环境搭建
官方网站
https://studygolang.com/
IDE下载
https://download.jetbrains.com.cn/go/goland-2021.1.exe
Hello World
package main
import "fmt"
func main() {
fmt.Println("Hello world!")
}
变量
// 整型
var a int = 100
a := 100
// 浮点型
b := 1000.0
// 字符串
c := "Objcat"
// 数组
d := []int{1, 2, 3}
// 字典
e := map[string]string{"name": "objcat", "age": "18"}
函数
1.无参数无返回值
func hello() {
fmt.Println("hello world!")
}
func main() {
hello()
}
2.有参数无返回值
func hello(text string) {
fmt.Println(text)
}
func main() {
hello("hello world!")
}
3.有参数有返回值
func hello(text string) string {
return text
}
func main() {
result := hello("hello world!")
fmt.Println(result)
}
字符串
1. 定义字符串
var myStr string = "123"
// 或 推导
myStr := "123"
2. 获取字符串
// 字符串可以通过下标来获取字字符串
fmt.Printf("%c", myStr[0]) // 1
fmt.Printf("%c", myStr[1]) // 2
3.拼接字符串
// 加号拼接
myStr2 := myStr + "456" // 123456
// 数组拼接
StrArr := []string{"123", "456"}
myStr2 := strings.Join(StrArr, "") // 123456
// format
myStr2 := fmt.Sprintf("%s%s", myStr, "456") // 123465
// Buffer
var sbuffer bytes.Buffer
sbuffer.WriteString("123")
sbuffer.WriteString("456")
myStr2 := sbuffer.String() // 123456
// builder
var sbuilder strings.Builder
sbuilder.WriteString("123")
sbuilder.WriteString("456")
myStr2 := sbuilder.String()
4.替换字符串
myStr2 := strings.ReplaceAll(myStr, "1", "12") // 1223
5.查找字符串位置
index := strings.Index(myStr, "2") // 1
6.遍历字符串
for index, value := range myStr {
fmt.Println("索引", index)
fmt.Println(fmt.Sprintf("值 %c 类型 %T", value, value))
}
数组
1.定义数组
// 定长数组
var myArr [10]string
myArr := [10]int{1, 2, 3}
// 动态数组
var myArr = make([]int, 0)
myArr := []int{}
2.获取元素
// 通过下标获取 下标从0开始
print(myArr[0])
3.添加元素
my_arr = append(myArr, 1)
print(myArr) // [1]
4.删除元素
// Go没有提供删除数组中元素的方法 但是可以使用append来达到效果
// 1.删除i位置的元素 - 原理就是把第i个位置空下去了
append(myArr[:i], myArr[i+1:]...)
// 2.直接删除元素
for i, _ := range myArr {
if myArr[i] == obj {
myArr = append(array[:i], array[i+1:]...)
break
}
}
// 3.封装方法
func remove(arrayInterface interface{}, obj interface{}) interface{} {
switch arrayInterface.(type) {
case []int:
array := arrayInterface.([]int)
for i, _ := range array {
if array[i] == obj {
arrayInterface = append(array[:i], array[i+1:]...)
return arrayInterface
}
}
break
case []string:
array := arrayInterface.([]string)
for i, _ := range array {
if array[i] == obj {
arrayInterface = append(array[:i], array[i+1:]...)
return arrayInterface
}
}
break
}
return arrayInterface
}
// 使用
myArr2 := []string{"1", "2", "3"}
fmt.Println(myArr2)
myArr2 = remove(myArr2, "2").([]string)
fmt.Println(myArr2)
5.截取元素
myArr2 = myArr[0:2] // [1, 2]
myArr2 = myArr[:2] // [1, 2]
myArr2 = myArr[1:2] // [2]
myArr2 = myArr[1:] // [2, 3]
6.拼接数组
myArr = append(myArr, []int{6, 7, 8}...)
fmt.Println(myArr)
字典
1.定义字典
var myDic = make(map[string]string)
myDic["name"] = "张三"
myDic["age"] = "18"
// 或者
myDic := map[string]string{
"name": "张三",
"age": "18",
}
2.获取元素
str := myDic["name"]
fmt.Println(str) // 张三
3.添加元素
myDic["gender"] = "男"
fmt.Println(myDic) // map[age:18 gender:男 name:张三]
4.删除元素
delete(myDic, "name")
fmt.Println(myDic) // map[age:18]
5.拼接字典
// 官方没有提供 但是可以自己写 当然这是不健全的
func Append(dictInterface1 interface{}, dictInterface2 interface{}) interface{} {
switch dictInterface1.(type) {
case map[string]string:
dict1, _ := dictInterface1.(map[string]string)
dict2, _ := dictInterface2.(map[string]string)
for k, v := range dict2 {
dict1[k] = v
}
return dict1
}
return dictInterface1
}
// 用法
myDic = Append(myDic, map[string]string{"gender": "男", "cat": "objcat"}).(map[string]string)
fmt.Println(myDic)
集合
go 没有集合的概念 但是可以用数组代替
1.创建集合
// 定长数组
var myArr [10]string
myArr := [10]int{1, 2, 3}
// 动态数组
var myArr = make([]int, 0)
myArr := []int{}
1.并集
func union(slice1, slice2 []string) []string {
m := make(map[string]int)
for _, v := range slice1 {
m[v]++
}
for _, v := range slice2 {
times, _ := m[v]
if times == 0 {
slice1 = append(slice1, v)
}
}
return slice1
}
2.交集
func intersect(slice1, slice2 []string) []string {
m := make(map[string]int)
nn := make([]string, 0)
for _, v := range slice1 {
m[v]++
}
for _, v := range slice2 {
times, _ := m[v]
if times == 1 {
nn = append(nn, v)
}
}
return nn
}
3.补集
func difference(slice1, slice2 []string) []string {
m := make(map[string]int)
nn := make([]string, 0)
inter := intersect(slice1, slice2)
for _, v := range inter {
m[v]++
}
for _, value := range slice1 {
times, _ := m[value]
if times == 0 {
nn = append(nn, value)
}
}
return nn
}
条件语句
1.if
a := 1
// 如果a等于1 执行条件
if a == 1 {
fmt.Println("a等于1")
}
2.if - else if
a := 1
// 如果a等于1执行1 如果a等于2执行2
if a == 1 {
fmt.Println("a等于1")
} else if a == 2 {
fmt.Println("a等于2")
}
3.if - else if - else
a := 1
// 如果都不等 执行else
if a == 1 {
fmt.Println("a等于1")
} else if a == 2 {
fmt.Println("a等于2")
} else {
fmt.Println("a既不等于1也不等于2")
}
循环语句
1.for
for i := 0; i < 10; i++ {
fmt.Println(i)
}
// 遍历数组
for i, v := range []int{1, 2, 3, 4} {
fmt.Println("下标 ", i)
fmt.Println("值", v)
}
// 遍历字典
my_dic := map[string]string{"name": "张三", "age": "18"}
fmt.Println(my_dic)
for k, v := range my_dic {
// key
fmt.Println(k)
// value
fmt.Println(v)
}
2.while
// go没有while 但是可以用for代替
for i := 0; ; i++ {
fmt.Println(i)
if i == 1000 {
break
}
}
类和对象
1.类
type Person struct {
}
2.定义成员变量
type Person struct {
name string
age int
}
// 实例化
func main() {
per := Person{"张三", 18}
}
3.定义构造函数
// go没有构造函数 但是可以单独写一个方法代替
type Person struct {
name string
age int
}
func NewPerson(name string, age int) Person {
return Person{name, age}
}
func main() {
per := NewPerson("张三", 18)
fmt.Println(per)
}
4.定义方法
func (this *Person)say() {
fmt.Println("人说")
}
// 调用
func main() {
per := Person{"张三", 18}
per.say()
}
5.继承
type Student struct {
Person
id int
}
// 实例化
func main() {
per := Person{"张三", 18}
per.say()
stu := Student{per, 1}
fmt.Println(stu) // {{张三 18} 1}
}
6.重写方法
type Student struct {
Person
id int
}
func (this *Student)say() {
fmt.Println("学生说")
}
func main() {
per := Person{"张三", 18}
per.say()
stu := Student{per, 1}
stu.say() // 学生说
}