Golang入门指南 - Go的数据类型/Go的运算符

最新推荐文章于 2024-04-08 10:34:56 发布

羊乐多多多多

最新推荐文章于 2024-04-08 10:34:56 发布

阅读量183

点赞数

分类专栏： golang 文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/Y_9906/article/details/132686619

版权

golang 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

前端开发后端小白的 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)
}