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 main

import (
	"fmt"
	"strconv"
)

// 类型转换
func main() {

	var a int8 = 12
	var b = uint8(a)

	var f float32 = 3.14
	var c = int32(f)

	fmt.Println(b, c)

	var f64 = float64(a)
	fmt.Println(f64)

	type IT int //类型要求很严格
	var d IT = 13
	fmt.Println(d)

	//字符串转数字
	var istr = "12a"
	//字符串转数字的方法，返回转换的值和error
	mint, 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, 转换为bool
	fl, 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)

	//字符串转为bool
	parseBool, 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 main

import "fmt"

func main() {
	// 运算符 + - * / % ++ --
	var a, b = 1, 2
	fmt.Println(a + b) //3

	var astr, bstr = "hello", "zed"
	fmt.Println(astr + bstr) //hellozed

	//取余
	fmt.Println(3 % 2) //1
	a++
	fmt.Println(a) //2

	//逻辑运算符
	var abool, bbool = true, false
	fmt.Println(abool && bbool) //false
	fmt.Println(abool || bbool) //true
	fmt.Println(!abool)         //false

	//位运算符
	var A = 60
	var B = 13
	fmt.Println(A & B) // 12
}

字符串

格式化输出

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {

	//转义符
	courseName := "go\"体系课\""
	fmt.Println(courseName)

	//格式化输出
	username := "bobby"
	out := "hello" + username //简单组装输出
	fmt.Println(out)

	age := 18
	address := "北京"
	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.Builder
	builder.WriteString("用户名: ")
	builder.WriteString(username)
	builder.WriteString(", 年龄: ")
	builder.WriteString(strconv.Itoa(age))
	builder.WriteString(", 地址: ")
	builder.WriteString(address)

	re := builder.String()
	fmt.Println(re)
}

字符串的比较

package main

import "fmt"

func main() {

	//字符串的比较
	a := "hello"
	b := "hello"
	fmt.Println(a == b) // true

	//字符串的大小比较
	c := "bello"
	fmt.Println(a > c) //true，比较asic码的大小
}

字符串的操作方法

package main

import (
	"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")) //true
	fmt.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 main

import "fmt"

/* if bool表达式 {
	逻辑
}
*/

func main() {
	//条件判断
	age := 22
	country := "中国"
	if age < 18 && country == "中国" {
		fmt.Println("未成年人")
	} else if age == 18 {
		fmt.Println("刚好是成年人")
	} else {
		fmt.Println("成年人")
	}

}

for循环

package main

import "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 main

import "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 main

import "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 := 95
	switch {
	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 main

import "fmt"

func main() {

	/*
			go语言提供了哪些集合类型的数据结构
		    1、数组
			2、切片（slice）
			3、map
			4、list
	*/

	// 数组 定义: var name [count]int
	var 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)

	//对数组进行遍历,index
	for _, value := range courses1 {
		fmt.Println(value)
	}
}

Go–Slice切片

package main

import "fmt"

func main() {

	//go折中
	var courses []string
	fmt.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函数重新生成slice
	coursesSlice4 := []string{"go", "Java", "Python", "MySQL"}
	newSlice := append(coursesSlice4[:2], coursesSlice4[3:]...)
	fmt.Println(newSlice)

	//复制slice
	coursesSlice4Copy := coursesSlice4
	coursesSlice4Copy2 := 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 main

import (
	"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 main

import "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 channel
	var 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 []string
	if 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原理"
	*/

	//遍历map
	fmt.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 main

import (
	"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)
	}
}