Go语言基础知识学习（一）

Go基本数据类型

bool

bool型值可以为true或者false,例子：

var b bool = true

数值型

类型	表示	范围
int8	有符号8位整型	-128 ~ 127
int16	有符号16位整型	-32768 ~ 32767
int32	有符号32位整型	-2147783648 ~ 2147483647
int64	有符号64位整型	···
uint8	无符号8位整型	0 ~ 255
uint16	无符号16位整型	0 ~ 65535
uint32	无符号32位整型	0 ~ 4294967295
uint64	无符号64位整型	···

浮点型

类型	表示
float32	32位浮点数
float64	64位浮点数

其他

类型	表示
byte	uint8
rune	int32

数据类型的转换

简单的转换操作

package mainimport ("fmt""strconv"
)// 类型转换
func main() {var a int8 = 12var b = uint8(a)var f float32 = 3.14var c = int32(f)fmt.Println(b, c)var f64 = float64(a)fmt.Println(f64)type IT int //类型要求很严格var d IT = 13fmt.Println(d)//字符串转数字var istr = "12a"//字符串转数字的方法，返回转换的值和errormint, err := strconv.Atoi(istr)if err != nil {fmt.Println("convert error!")} else {fmt.Println(mint)}var myi = 32//数字转字符串mstr := strconv.Itoa(myi)fmt.Println(mstr)//字符串转为float32, 转换为boolfl, err2 := strconv.ParseFloat("3.1415926", 64)if err2 != nil {return}fmt.Println(fl)//字符串转为整数parseInt, err3 := strconv.ParseInt("-42", 10, 64)if err3 != nil {return}fmt.Println(parseInt)//字符串转为boolparseBool, parseBoolErr := strconv.ParseBool("true")if parseBoolErr != nil {return}fmt.Println(parseBool)//基本类型转为字符串boolStr := strconv.FormatBool(true)fmt.Println(boolStr)//float转为字符串floatStr := strconv.FormatFloat(3.1415926, 'f', -1, 64)fmt.Println(floatStr)fmt.Println(strconv.FormatInt(42, 16))
}

运算符和表达式

package mainimport "fmt"func main() {// 运算符 + - * / % ++ --var a, b = 1, 2fmt.Println(a + b) //3var astr, bstr = "hello", "zed"fmt.Println(astr + bstr) //hellozed//取余fmt.Println(3 % 2) //1a++fmt.Println(a) //2//逻辑运算符var abool, bbool = true, falsefmt.Println(abool && bbool) //falsefmt.Println(abool || bbool) //truefmt.Println(!abool)         //false//位运算符var A = 60var B = 13fmt.Println(A & B) // 12
}

字符串

格式化输出

package mainimport ("fmt""strconv""strings"
)func main() {//转义符courseName := "go\"体系课\""fmt.Println(courseName)//格式化输出username := "bobby"out := "hello" + username //简单组装输出fmt.Println(out)age := 18address := "北京"fmt.Println("用户名: " + username + "," + "年龄: " + strconv.Itoa(age) + ",地址: " + address)fmt.Printf("用户名: %s, 年龄: %d, 地址: %s", username, age, address) //非常常用，性能不好userMsg := fmt.Sprintf("用户名: %s, 年龄: %d, 地址: %s", username, age, address)fmt.Println(userMsg)//通过string的builder进行字符串拼接，高性能var builder strings.Builderbuilder.WriteString("用户名: ")builder.WriteString(username)builder.WriteString(", 年龄: ")builder.WriteString(strconv.Itoa(age))builder.WriteString(", 地址: ")builder.WriteString(address)re := builder.String()fmt.Println(re)
}

字符串的比较

package mainimport "fmt"func main() {//字符串的比较a := "hello"b := "hello"fmt.Println(a == b) // true//字符串的大小比较c := "bello"fmt.Println(a > c) //true，比较asic码的大小
}

字符串的操作方法

package mainimport ("fmt""strings"
)func main() {//字符串的比较a := "hello"b := "hello"fmt.Println(a == b) // true//字符串的大小比较c := "bello"fmt.Println(a > c) //true，比较asic码的大小//是否包含某字符串name := "goland-工程师"isContains := strings.Contains(name, "goland")fmt.Println(isContains)//查询字串出现的次数fmt.Println(strings.Count(name, "o")) //1//分割字符串fmt.Println(strings.Split(name, "-")) //[goland 工程师]//字符串是否包含前缀 是否包含后缀fmt.Println(strings.HasPrefix(name, "g")) //truefmt.Println(strings.HasSuffix(name, "g")) //false//查询字串出现的位置fmt.Println(strings.Index(name, "师")) //14 字节出现的位置//字串替换fmt.Println(strings.Replace(name, "goland", "java", 1))//大小写转换fmt.Println(strings.ToLower(name))fmt.Println(strings.ToUpper(name)) // GOLAND//去掉特殊字符串fmt.Println(strings.Trim("hello go   ", " ")) // hello go, 去掉的是左右的所有被指定的字符串}

条件判断与for循环

条件判断

package mainimport "fmt"/* if bool表达式 {逻辑
}
*/func main() {//条件判断age := 22country := "中国"if age < 18 && country == "中国" {fmt.Println("未成年人")} else if age == 18 {fmt.Println("刚好是成年人")} else {fmt.Println("成年人")}}

for循环

package mainimport "fmt"func main() {/*for循环for init; condition; post {逻辑}*/for i := 0; i < 3; i++ {fmt.Println(i)}//打印九九乘法表for i := 1; i <= 9; i++ {for j := 1; j <= i; j++ {fmt.Printf("%d * %d = %d ", i, j, i*j)}fmt.Println()}//for range,主要是对字符串、数组、切片、map、channel的遍历/**for index, value := range 遍历的数据 {}1. 如果遍历的是字符串的话，key为字符串的索引，value字符串对应的缩影的字符的值的拷贝，如果不鞋key，返回的是索引2. 数组: key为数组的索引，value为索引对应的值的拷贝3. 切片: key为切片的索引，value为索引对应的值的拷贝4. map: key为map的key， value为key对应的值的拷贝5. channel:  无key,    value为channel接收的数据*/name := "hello, go"for index, value := range name {//fmt.Println(index, value)fmt.Printf("%d %c\r\n", index, value)}//不想打印index，可以使用匿名变量fmt.Println("----------------------------")for _, value := range name {fmt.Printf("%c\r\n", value)}fmt.Println("----------------------------")for index := range name {fmt.Printf("%c\r\n", name[index])}
}

goto

package mainimport "fmt"/*
*
goto语句可以让我的代码跳到指定的代码块中运行
很少用
*/
func main() {for i := 0; i < 5; i++ {for j := 0; j < 4; j++ {if j == 2 {goto over}fmt.Println(i, j)}}over:fmt.Println("over")}

switch

package mainimport "fmt"func main() {/*switch val {case val1:...case val2:...default:...}*///中文的星期几，输出对应的英文day := "周五"switch day {case "周一":fmt.Println("Mongday")case "周五":fmt.Println("Friday")case "周三":fmt.Println("Wednesday")default:fmt.Println("Saturday")}score := 95switch {case score < 60:fmt.Println("E")case score >= 60 && score < 70:fmt.Println("D")case score >= 70 && score < 80:fmt.Println("C")case score >= 80 && score < 90:fmt.Println("b")case score >= 90 && score <= 100:fmt.Println("A")}switch score {case 60, 70, 80:fmt.Println("牛")default:fmt.Println("牛牛")}
}

Go语言的容器

数组、切片（slice）、map、list

Go–数组

package mainimport "fmt"func main() {/*go语言提供了哪些集合类型的数据结构1、数组2、切片（slice）3、map4、list*/// 数组 定义: var name [count]intvar courses1 [3]string //courses1类型: 只有三个元素的数组类型var courses2 [4]string //courses2类型: 只有四个元素的数组类型fmt.Printf("%T\r\n", courses1)fmt.Printf("%T\r\n", courses2)courses1[0] = "go"courses1[1] = "grpc"courses1[2] = "gin"fmt.Println(courses1)//对数组进行遍历,indexfor _, value := range courses1 {fmt.Println(value)}
}

Go–Slice切片

package mainimport "fmt"func main() {//go折中var courses []stringfmt.Printf("%T\r\n", courses)courses = append(courses, "Java", "Python", "Golang")fmt.Println(courses)//访问切片的元素 访问一个,根据下标访问 or 访问多个fmt.Println(courses[2])//访问多个coursesSlice := []string{"Java", "Go", "mysql", "Kafka", "Redis", "ElasticSearch"}/*courseSlice[start:end] 左闭右开区间，1、如果只有start，没有end，表示从start开始到结尾的所有数据2、如果没有start，只有end，表示从0到end之间的所有的数据3、没有start没有end就是复制了一份*/fmt.Println(coursesSlice[1:3])fmt.Println(coursesSlice[0:])fmt.Println(coursesSlice[:3])fmt.Println(coursesSlice[:])//切片数据的添加coursesSlice2 := []string{"go", "grpc"}//若想合并两个切片的数据coursesSlice3 := []string{"python", "kafka"}for _, val := range coursesSlice3 {coursesSlice2 = append(coursesSlice2, val)}coursesSlice2 = append(coursesSlice2, coursesSlice3...)coursesSlice2 = append(coursesSlice2, "gin", "mysql", "es")fmt.Println(coursesSlice2)//如何删除slice中的元素,利用append函数重新生成slicecoursesSlice4 := []string{"go", "Java", "Python", "MySQL"}newSlice := append(coursesSlice4[:2], coursesSlice4[3:]...)fmt.Println(newSlice)//复制slicecoursesSlice4Copy := coursesSlice4coursesSlice4Copy2 := coursesSlice4[:]fmt.Println(coursesSlice4Copy)fmt.Println(coursesSlice4Copy2)var newCoursesSliceCopy = make([]string, len(coursesSlice4))copy(newCoursesSliceCopy, coursesSlice4)fmt.Println(newCoursesSliceCopy)fmt.Println("--------直接赋值和使用copy函数的区别--------")coursesSlice4[0] = "golang"fmt.Println(coursesSlice4Copy[0])fmt.Println(newCoursesSliceCopy[0])
}

切片在函数参数传递时是值传递还是引用传递

package mainimport ("fmt""strconv"
)func printSlice(data []string) {data[0] = "java"for i := 0; i < 10; i++ {data = append(data, strconv.Itoa(i))}
}func main() {/*go的slice在函数参数传递的时候是值传递还是引用传递?答案是值传递，但是效果呈现的是引用的效果（不完全是）这个代码呈现的结果是，如果是对当前slice进行值的修改，发现改成功了，但是想加数据却加不了，现象是改数据看起来是引用传递了，加数据反而是值传递的效果*/courses := []string{"go", "grpc", "gin"}printSlice(courses)fmt.Println(courses)
}

Go容器–map

package mainimport "fmt"func main() {/*map是一个key（索引）和value（值）的无序集合查询方便O(1)*/var coursesMap = map[string]string{"go":   "golang工程师","grpc": "grpc入门","gin":  "gin深入理解",}fmt.Println(coursesMap["grpc"])//放值coursesMap["mysql"] = "mysql原理"//var nullMap map[string]string //nil, map类型如果想设置值，必须要初始化//nullMap["mysql"] = "mysql原理"//fmt.Println(nullMap)//fmt.Println(coursesMap)var nullMap2 = map[string]string{}nullMap2["mysql"] = "mysql原理"fmt.Println(nullMap2)//使用make函数初始化，make是内置函数，主要用于初始化slice map channelvar nullMap3 = make(map[string]string, 3)nullMap3["mysql"] = "mysql原理"fmt.Println(nullMap3)/*map必须初始化采用使用, 初始化的方法1. map[string]string{}2. make(map[string]string, 3 )3. 但是slice可以不初始化*/var slirceTest []stringif slirceTest == nil {fmt.Println("slirceTest is nil")}slirceTest = append(slirceTest, "a")/**map的两种赋值方法：1. 初始化的赋值：var coursesMap = map[string]string{"go":   "golang工程师","grpc": "grpc入门","gin":  "gin深入理解",}2. 直接手动赋值:coursesMap["mysql"] = "mysql原理"*///遍历mapfmt.Println("-------------map的遍历---------------")for key, value := range coursesMap {fmt.Println(key, value)}fmt.Println("-------------map的遍历,只打印key---------------")for key := range coursesMap {fmt.Println(key, coursesMap[key])}//map是无序的，并且不保证每次打印是相同的数据fmt.Println("-------------map寻找key不存在的数据---------------")d := coursesMap["java"]fmt.Println(d)if _, ok := coursesMap["java"]; !ok {fmt.Println("not in")} else {fmt.Println("in")}//删除一个元素delete(coursesMap, "grpc")fmt.Println(coursesMap)delete(coursesMap, "rpc") //删除不存在的元素也不会报错//重要提示, map不是线程安全的
}

Go容器 – list（链表）

package mainimport ("container/list""fmt"
)func main() {var mylist = list.List{}mylist.PushBack("go")mylist.PushBack("grpc")mylist.PushBack("gin")fmt.Println(mylist)//遍历打印值,从头遍历for i := mylist.Front(); i != nil; i = i.Next() {fmt.Println(i.Value)}fmt.Println("----------反向遍历----------")//反向遍历for i := mylist.Back(); i != nil; i = i.Prev() {fmt.Println(i.Value)}fmt.Println("----------初始化list的方法----------")newList := list.New()newList.PushFront("mysql")for i := newList.Front(); i != nil; i = i.Next() {fmt.Println(i.Value)}//插入指定元素之前或者之后fmt.Println("----------插入指定元素之前或者之后----------")i := newList.Front()for ; i != nil; i = i.Next() {if i.Value.(string) == "mysql" {break}}newList.InsertBefore("oracle", i)for i := newList.Front(); i != nil; i = i.Next() {fmt.Println(i.Value)}//list删除fmt.Println("----------newList删除----------")newList.Remove(i)for i := newList.Front(); i != nil; i = i.Next() {fmt.Println(i.Value)}
}