Golang学习历程【第三篇 基本数据类型类型转换】

news/2024/12/22 20:46:59 标签: golang, 学习, 开发语言

Golang学习历程【第三篇 基本数据类型】

  • 1. 总览
  • 2. 基本数据类型
    • 2.1 整型
    • 2.2 浮点型
    • 2.2 布尔型
    • 2.3 字符
    • 2.4 字符串
      • 2.4.1 常用定义方式
      • 2.4.2 转移字符
      • 2.4.3 常用方法
      • 2.4.3 字符串中字符替换
  • 3. 类型转换
    • 3.1 整型与整型转化
    • 3.2 浮点数与整型转换
    • 3.3 其他类型与string类型转换
    • 3.4 strconv 字符串类型转换工具
      • 3.4.1 strconv.Atoi(字符串转int) 和 strconv.Itoa(int转字符串)
      • 3.4.2 strconv.Parse 字符串解析为其他类型
      • 3.4.3 strconv.Format 数字格式化为string
      • 3.4.4 其他方法

1. 总览

Go语言中数据类型分为：基本数据类型和复合数据类型

基本数据类型：整型，浮点型，布尔型，字符串
复合数据类型：数组，切片，结构体，函数，map，通道（channel）、接口等

2. 基本数据类型

2.1 整型

类型范围占用空间有无符号
int8 − 2 7 -2^7 −27~ 2 7 − 1 2^7-1 27−11个字节有
int16 − 2 15 -2^{15} −215~ 2 15 − 1 2^{15}-1 215−12个字节有
int32 − 2 31 -2^{31} −231~ 2 31 − 1 2^{31}-1 231−14个字节有
int64 − 2 63 -2^{63} −263~ 2 63 − 1 2^{63}-1 263−18个字节有
uint8 0 0 0~ 2 8 − 1 2^8-1 28−11个字节无
uint16 0 0 0~ 2 16 − 1 2^{16}-1 216−12个字节无
uint32 0 0 0~ 2 32 − 1 2^{32}-1 232−14个字节无
uint64 0 0 0~ 2 64 − 1 2^{64}-1 264−18个字节无

特殊类型：

类型描述
uint32位操作系统上为uint32,64位操作系统上为uint64
int32位操作系统上为int32,64位操作系统上为int64
uintptr无符号整型，用于存放一个指针
简单示例：
var (
	num1 int  = 666
	num2 uint = 666
	// 以下赋值可选最大值，math 为math包，使用即自动引入
	num1 int  = 666
	num2 uint = 666
	// 以下赋值可选最大值
	num3  int8   = math.MaxInt8
	num4  int16  = math.MaxInt16
	num5  int32  = math.MaxInt32
	num6  int64  = math.MaxInt64
	num7  uint8  = math.MaxUint8
	num8  uint16 = math.MaxUint16
	num9  uint32 = math.MaxUint32
	num10 uint64 = math.MaxUint64
)
fmt.Println(num1, num2, num3, num4, num5, num6, num7, num8, num9, num10)

结果：

666 666 127 32767 2147483647 9223372036854775807 255 65535 4294967295 18446744073709551615

2.2 浮点型

Go语言支持两种浮点数：float32和float64，遵循IEEE 745标准。32位操作系统中，默认为float32；64位操作系统中默认为float64。

  • float32：-3.4e38~3.4e38 ，占用4个字节
  • float64：-1.8e308~1.8e308，占用8个字节
// 1. 基本定义
var num1 float32 = 1.06
num2 := 3.1415926
// 保留小数据，可以使用%.nf或者%0.nf 指定保留n位小数，
fmt.Printf("原样输出：%v; 默认保留6位小数: %f; 指定保留3为小数: %0.3f \n", num1, num2, num2)
// 2. 其他常用样例
var (
	num3 float32 = 3.1415926
	num4 float64 = 1.113
	num5         = 3.14e2  // 使用科学计数法表示，3.14*10^2 的值：为314
	num6         = 3.14e-2 // 使用科学计数法表示，3.14*10-2 的值：为0.0314
)
fmt.Println(num3, num4, num5, num6)

结果：

原样输出：1.06; 默认保留6位小数: 3.141593; 指定保留3为小数: 3.142 
3.1415925 1.113 314 0.0314

2.2 布尔型

bool值仅有两个值：true和false。声明不赋值，默认为false

var (
	bool1 bool
	bool2 = true
)
fmt.Println(bool1, bool2)

结果：

false true

2.3 字符

字符是单个数值，属于int类型，Go语言中有两种表示：byte和rune

  • byte: int类型，代表ASCII码的值
  • rune: int类型，代表UTF-8编码

注：UTF-8的国际通用编码，是ASCII码的扩展，包括了各国的常用的语言文字</font
常用示例：

var a = 'A'
var a = 'A'
// 使用%c输出字符
fmt.Printf("字符ASCII值:%v; 原样编码:%c \n", a, a)
var (
	b = 'B'
	c = '你'
	d = "this" // 可以获取字符串中的单个字符
)
fmt.Printf("%c,%c,%c,%c,%c,%c", b, c, d[0], d[1], d[2], d[3])

结果：

字符ASCII值:65; 原样编码:A 
B,你,t,h,i,s

2.4 字符串

2.4.1 常用定义方式

// 字符串定义
var val1 string = "hello world"
var val2 = "你好 go"
val3 := "Good"
fmt.Println(val1, val2, val3)
// 字符串val2中2个中文，3个英文(空格也算)；共2*3+3=9个字符，可通过len函数获取
fmt.Println(len(val2))
// 多行字符串：会原样输出
var info = `姓名：张三
年龄：18`
fmt.Println(info)

结果：

hello world 你好 go Good
9
姓名：张三
        年龄：18

字符串中，英文字母占一个字节，中文占用3个字节。可使用len函数打印字符串字节长度

2.4.2 转移字符

转义符号使用\表示
常用的转义字符有：

  1. \r：回车符（返回行首）
  2. \n：换行符（跳至下一行同列）
  3. \t：制表符（可用于整齐输出一系列值）
  4. \'：单引号，输出'
  5. \"：双引号，输出"
  6. \\：反斜杠，输出\
var val1 string = "hello\r"
var val2 string = "world\n"
var val3 string = "hello world\t"
var val4 string = "'hello' \\ \"world\""
/*
	var1：\r 回车符，hello输出结束后回车，光标移动至当前行首，意味着清空hello值
	val2: \n 换行符，world输出之后换行
	val3: \t 制表符，hello world简易理解为一个大的空格，格式美观，自带对齐
	val4: Go语言中'可以直接写在"内部，\\输出\, \" 转义字符，输出"
*/
fmt.Println(val1, val2, val3, val4)

结果：

 world
 hello world     'hello' \ "world"

2.4.3 常用方法

方法名基本上为常用英文名缩写，各语言基本通用，使用多了自然熟记

方法描述
len获取字符串长度
+或fmt.Springf拼接字符串
strings.Split拆分字符串
strings.Contains获取字符串长度
strings.HasPrefix,strings.HasSuffix获取字符串长度
strings.Index,strings.LastIndex获取字符串长度
strings.Join获取字符串长度
strings.ToLower字符串全转小写
strings.ToUpper字符串全转大写
示例：
var val = "Hello World"
// 1. len求长度
length := len(val)
fmt.Printf("%s长度: %d\n", val, length)

// 2. + 拼接字符串，Sprint中S代表返回字符串，同理含有：Sprinf、Sprinln，与Prinf、Prinln类似，区别在于S开头函数代表返回字符串，可用变量接收
str1 := val + "小明"
str2 := fmt.Sprint(val, "小红")
fmt.Printf("+拼接：%s;\tSprint函数拼接: %s \n", str1, str2)

// 3. 字符串拆分结果为：切片（类似于数组）；参数为(<原字符串>, <切片字符串>)，示例中将Hello World以空格拆分为Hello和World
splitVal := strings.Split(val, " ") // 切片结果为[Hello World]
// 4. Join将切片拼接成新的字符串；参数为(<原字符串>, <连接符>)
newStr := strings.Join(splitVal, ",") //
fmt.Printf("切片值：%v;\tJoin连接成新的字符串: %s \n", splitVal, newStr)

// 5.字符串是否包含子串，Contains参数为(<原字符串>,<子串>)
bool1 := strings.Contains(val, "Hello")
bool2 := strings.Contains(val, "Hello")
fmt.Printf("是否包含Hello：%v;\t是否包含olleH: %v \n", bool1, bool2)

// 6. 前缀判断：HasPrefix ,参数为(<原字符串>,<子串>); 后缀判断：HasSuffix，参数(<原字符串>,<子串>)
bool3 := strings.HasPrefix(val, "He")
bool4 := strings.HasPrefix(val, "llo")
bool5 := strings.HasSuffix(val, "World")
bool6 := strings.HasSuffix(val, "Wor")
fmt.Printf("前缀包含He：%v;\t前缀包含llo: %v\t后缀包含World：%v;\t后缀包含Wor: %v \n", bool3, bool4, bool5, bool6)

// 7. 返回子串在原字符串首次出现的位置，Index，从前向后查找；LastIndex，从后向前查找，参数都为(<原字符串>,<子串>)。结果：查询到，返回下标值，查询不到，返回-1。注：下标从0开始
index1 := strings.Index(val, "o")
index2 := strings.LastIndex(val, "o")
index3 := strings.Index(val, "a")
fmt.Printf("o从前到后查询在第%v位;\to从后到前查询在第%v位\ta从前到后查询在第%v位\n", index1, index2, index3)
// 8. strings.ToLower和strings.ToUpper
str3 := strings.ToLower(val)
str4 := strings.ToUpper(val)
fmt.Printf("全小写： %v;\t全大写：%v\n", str3, str4)

运行结果

Hello World长度: 11
+拼接：Hello World小明; Sprint函数拼接: Hello World小红
切片值：[Hello World];  Join连接成新的字符串: Hello,World
是否包含Hello：true;    是否包含olleH: true
前缀包含He：true;       前缀包含llo: false      后缀包含World：true;    后缀包含Wor: false 
o从前到后查询在第4位;   o从后到前查询在第7位    a从前到后查询在第-1位
全小写hello world;      全大写HELLO WORLD

温馨提示：这里的len、split、contains、prefix、suffix、index、join、lower、upper等所表示的含义在各个编程语言大同小异，只要通一门语言，其他也就简单了

2.4.3 字符串中字符替换

	// 字符串中替换字符
	var val1 = "hello xioaming"
	byteStr := []byte(val1) // 英文字符 转成byte数组类型即可，然后替换值
	byteStr[0] = 'a'
	fmt.Println(string(byteStr)) // string(byteStr)为将数组转成字符串返回，fmt.Println再打印输出结果
	var val2 = "你好小明"
	runeStr := []rune(val2) // 包含中文字符 需要转成rune数组类型即可，然后替换值
	runeStr[0] = '我'
	fmt.Println(string(runeStr))

结果：

aello xioaming
我好小明

3. 类型转换

数字类型装换有两种：低精度转高精度，高精度转低精度
注：高精度转低精度，慎用，由于类型表示范围不同，可能造成精度丢失

3.1 整型与整型转化

示例：

// 进度转换可通过 int8(<整型>),int16(<整型>),int32(<整型>),int64(<整型>)转换
// 1. 低精度转高精度
var a int8 = 127
b := int64(a)
fmt.Printf("a=%v,类型：%T\tb=%v,类型：%T \n", a, a, b, b)
// 2. 高精度转低精度
var c int64 = 127
d := int16(c)
fmt.Printf("a=%v,类型：%T\tb=%v,类型：%T \n", c, c, d, d)

结果：

a=127,类型：int8        b=127,类型：int64 
a=127,类型：int64       b=127,类型：int16

3.2 浮点数与整型转换

示例：

// 3. 整型转浮点型，可通过 float32(<整型>),float64(<整型>)，浮点数转浮点数据也可以这样操作
var e int16 = 256
f := float32(e)
fmt.Printf("a=%v,类型：%T\tb=%v,类型：%T \n", e, e, f, f)
// 4. 浮点型转整型
var g float64 = 3.145
h := int16(g) // 注：类型会丢失，不是四舍五入，直接截取整数部分
fmt.Printf("a=%v,类型：%T\tb=%v,类型：%T \n", g, g, h, h)

结果：

a=256,类型：int16       b=256,类型：float32 
a=3.145,类型：float64   b=3,类型：int16

3.3 其他类型与string类型转换

var (
	intV   = 123
	folatV = 3.145
	boolV  = true
	charV  = 'A'
)
// 1. 通过 fmt.Sprintf进行转换
str1 := fmt.Sprintf("%d", intV)   // 转换int
str2 := fmt.Sprintf("%f", folatV) // 转换float
str3 := fmt.Sprintf("%t", boolV)  // 转换 bool
str4 := fmt.Sprintf("%c", charV)  // 转换 字符
fmt.Println(str1, str2, str3, str4)

结果：

123 3.145000 true A

3.4 strconv 字符串类型转换工具

3.4.1 strconv.Atoi(字符串转int) 和 strconv.Itoa(int转字符串)

简单记忆：i(int) ，itoa中i在首字母，表示int转string。atoi中i在末尾，表示string转int

var str = "123"
// 1. 将string转换为int类型，strconv.Atoi(<string>)， 返回类型有两个：<转换数据,异常err>
num1, _ := strconv.Atoi(str)
fmt.Printf("转化值：%v\t类型：%T\n", num1, num1)
// 2. 将int类型转换为string, strconv.Itoa(<int>),类型必须int，返回类型有一个：<string>
var num2 int64 = 456
str2 := strconv.Itoa(int(num2))
fmt.Printf("转化值：%v\t类型：%T\n", str2, str2)

结果：

转化值：123     类型：int
转化值：456     类型：string

3.4.2 strconv.Parse 字符串解析为其他类型

strconv.Parse能将将字符串解析为指定类型，前提：允许转换

var (
	str1 = "256"
	str2 = "3.145"
	str3 = "true"
)
// 以下的bitSize参数感觉意义不大，返回值有特定的返回类型
/*
	1. ParseInt
		params
			参数1: string数据
			参数2：base 指定进制，取值范围是 2 到 36。如果 base 为 0
			参数3：bitSize 指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64
		return
			int64: 返回始终为int64数值
			err: 转换失败后返回的失败信息
*/
num1, _ := strconv.ParseInt(str1, 10, 0)
fmt.Printf("转化值：%v\t类型：%T\n", num1, num1)
/*
	2. ParseFloat
		params
			参数1: string数据
			参数2：bitSize 指定了返回值的类型，32 表示 float32，64 表示 float64；
		return
			float64: 返回始终为float64数值
			err: 转换失败后返回的失败信息
*/
num2, _ := strconv.ParseFloat(str2, 32)
fmt.Printf("转化值：%0.3f\t类型：%T\n", num2, num2)
/*
	3. ParseBool
		params
			参数1: string数据
		return
			bool: 返回始终为bool数值
			err: 转换失败后返回的失败信息
*/
boo, _ := strconv.ParseBool(str3)
fmt.Printf("转化值：%v\t类型：%T\n", boo, boo)

结果：

转化值：256     类型：int64
转化值：3.145   类型：float64
转化值：true    类型：bool

3.4.3 strconv.Format 数字格式化为string

var (
	intV   = 123
	floatV = 3.145e2
	booV   = true
)
// 以下的bitSize参数感觉意义不大，返回值有特定的返回类型
/*
	1. FormatInt
		params
			参数1: int64数据
			参数2：base 指定进制，取值范围是 2 到 36。如果 base 为 0
		return
			string: 返回始终为string数值
*/
str1 := strconv.FormatInt(int64(intV), 10)
fmt.Printf("转化值：%v\t类型：%T\n", str1, str1)
/*
	2. FormatFloat
		params
			参数1: float64数据
			参数2：格式化类型
					 'b' (-ddddp±ddd, 二进制指数),
					 'e' (-d.dddde±dd, 十进制e指数),
					 'E' (-d.ddddE±dd, 十进制E指数),
					 'f' (-ddd.dddd, 无指数),
					 'g' ('e'表示大指数，'f'表示其他指数),
					 'G' ('E'表示大指数，'F'表示其他指数),
					 'x' (-0xd.ddddp±ddd, 十六进制分数和二进制指数 小写),
					 'X' (-0Xd.ddddP±ddd, 十六进制分数和二进制指数 大写).
			参数3：保留的小数点位数，四舍五入。-1代表不对小数点格式化处理
			参数4：bitSize 指定了返回值的类型，32 表示 float32，64 表示 float64；
		return
			string: 返回始终为string数值
*/
str2 := strconv.FormatFloat(floatV, 'f', -1, 64)
fmt.Printf("转化值：%v\t类型：%T\n", str2, str2)
/*
	3. FormatFloat
		params
			参数1: bool数据
		return
			string: 返回始终为string数值
*/
str3 := strconv.FormatBool(booV)
fmt.Printf("转化值：%v\t类型：%T\n", str3, str3)

结果：

转化值：123     类型：string
转化值：314.5   类型：string
转化值：true    类型：string

3.4.4 其他方法

其他还包含strconv.Append(字符换追加)、strconv.IsPrint（是否可打印） 和 strconv.IsGraphic（是否图形字符）、strconv.Quote（字符串转义） 和 strconv.Unquote（取出转义）、strconv.CanBackquote（判断是否可以表示为单行反引号字符串）等。
这里学习到这，不做详细示例分析，有印象即可，需要时再学习；可参考链接

上一篇：Golang学习历程【第二篇 fmt包&变量、常量的定义】
下一篇：Golang学习历程【第四篇 运算符&流程控制】


http://www.niftyadmin.cn/n/5795844.html

相关文章

亚马逊API接口深度解析：如何高效获取商品详情与评论数据

亚马逊API接口深度解析：如何高效获取商品详情与评论数据

在当今数字化时代&#xff0c;电商平台的数据对于商家和开发者来说至关重要。亚马逊作为全球领先的电商平台&#xff0c;其API接口为开发者提供了丰富的商品信息和评论数据。本文将深入探讨如何使用亚马逊API接口获取商品详情和商品评论&#xff0c;同时提供简洁明了的使用方法…
阅读更多...
代码随想录算法训练营第十一天-239.滑动窗口最大值

代码随想录算法训练营第十一天-239.滑动窗口最大值

解题思想与代码实现&#xff0c;令人叹为观止队列的最佳应用从总体上讲&#xff0c;完成代码的思路是非常清晰的 根据窗口大小&#xff0c;从源数据第一个开始&#xff0c;把数据依次压入队列中从压入队列的数据中找出最大值&#xff0c;放入结果集合中再将队列中第一个元素弹出…
阅读更多...
保姆级教程Docker部署RabbitMQ镜像

保姆级教程Docker部署RabbitMQ镜像

目录 1、创建挂载目录 2、运行RabbitMQ容器 3、Compose运行RabbitMQ容器 4、开启界面插件 5、查看RabbitMQ运行状态 6、常见问题处理 1、创建挂载目录 # 创建宿主机rabbitMQ挂载目录 sudo mkdir -p /data/docker/rabbitmq/log# 修改log目录权限 sudo chmod 777 /data/do…
阅读更多...
HTML 新手易犯的标签属性设置错误

HTML 新手易犯的标签属性设置错误

滥用target"_blank"属性&#xff1a;将所有链接的目标设为_blank会在新标签页中打开链接&#xff0c;这可能会导致用户在不知情的情况下打开大量新标签页&#xff0c;影响用户体验。正确的做法是只在需要新标签页打开的链接上使用该属性&#xff0c;并在标签中添加适…
阅读更多...
在UE5中调用ImGui图形界面库

在UE5中调用ImGui图形界面库

ImGui是一个小巧灵活、简洁美观的图形界面库 首先我们直接参考Github https://github.com/SLSNe/Unreal5-ImGui 把项目下载下来后 打开项目目录或者引擎目录 项目根目录/Plugins/ImGui/ 或 UE5引擎根目录/Engine/Plugins/ 如果没有Plugins文件夹就新建一个 把项目放里面…
阅读更多...
CentOS 7 安装、测试和部署FastDFS

CentOS 7 安装、测试和部署FastDFS

目录 FastDFS环境搭建 安装 libfastcommon 库 安装FastDFS 查看编译后的文件 FastDFS配置 FastDFS启动 启动tracker服务 启动storage服务 查看storage是否已经注册到了tracker下 查看存储文件的目录 FastDFS重启 FastDFS关闭 使用fdfs_test进行测试 修改client.co…
阅读更多...
MongoDB 介绍及 Java 实现基本操作

MongoDB 介绍及 Java 实现基本操作

MongoDB 介绍及 Java 实现基本操作 一、MongoDB 简介二、Java 操作 MongoDB 的基本步骤1. 环境准备2. 基本操作示例 三、代码解析1. 连接 MongoDB&#xff1a;通过 MongoClients.create(uri) 创建客户端连接&#xff0c;uri 指定 MongoDB 服务地址。2. 获取数据库和集合&#x…
阅读更多...
c语言进程直接的管道

c语言进程直接的管道

无名管道 #include<myhead.h> int main(int argc, const char *argv[]) {int pipfd[2];char buff[1024]"hello world";char s[1024];//创建无名管道if(pipe(pipfd)-1){perror("pipe");return -1;}int pidfork();if(pid-1){perror("fork"…
阅读更多...
最新文章

Copyright @ 2022~2023