前端开发后端小白的 Golang 学习记录,如有不对或者遗漏的地方欢迎大佬指出,不接受抬杠你说的都对 ~
Go的数据类型
Go中数据类型 大致分为两类 基本数据类型 和 派生数据类型/复杂数据类型
基本数据类型
整数类型
按位长度分度分为:8位,16位,32位,64位
对应有符号整数:int8,int16,int32,int64
对应无符号整数:uint8,uint16,uint32,uint64
每个类型都有对应的 占用存储空间
以及 表数取值范围
- 例如 有符号整数类型 int8,占用1字节存储空间,表数取值范围为(-128~127)
- 例如 无符号整数类型 uint8,占用1字节存储空间,表数取值范围为(0~255)
- 例如 其他整数类型 byte,等价于uint8
…
如果超出表述取值范围,则会溢出,抛出以下错误:
package main
import "fmt"
func main() {
var num uint8 = 280
fmt.Println(num)
}
# command-line-arguments
# cannot use 280 (untyped int constant) as uint8 value in variable declaration (overflows)
Go的整数类型 默认声明为
int
类型
package main
import "fmt"
func main() {
num := 18
fmt.Printf("num的类型是:%T", num)
// 输出: num的类型是: int
}
浮点类型
简单来说就是存放小数值的
-
浮点型数据分为
float32
(所占存储空间为4字节),以及float64
(所占存储空间为8字节) -
两种浮点型数据格式都遵循的是IEEE754标准,并且也同样拥有几乎所有编程语言都有的精度丢失问题(二进制浮点数精度丢失)其中
float32
更加容易出现精度丢失问题
如下所示:
package main
import "fmt"
func main() {
var num1 float32 = 3.141592653
fmt.Println("float32 :", num1)
var num2 float64 = 3.141592653
fmt.Println("float64 :", num2)
}
# float32 : 3.1415927
# float64 : 3.141592653
Go的浮点类型 默认声明为
float64
类型
package main
import "fmt"
func main() {
num := 3.14
fmt.Printf("num的类型是:%T", num)
// 输出: num的类型是: float64
}
布尔类型
布尔类型与JavaScript相同,都为
true
以及false
,但有一点是和JavaScript大大大不同的地方,Go中是不能将整型或是其他类型数据转换为布尔类型!
如下所示:
package main
import "fmt"
func main() {
// 整型强制转换验证
flagNum := 1
if flagNum {
fmt.Println("flagNum为true")
}
// 同样也无法与其他类型进行转换(string类型为例)
str := "string"
if str {
fmt.Println("str存在")
}
}
# command-line-arguments
# non-boolean condition in if statement
字符类型
注意:用 单引号
括起来的单个字符是字符类型,用 双引号
括起来的字符是字符串类型
Go的字符类型 默认声明为
rune
类型(rune类型也是兼容byte类型的~)
package main
import "fmt"
func main() {
a1 := 'A'
fmt.Printf("Unicode码 = %v 对应值 = %c 类型 = %T", a1, a1, a1)
// 输出:Unicode码 = 65 对应值 = A 类型 = int32
}
byte类型
byte类型是
uint8
别名,代表了ASCII
码的一个字符
输出字符时,是将该字符在ASCII
码表中对应的值进行输出,而且它也是可以直接参与运算, 如下所示:
package main
import "fmt"
func main() {
var c1 byte = 'a'
fmt.Println("c1 = ", c1)
var c2 byte = '8'
fmt.Println("c2 = ", c2)
var c3 byte = '~'
fmt.Println("c3 = ", c3)
var c4 byte = '>'
fmt.Println("c4 + 20 =", c4+20)
// 想显示对应的字符,必须采用格式化方式输出
var c5 byte = '~'
fmt.Printf("ASCII码 = %v 对应值 = %c 类型 = %T", c5, c5, c5)
}
# c1 = 97
# c2 = 56
# c3 = 126
# c4 + 20 = 82
# ASCII码 = 126 对应值 = ~ 类型 = uint8
rune类型
rune类型代表一个
UTF-8
字符,当需要处理中文、日文或者其他复合字符时,则需要用到 rune 类型(在内存中使用int
来表示,等价于int32
类型)
package main
import "fmt"
func main() {
var a1 rune = 'A'
fmt.Printf("Unicode码 = %v 对应值 = %c 类型 = %T", a1, a1, a1)
}
# Unicode码 = 65 对应值 = A 类型 = int32
字符串类型
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的,也就是说对于传统的字符串是由字符组成的,而 Go 的字符串不同,它是由字节组成的。
如下所示:
package main
import "fmt"
func main() {
str1 := "str1"
var str2 = "str2"
var str3 string = "str3"
fmt.Printf("值 = %v 类型 = %T\n", str1, str1)
fmt.Printf("值 = %v 类型 = %T\n", str2, str2)
fmt.Printf("值 = %v 类型 = %T\n", str3, str3)
}
# 值 = str1 类型 = string
# 值 = str2 类型 = string
# 值 = str3 类型 = string
多行字符串 与 JavaScript 相同,使用反引号,如下所示:
package main
import "fmt"
func main() {
str := `
测试第一行
测试第二行
测试第三行
balabala ...
`
fmt.Println(str)
}
# 测试第一行
# 测试第二行
# 测试第三行
# balabala ...
字符串常用操作
注意:strings 是需要引入strings包
方法 | 介绍 |
---|---|
len(str) | 求长度 |
+ 或 fmt.Sprintf | 拼接字符串 |
strings.Split | 分割 |
strings.Contains | 判断是否包含 |
strings.HasPrefix / strings.HasSuffix | 前缀/后缀 判断 |
strings.Index / strings.LastIndex | 字符串出现位置 |
strings.Join(a[]string,sep string) | join操作 |
len(str) 求长度
注意 : 在UTF-8编码下汉字占用3个字节(包括中文输入法状态下的标点符号)
str1 := "你好,"
str2 := "Golang"
fmt.Println("str1 = ", len(str1)) // str1 = 9
fmt.Println("str2 = ", len(str2)) // str2 = 6
+ 或 fmt.Sprintf 拼接字符串
str1 := "你好"
str2 := "Golang"
fmt.Println(str1 + " : " + str2) // 你好 : Golang
str3 := fmt.Sprintf("%v %v", str1, str2)
fmt.Println(str3) // 你好 Golang
strings.Split 分割
分割后输出的为切片,并不是和JavaScript一样输出数组,在Go中 切片 和 数组 还是有区别的 ~
package main
import (
"fmt"
"strings"
)
func main() {
str := "Golang-JavaScript-balabala"
arr := strings.Split(str, "-")
fmt.Println(arr)
// [Golang JavaScript balabala]
}
strings.Join 切片链接为字符串
package main
import (
"fmt"
"strings"
)
func main() {
str1 := "Golang-JavaScript-balabala"
arr := strings.Split(str1, "-")
fmt.Println(arr) // [Golang JavaScript balabala]
str2 := strings.Join(arr, "~")
fmt.Println(str2) // Golang~JavaScript~balabala
}
strings.Contains 判断是否包含
package main
import (
"fmt"
"strings"
)
func main() {
str1 := "The Reason the song comes from beef"
flag := strings.Contains(str1, "song")
fmt.Println(flag) // true
}
strings.HasPrefix / strings.HasSuffix 前缀/后缀
package main
import (
"fmt"
"strings"
)
func main() {
str1 := "The Reason the song comes from beef"
flag1 := strings.HasPrefix(str1, "The")
flag2 := strings.HasSuffix(str1, "The")
fmt.Println("flag1 = ", flag1) // flag1 = true
fmt.Println("flag2 = ", flag2) // flag2 = false
}
strings.Index / strings.LastIndex 字符串出现位置
查找不到返回 -1 ,查找到返回下标位置
package main
import (
"fmt"
"strings"
)
func main() {
str1 := "The Reason the song comes from beef"
str2 := strings.Index(str1, "s")
str3 := strings.LastIndex(str1, "s")
fmt.Println("str2 = ", str2) // str2 = 7
fmt.Println("str3 = ", str3) // str3 = 24
}
转义字符
转义符 | 含义 |
---|---|
\b | 退格 |
\n | 换行 |
\r | 回车 |
\t | tab |
\ " | 双引号 |
\ ’ | 单引号 |
\\ | 反斜杠 |
Go 的运算符
自增与自减
注意:
++
(自增)和--
(自减) 在Go中是单独的语句,并不属于运算符
在Go中,++
和 --
和 JavaScript 有一点不同,不存在 前++ 和 前-- 的情况,如下所示会抛出以下错误:
package main
import (
"fmt"
)
func main() {
num := 10
++num
fmt.Println(num)
}
# command-line-arguments
# syntax error: unexpected ++, expected }
那么当不存在 前++ 和 前-- 的情况时,就不会出现先参与运算和后参与运算的问题,++
和 --
后就直接输出值
package main
import (
"fmt"
)
func main() {
num1 := 10
num2 := 20
num1++
num2--
fmt.Println(num1) // 11
fmt.Println(num2) // 19
}
算数运算符
+
相加-
相减*
相乘/
相除%
取余 余数 = 被除数 - (被除数/除数) * 除数
package main
import (
"fmt"
)
func main() {
num1 := 10
num2 := 20
fmt.Println("相加 = ", num1+num2)
fmt.Println("相减 = ", num1-num2)
fmt.Println("相乘 = ", num1*num2)
fmt.Println("取余 = ", num1%num2)
}
# 相加 = 30
# 相减 = -10
# 相乘 = 200
# 取余 = 1
相除注意: 相除比较特殊,如果运算的数都是整数,那么相除后,结果会去除小数部分,只保留整数部分
package main
import (
"fmt"
)
func main() {
num1 := 10
num2 := 3
fmt.Println("整数相除 = ", num1/num2)
num3 := 10.0
num4 := 3.0
fmt.Println("浮点数相除 = ", num3/num4)
}
# 整数相除 = 3
# 浮点数相除 = 3.3333333333333335
赋值运算符
基本和 JavaScript 相同 除法的不同已在算术运算符中举例 此处就不再过多赘述 ~
=
赋值运算符 将一个表达式的值赋值给一个左值+=
相加后再赋值-+
相减后再赋值*=
相乘后再赋值/=
相除后再赋值%=
取余后再赋值
关系运算符
基本和 JavaScript 相同 返回布尔类型 ~
==
检查两个值是否相等!=
检查两个值是否不相等>
检查左边值是否大于右边值>=
检查左边值是否大于等于右边值<
检查左边值是否小于右边值<=
检查左边值是否小于等于右边值
逻辑运算符
基本和 JavaScript 相同 ~
&&
为逻辑且,代表同时需要满足运算符前后的两个条件则为正确||
为逻辑或,代表运算符前后满足其中一个条件则为正确!
为逻辑非,代表最终结果为运算符不同的条件则为正确
package main
import "fmt"
func main() {
age := 18
flag := true
fmt.Println("&& ", age < 20 && age > 10)
fmt.Println("|| ", age > 20 || age < 10)
fmt.Println("! ", !flag)
}
# && true
# || false
# ! false