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)
}
}
![[MySQL] SQL优化之性能分析](https://img-blog.csdnimg.cn/direct/3fbe5fe455e24a7fb4fd491ca3752b33.png)
