亲宝软件园·资讯

展开

go语言系列-从零到数据类型的基本介绍

紫色飞猪 人气:0
视频资源:b站UP主v若水若水的尚硅谷go视频 不动笔墨不读书 ,虽然我有全套视频和笔记 还是自己动点笔墨 因为在19年下半年大致学过go语言 所以这么计划:一个星期拿下基础 一个星期拿下框架 两个星期拿出项目 一个月搞定go ### Go环境安装 版本选择 ```go >go version go version go1.13.5 windows/amd64 ``` SDK:软件开发工具包。是提供给开发人员使用的,其中包含了对应开发语言的工具包 Go SDK下载地址:https://www.golangtc.comhttps://img.qb5200.com/download-x/download ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215156619-888941478.png) src:go的源代码 bin: go的指令 ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215210724-1829376336.png) Go开发需要配置的环境变量 - GOROOT:指定SDK的安装 路径E:\GO - PATH:添加SDK的/bin目录 E:\GO\go\bin - GOPATH:工作目录,捡来go项目的工作路径 E:\gostudent IDE: 选择goland https://www.cnblogs.com/zisefeizhu/p/11178668.htm ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215223948-867008517.png) ### Go官方编程指南 Go 设计思想:一个问题尽量只有一个解决方法 Golang 官方网站 国内要使用特殊手段 https://golang.org 进入后第一个页面,点击 tour-> 选择 简体中文就可以进入中文版的 Go 编程指南 Golang 官方标准库 API 文档,https://golang.org/pkg可以查看 Golang所有包下的函数和使用 api : application program interface:应用程序编程接口。 就是我们 Go 的各个包的各个函数。 API是Golang提供的基本编程接口 Go语言提供了大量的标准库,因此Google公司也为这些标准库提供了相应的API文档,用于告诉开发者如何使用这些标准库,以及标准库包含的方法 Go中文网 在线标准库文档:https://studygolang.com/pkgdoc ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215248509-11719667.png) Go的包和源文件和函数的关系简图 ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215259360-1334068962.png) ### 标识符的命名规范 ```go Go对各种变量、方法、函数等命名时使用的字符序列称为标识符 凡是自己可以起名字的地方都叫标识符 由26个英文字母大小写,0-9,_组成 数字不可以开头。var num int // √ var 3num int//× Go中严格区分大小写 var num int var Num int 说明:在Go中,num和Num是两个不同的变量 标识符不能包含空格 下划线”_”本身在Go中是一个特殊的标识符,称为空标识符。可以代表任何其它的标识符,但是它对应的值会被忽略(比如:忽略某个返回值)。所以仅能被作为占位符使用,不能作为标识符使用 不能以系统保留关键字作为标识符(一共有25个),比如break,if 等等... 包名:保持package的名字和目录保持一致,尽量采取有意义的包名,简短,有意义,不要和标准库冲突 变量名、函数名、常量名:采用驼峰法 如果变量名、函数名、常量名首字母大写,则可以被其他的包访问:如果首字母小写,则只能在本包中使用(注:可以简单的理解成,首字母大写是公开的,首字母小写是私有的),在Go语言中没有public,private等关键字。 ``` | 对 | 错 | | ------------------------------------------------------------ | --------------------- | | hello hello12 h_4 _ab int【建议不要使用】 float32【建议不要使用】 Abc | 1hello h-b ‘x h’ _ | ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215316926-786910981.png) ### 系统保留关键字 在Go中,为了简化代码编译过程中对代码的解析,其定义的保留关键字只有25个 ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215328370-728684811.png) ### 系统的预定义标识符 除了保留关键字外,Go还提供了36个预定义的标识符,其包括基本数据类型和系统内嵌函数 ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215341425-1521996773.png) ### Go语言快速开发入门 **hello.go** ```go //开发一个hello.go程序,可以输出 "hello, 紫色飞猪" package main import ( "fmt" _"log" ) func main() { fmt.Println("hello, zisefeizhu") } 1) go文件的后缀是.go 2) package main 表示该hello.go文件所在的包是main。再go中,每个文件都必须归属于一个包 3) import "fmt" 表示:引入一个包,包名fmt,引入该包后,就可以使用fmt包的函数,比如:fmt.Println fmt包中提供格式化、输出、输入的函数 4)_"log" go语言定义的变量或者import的包如果没有使用到,就用_注释掉。 4) func main() { //func是关键字,表示一个函数 //main是函数名,是一个主函数,程序的入口 fmt.Println("hello,zisefeizhu") //表示调用fmt包的函数 Println输出“hello, zisefeizhu” } 5) go语言严格区分大小写。 6) go编译器是按行进行编译的,一行写一条语句,每条语句不需要分号(go讨语言会在每行后自动加分号),不能把多行语句写在同一行 7) go语言大括号成对出现。 ``` **Go执行流程分析 go run / go build** ```go E:\gostudent>dir //项目目录 E:\gostudent 的目录 2020/04/01 15:16 . 2020/04/01 15:16 .. 2020/04/01 15:33 .idea 2020/04/01 15:33 2020-04-01 //今日目录 E:\gostudent>cd 2020-04-01 E:\gostudent\2020-04-01>dir E:\gostudent\2020-04-01 的目录 2020/04/01 15:33 . 2020/04/01 15:33 .. 2020/04/01 15:33 151 hello.go //hello.go文件 E:\gostudent\2020-04-01>go run hello.go hello, zisefeizhu //编译运行一步完成 E:\gostudent\2020-04-01>dir E:\gostudent\2020-04-01 的目录 2020/04/01 15:33 . 2020/04/01 15:33 .. 2020/04/01 15:33 151 hello.go 1 个文件 151 字节 2 个目录 121,884,221,440 可用字节 //没有生成二进制文件 E:\gostudent\2020-04-01>go build hello.go E:\gostudent\2020-04-01>dir 驱动器 E 中的卷是 娱乐 卷的序列号是 78AB-12F2 E:\gostudent\2020-04-01 的目录 2020/04/01 15:49 . 2020/04/01 15:49 .. 2020/04/01 15:49 2,106,368 hello.exe //二进制文件 2020/04/01 15:33 151 hello.go E:\gostudent\2020-04-01>hello.exe //直接执行 hello, zisefeizhu 1)如果先编译生成了可执行文件,那么可以将该可执行文件拷贝到没有go开发环境的机器上,仍然可以运行 2)如果是直接go run 源代码,那么如果要在另外一个机器上这么运行,也需要go开发环境,否则无法执行 3)在编译时,编译器会将程序运行依赖的库文件包含在可执行文件中,所以,可执行文件变大了很多 go build 可以指定生成的可执行文件名 E:\gostudent\2020-04-01>go build -o zisefeizhu.exe hello.go E:\gostudent\2020-04-01>dir 2020/04/01 15:55 . 2020/04/01 15:55 .. 2020/04/01 15:49 2,106,368 hello.exe 2020/04/01 15:33 151 hello.go 2020/04/01 15:55 2,106,368 zisefeizhu.exe 3 个文件 4,212,887 字节 2 个目录 121,880,002,560 可用字节 E:\gostudent\2020-04-01>zisefeizhu.exe hello, zisefeizhu windows 二进制文件必须是.exe linux 没有后缀之分 ``` **转义字符** ```go //转义字符 package main import "fmt" func main() { fmt.Println("hello\tzisefeizhu\nage\t21\ndir\tE:\\gostudent\\2020-04-01\nhellozisefeizhuhellozisefeizhu\rzisefeizhu\ni live you\"jing xiang\"")go } 输出: hello zisefeizhu age 21 dir E:\gostudent\2020-04-01 zisefeizhu i live you"jing xiang" 1)\t : 表示一个制表符,通常使用它可以排版 2)\n : 换行符 3)\\ : 一个\ 4)\" : 一个 " 5)\r : 一个回车 不是换行 是整行替换了 在现实中,我们认为回车和换行是一码事,但是在计算机的世界里面其实我们之前的判断是有误的。回车是意味着当前行的返回到行首,而换行是结束本行到下一行。 ``` **注释** ```go //注释 package main import "fmt" func main() { //单行注释 /* 多行注释 多行注释 */ fmt.Println("注释") } 1) 对于行注释和块注释,被注释的文字,不会被Go编译器执行 2) 块注释里面不能有块注释,也就是说块注释不能有嵌套 3) 推荐使用单行注释 ``` **代码风格** ```go package main import "fmt" func main() { fmt.Println("gofmt格式化") var num int = 2 + 4 * 5 fmt.Println("hellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisef" + "eizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhu" + "hellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozi" + "sefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhu\nnum = ",num) } 1) 使用一次tab操作,实现缩进,默认整体向右边移动,使用shift+tab整体向左移 2) 使用gofmt来进行格式化 3) 运算符两边习惯性各加一个空格 4) 大括号必须和函数名同行 5) 一行最长不超过80个字符,超过的请使用换行展示,尽量保持格式优雅 ``` ### Dos常用指令 **dos的基本操作原理** ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215407006-1786800572.png) **案例:** 切换到E盘,新建一个目录zisefeizhu,切换到该目录,新建 a b c 三个目录,切换到a 目录, 新建文件news.txt,复制文件到b目录下,移动到c目录下,最后都删除 ```dos e:\gostudent\2020-04-01>cd e:\ //切换到e盘 e:\>md zisefeihu //新建目录zisefeizhu e:\>cd zisefeihu //切换到该目录 e:\zisefeihu>md a b c //新建目录 a b c e:\zisefeihu>dir //查看目录下的内容 2020/04/01 16:55 a 2020/04/01 16:55 b 2020/04/01 16:55 c e:\zisefeihu>cd a //切换到a 目录 相对目录 e:\zisefeihu\a>echo . > news.txt //创建一个空文件 e:\zisefeihu\a>copy news.txt e:\zisefeihu\b //复制到b目录 绝对路径 已复制 1 个文件。 e:\zisefeihu\a>move news.txt e:\zisefeihu\c //移动到c盘 移动了 1 个文件。 e:\zisefeihu\a>dir e:\zisefeihu\a>cd .. e:\zisefeihu>cd .. e:\>rd /q/s zisefeihu //删除zisefeizhu目录及子目录和文件 不带询问 e:\>dir e:\>cls //清屏 cang lao shi :苍老师 首字母 ``` ### Go变量 一个程序就是一个世界,变量是程序的基本组成单位。 变量相当于内存中一个数据存储空间的表示,可以把变量看作是一个房间的门牌号,通过门牌号可以找到房间,同样的道理,通过变量名可以访问到变量(值) **变量的使用步骤** ```go import "fmt" func main() { var i int //声明变量(定义变量) i = 10 //非变量赋值 fmt.Println("i = ", i) //使用变量 } //i = 10 1) 变量表示内存中的一个存储区域 这里可以把内存比喻成一个大厦每个房间都是存储区域 2)该区域有自己的名称(变量名)和类型(数据类型) 房间号 房间存放的内容 ``` ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215422304-1041554902.png) **变量使用三种方式:** ```go func main() { var i int //指定变量类型,声明后如不赋值,使用默认值 var num = 10.11 //根据值自行判定变量类型(类型推导) name := "zisefeizhu" //(3)省略var,注意:=左侧的变量不应该是已经声明过的,否则会导致编译错误 n1, n2, name2 := 100, 200, "jingxing" //一次性声明多个变量 } 一次性声明多个全局变量【在go中函数外部定义变量就是全局变量】 var ( n3 = 300 n4 = 900 name2 = "yike" ) func main() { } 变量在同一个作用域(在一个函数或者在代码块)内不能重名 变量 = 变量名 + 数据类型 + 值 【变量的三要素】 Go的变量如果没有赋初值,编译器会使用默认值,比如int 默认值0 string默认值是空串,小数默认值为0 ``` **变量的声明、初始化和赋值** ```go 声明变量 基本语法:var 变量名 数据类型 var a int 这就是声明了一个变量,变量名是a var num1 float32 这也是声明了一个变量,表示一个单精度类型的小数,变量名是num1 初始化变量 在声明变量的时候,就给值 var a int = 45 这就是初始化变量a 使用细节:如果声明时就直接赋值,可省略数据类型 var b = 400 变量赋值 var num int //默认0 num = 780 这就是给变量赋值 ``` **程序中 + 号的使用** 1) 当左右两边都是数据型时,则做加法运算 2) 当左右两边都是字符串,则做字符串拼接 ## 数据类型的基本介绍 在 Go 编程语言中,数据类型用于声明函数和变量。数据类型的出现是为了把数据分成所需内存大小不同的数据,编程的时候需要用大数据的时候才需要申请大内存,就可以充分利用内存。编译器在进行编译的时候,就要知道每个值的类型,这样编译器就知道要为这个值分配多少内存,并且知道这段分配的内存表示什么。 ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215436794-557999894.png) ***基本数据类型、数组和结构体都是值类型*** ### **整数类型** **int的有符号类型** | 类型 | 有无符号【正负】 | 占用存储空间 | 表数范围 | 备注 | | ----- | ---------------- | ------------ | ---------------- | ------------------------------------------- | | int8 | 有 | 1字节 | -128 ~ 127 | -128 到 127 | | int16 | 有 | 2字节 | -2^15 ~ 2^15 - 1 | -32768 到 32767 | | int32 | 有 | 4字节 | -2^31 ~ 2^31 -1 | -2147483648 到2147483647 | | int64 | 有 | 8字节 | -2^63 ~ 2^63 -1 | -9223372036854775808 到 9223372036854775807 | **int的无符号类型** | 类型 | 有无符号 | 占用存储空间 | 表数范围 | 备注 | | ------ | -------- | ------------ | ------------- | ------------------------- | | uint8 | 无 | 1字节 | 0 ~ 255 | 0 到 255 | | uint16 | 无 | 2字节 | 0 ~ 2^16 - 1 | 0 到 65535 | | uint32 | 无 | 4字节 | 0 ~ 2^32 - 1 | 0 到 4294967295 | | uint64 | 无 | 8字节 | 0 ~ 2^64 4- 1 | 0 到 18446744073709551615 | 有无符号类型的区别 ​ 首位为符号位 ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215451466-394086786.png) **int的其它类型** | 类型 | 有无符号 | 占用存储空间 | 表数范围 | 备注 | | ------- | ------------------------------------------------------------ | ------------------------------- | --------------------------------- | -------------------- | | int | 有 | 32位系统4个字节/64位系统8个字节 | -2^31 ~ 2^31 - 1/-2^63 ~ 2^63 - 1 | | | uint | 无 | 32位系统4个字节/64位系统8个字节 | 0 ~ 2^32 - 1/0 ~ 2^64 - 1 | | | rune | 有 | 与int32一样 | -2^31 ~ 2^31 - 1 | Unicode码 | | uintptr | 无符号整形,用于存放一个指针,是一种无符号的整数类型,没有指定具体的bit大小但是足以容纳指针。uintptr类型只有在底层编程是才需要,特别是Go语言和C语言函数库或操作系统接口相交互的地方。 | | | | | byte | 无 | 与uint8等价 | 0 ~ 255 | 一般用来存储单个字符 | **整型的使用细节** ```go package main import ( "fmt" "unsafe" ) func main() { var n1 = 65535 //Golang的整型默认声明为int型 fmt.Printf("n1的类型是%T n1 占用的字节数是%d ", n1, unsafe.Sizeof(n1)) //在程序查看某个变量的字节大小和数据类型 } //n1的类型是int n1 占用的字节数是8 Go程序中整型变量在使用时,遵守保小不保大的原则,即:在保证程序正确运行下,尽量使用占用空间小的数据类型 bit:计算机中的最小存储单位。byte:计算机中基本存储单位。1byte = 8bit 有符号类型可以存储任何整数,无符号类型只能存储自然数 定义一个int8类型的整数(var num int8 = 0),如果一直自加1,这个变量的值会是(0...127 -128 -127... 0 ...127)循环往复下去,而不会超过类型最大值的范围 ``` ### 浮点数/小数类型 小数类型就是用于存放小数的,比如 6.6 0.23 -1.91 **小数类型分类** | 类型 | 占用存储空间 | 表数范围 | | ------------- | ------------ | ---------------------- | | 单精度float32 | 4字节 | -3.403E38 ~ 3.403E38 | | 双精度float64 | 8字节 | -1.798E308 ~ 1.798E308 | | complex64 | | 32位实数和虚数 | | complex128 | | 64位实数和虚数 | ```go func main() { var n1 = 21.23 //默认声明为float64 推荐使用float64 var ( n2 float32 = -123.0000901 //float64的精度比float32高 n3 float64 = -123.0000901 ) fmt.Printf("n1的类型%T n1 占用的字节数是%d\n", n1, unsafe.Sizeof(n1)) fmt.Println("n2 = ",n2, "n3 = ",n3) } //n1的类型float64 n1 占用的字节数是8 //n2 = -123.00009 n3 = -123.0000901 尾数部分可能丢失,造成精度损失 浮点类型有固定的范围和字段长度,不受os影响 浮点数 = 符号位+指数位+尾数位 浮点数都是有符号的 浮点型常量有两种表示形式 十进制数形式:如:5.12 .512(必须有小数点) 科学计数法形式:如:5.1234e2 = 5.1234^10的2次方 5.12E-2 = 5.12/10的2次方 ``` ### 字符类型 Golang中没有专门的字符类型,如果要存储单个字符(字母),一般使用byte来保存。 字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的,也就是说对于传统的字符串是由字符组成的,而Go的字符串不同,它是由字节组成的。 ```go func main() { var ( c1 byte = 'a' //字符常量用单引号括起来 c2 byte = '0' //字符o byte等价uint8 //c3 byte = '北' //.\变量.go:12:13: constant 21271 overflows byte //c3 int = "北" //.\变量.go:13:12: cannot use "北" (type string) as type int in assignment c3 int = '北' c4 int = 22269 n1 = 10 + c1 //字符类型是可以进行运算的 ) fmt.Printf("c2 的类型是%T c2占用的字节数%d c2对应的字符%c\n ", c2, unsafe.Sizeof(c2), c2) fmt.Println("c1 = ", c1) //直接输出byte值,就是输出对应字符的码值。 字符的本质是一个整数,直接输出时,是该字符对应的UTF-8编码的码值 fmt.Printf("c3 = %c c3对应码值=%d\n", c3, c3 ) //格式化输出对应的字符 fmt.Printf("c4 = %c\n", c4) fmt.Println("n1 = ", n1) } //c2 的类型是uint8 c2占用的字节数1 c2对应的字符0 // c1 = 97 //c3 = 北 c3对应码值=21271 //c4 = 国 //n1 = 107 Go语言的字符使用UTF-8编码,如果想查询字符对应的utf8码值:http://www.mytju.com/classcode/tools/encode_utf8.asp 英文字符 - 1个字节 汉字 - 3个字节 字符型存储到计算机中,需要将字符对应的码值(整数)找出来 存储:字符 -->对应码值 -->二进制 -->存储 读取:二进制 -->码值 -->字符 -->读取 字符和码值的对应关系是通过字符编码表决定的(是规定好的) Go语言的编码都统一成了utf-8。非常的方便,很统一,再也没有编码乱码的困扰了 ``` ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215515837-1492263213.png) ### 布尔类型 布尔类型也叫bool类型,bool类型数据只允许取值true和false bool类型占1个字节 bool类型适于逻辑运算,一般用于程序流程控制 if条件控制语句 for循环控制语句 ```go func main() { var b = false fmt.Printf("b = %v, b的占用空间=%d", b, unsafe.Sizeof(b)) } //b = false, b的占用空间=1 ``` ### string类型 字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本 ```go func main() { var ( addrress string = "北京 110 world!" str = "hello" // // 字符串一旦赋值了,字符串就不能修改了:在Go中字符串是不可变的 ) str2 := `str[0] = 'a'` //反引号,会识别转义字符,以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击,输出源代码等效果 fmt.Println("str2 = ", str2, "\n","address = ", addrress) } //str2 = str[0] = 'a' // address = 北京 110 world! ``` ### 基本数据类型的默认值 在go中,数据类型都有一个默认值,当程序员没有赋值时,就会保留默认值,在Go中,默认值又叫o值 | 数据类型 | 默认值 | | -------- | ------ | | 整型 | 0 | | 浮点型 | 0 | | 字符串 | “” | | 布尔类型 | false | ### 基本数据类型的相互转换 Go在不同类型的变量之间赋值时需要显式转换。也就是说Go中数据类型不能自动转换 ```go func main() { var ( i int32 = 1000 //被转换的是变量存储的数据(即值),变量本身的数据类型并没有变化 n1 float32 = float32(i) n2 int8 = int8(i) //将int32转成int8【-128 - 127】,编译时不会报错,只是转换的结果是按溢出处理,和我们希望的结果不一样。因此在转换时,需要考虑范围 n3 int64 = int64(i) ) n4 = i + n2 //类型不同,不能相加 fmt.Printf("i = %v, n1 = %v, n2 = %v, n3 = %v", i, n1, n2, n3) } //i = 1000, n1 = 1000, n2 = -24, n3 = 1000 表达式T(v)将值v转换为类型T T:就是数据类型,比如int32, int64, float32 等等 v:就是需要转换的变量 Go中,数据类型的转换可以是从:表示范围小 --> 表示范围大,也可以:范围大 --> 范围小 存在溢出现象 ``` ### 基本数据类型和string的转换 在程序开发中,经常将基本数据类型转成string,或者将string转成基本数据类型 **基本类型转string类型** ```go func main() { var ( num1 int = 99 num2 float32 = 23.456 b bool = true myChar byte = 'h' str string //空的str ) //使用第一种方式来转换fmt.Sprintf方法 fmt.Sprintf("%参数",表达式) //参数需要和表达式的数据类型相匹配 //fmt.Sprintf() 会返回转换后的字符串 str = fmt.Sprintf("%d",num1) //%d 表示为十进制 fmt.Printf("str type %T str = %q\n",str,str) //%T 值的类型的Go语法表示 // %q 该值对应的双引号括起来的go语法字符串字面值,必要时会采用安全的转义表示 str = fmt.Sprintf("%f",num2) //%f 有小数部分但无指数部分,如123.456 fmt.Printf("str type %T str = %q\n",str,str) str = fmt.Sprintf("%t",b) fmt.Printf("str type %T str = %q\n",str,str) str = fmt.Sprintf("%c",myChar) //%c 该值对应的unicode码值 fmt.Printf("str type %T str = %q\n",str,str) } //str type string str = "99" //str type string str = "23.455999" //str type string str = "true" //str type string str = "h" 这也是我喜欢用的一种 简单好使 ``` ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215534196-535301753.png) ```go func main() { //第二种方式strconv函数 var ( num3 int = 99 num4 float64 = 23.456 b2 bool = true str string ) str = strconv.FormatInt(int64(num3),10) //这里的10是进制 fmt.Printf("str type %T str = %q\n",str,str) //strconv.FormatFloat(num4,'f',10,64) //说明:'f'格式 10:表示小数位保留10位,64:表示这个小数是float64 str = strconv.FormatFloat(num4,'f',10,64) fmt.Printf("str type %T str = %q\n",str,str) str = strconv.FormatBool(b2) fmt.Printf("str type %T str = %q\n",str,str) //strconv包中有一个函数Itoa var num5 int64 = 4567 str = strconv.Itoa(int(num5)) //strconv.Itoa是strconv.FormatInt的简写 fmt.Printf("str type %T str = %q\n",str,str) } //str type string str = "99" //str type string str = "23.4560000000" //str type string str = "true" //str type string str = "4567" 函数将浮点数表示为字符串并返回。 bitSize表示f的来源类型(32:float32、64:float64),会据此进行舍入。 fmt表示格式:'f'(-ddd.dddd)、'b'(-ddddp±ddd,指数为二进制)、'e'(-d.dddde±dd,十进制指数)、'E'(-d.ddddE±dd,十进制指数)、'g'(指数很大时用'e'格式,否则'f'格式)、'G'(指数很大时用'E'格式,否则'f'格式)。 prec控制精度(排除指数部分):对'f'、'e'、'E',它表示小数点后的数字个数;对'g'、'G',它控制总的数字个数。如果prec 为-1,则代表使用最少数量的、但又必需的数字来表示f。 ``` ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215547546-692357360.png) **string类型转基本数据类型** ```go func main() { var ( str string = "true" b bool str2 string = "1234590" n1 int64 n2 int str3 string = "123.456" f1 float64 str4 string = "hello" n int64 = 11 ) //b,_ = strconv.ParseBool(str) //说明 //1. strconv.ParseBool(str)函数会返回两个值(value bool,err error) //2. 因为只想获取到value bool,不想获取err所以使用_忽略 b,_ = strconv.ParseBool(str) fmt.Printf("b type %T b = %v \n",b,b) n1,_ = strconv.ParseInt(str2,10,64) n2 = int(n1) fmt.Printf("n1 type %T n1 = %v\n",n1,n1) n3 := int32(n1) fmt.Printf("n3 type %T n3 = %v\n", n3,n3) //再将64位转32位 fmt.Printf("n2 type %T n2 = %v\n",n2,n2) f1,_ = strconv.ParseFloat(str3,64) fmt.Printf("f1 type %T f1 = %v\n",f1,f1) n, _ = strconv.ParseInt(str4, 10, 64) //在将String类型转成基本数据类型时,要确保String类型能够转成有效的数据,比如我们可以把’123’转成一个整数, //但是不能把“hello”转成一个整数,如果这样做,Go直接将其转成0,其它类型也是一样的道理。 // float --> 0 bool --> false fmt.Printf("n type %T n == %v\n", n,n) } //b type bool b = true //n1 type int64 n1 = 1234590 //n2 type int n2 = 1234590 //f1 type float64 f1 = 123.456 //n type int64 n == 0 ``` ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215600010-513601720.png) ### 值类型和引用类型 值类型:基本数据类型int系列、float系列、bool、string、数组和结构体struct 引用类型:指针、slice切片、map、管道chan、interface等都是引用类型 **值类型和引用类型的使用特点** 值类型:变量直接存储值,内存通常在栈中分配 ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215613466-1560749446.png) 引用类型:变量存储的是一个地址,这个地址对应的空间才真正存储数据(值),内存通常在堆上分配,当没有任何变量引用这个地址时,该地址对应的数据空间就成为一个垃圾,由GC来回收 ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215624789-1562820014.png) **内存的栈区和堆区示意图** ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215637287-1549906306.png) **指针** 基本数据类型,变量存的就是值,也叫值类型 获取变量的地址,用&,比如:var num int,获取num的地址:&num 分析一下基本数据类型在内存的布局 ```go func main() { //基本数据类型,变量存的就是值,也叫值类型 var i int = 10 fmt.Println("i 的地址 = ", &i) //获取变量的地址,用&,比如:var num int,获取num的地址:&num var ptr *int = &i //指针类型,指针变量存的是一个地址,这个地址指向的空间存的才是值 //1. ptr 是一个指针变量 //2. ptr 的类型 *int //3. ptr 本身的值&i *ptr = 101 fmt.Printf("ptr = %v\n", ptr) fmt.Printf("ptr的地址 = %v\n", &ptr) fmt.Printf("ptr 指定的值 = %v\n", *ptr) //获取指针类型所指向的值,使用:*,比如:var ptr *int,使用*ptr获取ptr指向的值 fmt.Printf("i 的值 =%v", i) //将i的地址赋给指针ptr,并通过ptr去修改i的值 } //i 的地址 = 0xc00000a0b8 //ptr = 0xc00000a0b8 //ptr的地址 = 0xc000006030 //ptr 指定的值 = 101 //i 的值 =101 值类型,都有对应的指针类型,形式为 *数据类型,比如int的对应的指针就是 *int,float32对应的指针类型就是*float32,依次类推 值类型包括:基本数据类型int系列、float系列、bool、string、数组和结构体struct ``` ![](https://img2020.cnblogs.com/blog/1464583/202004/1464583-20200401215652061-1919345246.png)

加载全部内容

相关教程
猜你喜欢
用户评论