golang
golang
go语言特点：c语言编译执行方式以及弱化指针+python
文章中的示例代码可直接复制到自己的编辑器中运行
Dos基础命令
目录操作
#查看当前路径下文件
dir
#切换到其他盘
cd /d d:
#切换到当前盘的其他目录
cd 目录名\目录名 #相对路径
cd f:\目录名\目录名 #绝对路径
#切换到上一级
cd ..
#切换到根目录
cd \
#新建目录
md 目录名及其创建的路径
#新建多个目录
md 目录名及路径 目录名及其路径
#删除空目录
rd 需要删除的目录路径
#删除目录以及下面的子目录和文件，不带询问
rd /q/s 需要删除的目录路径
#删除目录以及下面的子目录和文件，带询问
rd /s 需要删除的目录路径文件操作
#新建或追加内容到文件
echo 文件内容 > 文件路径以及新建或者想要追加内容的文件名
#复制文件
copy 原文件路径 目标文件路径（可进行文件的重命名）
#移动文件
move 原文件路径 目标文件路径（可进行文件的重命名）
#删除指定文件
del 要删除的文件路径
#删除所有.txt后缀的文件
del *.txt其他指令
#清屏
cls
#退出dos
exit其他知识点
vscode快捷键
alt+shift+f：全局整理格式
alt+shift+↓：复制一行
字节
一个字节8位2进制
程序种+的使用
- 当左右两边都是数值型时，则做加法运算
- 当左右两边都是字符串，则时将其拼接
package main
import "fmt"
func main() {
//此处的输出结果为80
fmt.Println(30 + 50)
//此处的输出结果为hello world
fmt.Println("hello " + "world")
}Unicode码
Unicode只有一个字符集，中文、日文、韩文三种文字一齐占用了Unicode中0x3000到0x9FFF的部分。Unicode目前普遍采用的是UCS-2标准，它用两个字节来编码一个字符， 比如汉字”经”的编码是0x7ECF。因为字符码一般用十六进制来表示，为了与十进制区分，十六进制以0x开头，0x7ECF转换成十进制即是32463，UCS-2用两个字节来编码字符，两个字节就是16位二进制， 2的16次方等于65536，所以UCS-2最多能编码65536个字符。 编码从0到127的字符与ASCII编码的字符一样，比如字母”a”的Unicode编码是0x0061，对应的十进制是97，而”a”的ASCII编码是0x61，对应的十进制也是97,。实际上Unicode对汉字的支持与编码并不怎么好，这也是没办法的。简体汉字和繁体汉字加在一起总共有六七万个，而UCS-2最多只能表示65536个字符，所以Unicode只能通过排除一些几乎不用的汉字的方法以能够表达其余常用汉字，好在常用的简体汉字只有七千多个。为了能表示所有汉字，Unicode也有UCS-4规范，就是用 4个字节来编码字符，在这种规范下，大部分来自不同国家和地区的可读字符都可以被表达出来。
Golang官方变成指南
网页端指南网站：
(不推荐)API查询官方网址（API：应用程序编程接口，就是我们Go的包的各个函数）
(推荐)Golang标准库API文档(国内下载，访问速度比官方要快)
调用包中的方法：包名.包中的函数名(需要传入的参数)
// 引入包：文件所在包
package main
//导入方法使用的包
import "fmt"
func main() {
//使用fmt中的Println函数
fmt.Println("hello,world!")
}编译与运行
编译
编译：主要是将编写的代码编译为机器能识别的二进制码文件，在Windows上会生成一个.exe后缀的文件，在Linux下会生成一个绿色的可执行文件，若存在错误则会爆出有问题的行。
运行
运行的两种方式：
- 直接运行生成的可执行Go程序，比如hello.exe
- 通过运行工具fo run队员吗进行运行
常见问题及解决方法
找不到文件
问题描述：执行代码时报错：The system cannot find the file specified.
翻译出来为：系统找不到指定的文件
解决发放：源文件名不存在或者写错，或者当前路径错误
语法错误
问题描述：提示语法错误例子：
#command-line-arguments
main\hello.go:9:6: undefined: fmt.Print1n翻译为：
#命令行参数main\hello.go:9:6:未定义：fmt.打印1n
其中第二行表示：出错的文件路径：行数：列：出现的问题
主要看的为我上边高亮的内容
解决方法：排查是否出现语法错误，比如拼错单词，大小写，大括号，引号，或者使用了中文输入法等
注释
介绍：主要用来对方法类异界代码进行描述，便于后期维护和他人阅读
分类：
- 行注释（单行注释）
- 块注释（多行注释）
注意：注释的内容是不会被程序编译的，对程序无影响
行注释
使用方法：// + 注释内容
推荐用来注释整个方法和语句
// 引入包：文件所在包
package main
//导入方法使用的包
import "fmt"
func main() {
fmt.Println("hello,world!") //输出hello,world!,需要注意的是需要导入对应的包，否则编译无法通过
}块注释（多行注释）
使用方法：/ /
注意：块注释里不允许有块注释嵌套
/*
多
行
注
释
*/
// 引入包：文件所在包
package main
//导入方法使用的包
import "fmt"
func main() {
fmt.Println("hello,world!") //输出hello,world!,需要注意的是需要导入对应的包，否则编译无法通过
}代码风格规范
正确的缩进和空白
- 使用
tab操作，实现整体向右缩进，默认整体向右边移动，有时候用shift+tab整体左移- 或者使用gofmt来进行格式化（vscode中使用
alt+shift+f实现）终端中通过fofmt -w +go文件路径实现- 运算符两边习惯性各加一个空格。比如：2 + 3 * 5
代码风格
//错误示范
package main
import "fmt"
func main()
{ //Go语言不能将方法后边的大括号另起一行
fmt.Println("hello,world")
}
//正确示范
package main
import "fmt"
func main() {
fmt.Println("hello,world")
}go语言特点
弱化的指针
package main
import "fmt"
//此处num为变量
func test(num int) {
num =20
fmt.Println("num=", num)
}
//此处*num为指针
func test2(num2 *int) {
//&num表述输出num2指针的内存地址，num2表示输出指针变量的值，*num2表示输出num2保存的内存地址对应的值
fmt.Println("&num2=", &num2, "num2=", num2, "*num2", *num2)
}
func main() {
fmt.Println(30 + 50)
fmt.Println("hello " + "world")
//定义指针变量
var i *int
//定义变量n
n := 20
//给指针变量赋值为n的内存地址
i = &n
//调用test函数
test(50)
//调用test2函数
test2(i)
}包的引入
引入包的概念，用于组织架构，Go语言的一个文件都要归属于一个包，而不能单独存在
注意：此处的包主要是当前.go后缀文件所在的文件夹
//归属的包的生命
package 归属的包的名字
//举例:归属于main的go文件
package main
//引入包
import "引入的包的名称"
//举例
import "fmt"行长约定
一行最长不超过80个字符，超过的请使用换行展示，尽量保持格式优雅
//换行举例,使用goland编辑器的话goland会自动帮你加上
fmt.Println("hellehellehellehellehe",
"llehellehellehellehellehelle",
"hellehellehellehellehellehellehelle")垃圾回收机制
垃圾回收机制，内存自动回收，不需要开发人员管理
天然并发（重要特点）
- 从语言层面支持并发，实现简单
- goroutime，轻量级线程，可实现大并发处理，高效利用多核
- 基于CPS并发模型实现
管道通讯机制
吸收管道通讯机制，形成Go语言特有的管道channel，通过管道channel，可以实现不通goroute质检的相互通信
函数返回多个值
//同时返回和与差，(n1 int, n2 int):此处为传参,(int int):此处为返回值
func getSumAndSub(n1 int, n2 int) (int int){
sum := n1+n2 //go语句之后不需要写分号
sub := n1-n2
return sum , sub
}切片slice、延时执行defer
切片类似于Java中的集合
延时执行指的是所有代码执行完以后在执行defer中的代码
开发工具
- VSCode：个人看法(需要安装各种插件)
- Sublime Text: 个人看法(适合用来查看单独的go文件)
- Vim：同上
- Emacs：即使编辑器又可以用在做集成开发环境
- eclipse：开发编辑器，但是需要安装go插件并进行配置
- goland：开发编辑器，教程视频介绍，但是是JetBrain公司的全家桶产品，相对来说更推荐这个(个人推荐)
VSCode的下载安装以及使用
下载安装
下载地址:VSCode
使用
创建工作区
点击文件->打开文件夹
创建并选择文件夹作为工作目录
VSCode搭建go语言环境
下载安装SDK
SDK：软件开发工具包，主要是提供给开发人员使用的，其中包含了对应开发语言的工具包
下载地址：
Go中文网 Go语言中文网 golang (p2hp.com)
傻瓜式安装即可，安装路径不要有中文
配置环境变量
右键此电脑->属性->高级系统设置->环境变量->新建
新建:GOROOT
- 变量名：GOROOT
- 变量值：SDK安装路径
path添加SDK的bin路径如下
%GOROOT%\bin
如果使用上边配置验证不通过则使用绝对路径
验证
桌面开启终端输入go version显示版本即表示环境变量配置成功如下图所示
入门程序Hello World
开发工具：VSCode
创建main文件夹以及hello.go文件
安装编译运行的插件
编写代码
// 引入包：文件所在包 package main //导入方法使用的包 import "fmt" func main() { //输出hello,world!,需要注意的是需要导入对应的包，否则编译无法通过 fmt.Println("hello,world!") }保存->右键点击Run Code运行代码
保存后确保VSCode文件名后边没有白色点才算保存完成
Golang执行流程分析
两种执行流程：
- .go文件先使用go build进行编译生成.exe或可执行文件然后运行.exe文件或可执行文件进行运行
- go run:编译运行一步解决
两种执行流程区别：
- 如果是先编译在运行生成的.exe文件即使将.exe文件移动到一台没有环境的电脑上仍然可以运行，使用go run命令则不可以
- 使用go build编译时，编译器会将程序运行所需要的库文件包含在可执行文件中，所以可执行文件变大了很多
执行流程图如下
Go语法注意点
- Go源文件以“go”为扩展名
- Go应用程序的执行入口时main()方法
- Go语言严格区分大小写
- Go方法由一条条语句构成，每个语句后不需要分号（Go语言会在每行后自动加分号），这也体现出Golang的简洁性
- Go编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多条语句写在同一行，否则会报错
- go语言定义的变量或者import的包如果没有使用到，代码不能编译通过
- 大括号成对出现，缺一不可
Go转义字符
\t：一个制表符
\n：换行符
\\：一个\
\“：一个“
\r：一个回车根据版本可能是替换也可能是换行
我的是1.21.5版本效果为换行
数据类型以及默认值
基本数据类型
数值型
整数类型
默认值：0
uint类型为无符号类型
分类：
- int 范围：32位系统-231~231-1，64位系统-263~263-1 存储空间：32位系统4字节，64位系统8字节
- int8 范围：-128~127 存储空间：1字节
- int16 范围：-215~215-1 存储空间：2字节
- int32 范围：-231~231-1 存储空间：4字节
- int64 范围：-263~263-1 存储空间：8字节
- uint 范围：32位系统0~232-1，64位系统0
~264-1 存储空间：32位系统4字节，64位系统8字节- uint8 范围：0~255 存储空间：1字节
- uint16 范围：0~216-1 存储空间：2字节
- uint32 范围：0~232-1 存储空间：4字节
- uint64 范围：0~264-1 存储空间：8字节
- byte：与uint8等价，当要存储字符时选用byte
- rune：与int32一样，表示一个Unicode码，一般用来存储汉字
使用细节：
在程序中查看某个变量的字节大小和数据类型
package main //导入包的方法建议使用这种 import ( "fmt" "unsafe" ) func main() { //查看某个变量的占用字节和数据类型 var n int64 = 10 //使用fmt.Printf()用来做格式化输出，%T用来输出类型，%d用来输出占用字节，使用unsafe包下的Sizeof函数来获取变量占用字节数大小 fmt.Printf("n的类型 %T n占用的字节数是 %d", n, unsafe.Sizeof(n)) }Golang程序中整型变量在使用时，遵守报销不报答原则，即：在保证程序正常运行下，尽量使用占用空间小的数据类型。比如想要存储的数据范围在0-255那便使用unit8类型来保存，没必要定义更大的变量
bit：计算机中的最小存储单位。Byte：计算机中基本存储单元。1byte=8bit
浮点类型/小数类型
默认值：0
简单说明：
浮点数=符号位+指数位+尾数为
尾数部分可能丢失，造成经度损失。
package main import ( "fmt" ) func main() { var num1 float32 = -123.0000901 var num2 float64 = -123.0000901 //此处的输出位：num1= -123.00009 num2= -123.0000901 //从输出可以看出num1会有精度丢失 fmt.Println("num1=", num1, "num2=", num2) }浮点型的存储分为三部分：符号位+指数位+尾数位，在存储过程中精度可能丢失
分类：
float32 范围：-3.403E38~3.403E38 存储空间：4字节
float64 范围：-1.798E308~1.798E308 存储空间：8字节
使用细节：
Golang浮点类型有固定的范围和字段长度，不受具体的操作系统影响
Golang的浮点型默认声明位float64
浮点型常量两种表现形式：
十进制数形式：如5.12，.512（.512输出时是0.512，必须有小数点）
科学计数法形式：如5.1234e2 = 5.1234*10的2次方 5.1234E-2 = 5.12/10的2次方
通常情况下，应该使用float64，因为它比float32更精确。[开发中，推荐使用float64]
字符型
没有专门的字符型，使用byte来保存单个字母字符，可以保存的范围是[0-1,a-z,A-Z..]，若保存的字符对应码值大于255，这时推荐使用rune和int类型保存,
默认值：””
package main
import (
"fmt"
)
func main() {
var c1 byte
var c2 byte = 'a'
var c3 byte = '0'
/*
var c4 byte = '陈'前边的注释符号会提示溢出报错，
单个汉字的值已经超出byte类型所能存储的最大数据
以陈为示例，他的ASCII码值为38472，而byte所能
存储的最大范围为0~255，因此无法进行保存
*/
//var c4 byte = '陈'
//当个汉字字符推荐使用rune来保存(推荐)
var c4 rune = '陈'
var c5 int = '莹'
/*
直接输出：直接输出时输出的值为ASCII码值
*/
//输出结果：默认值为0
fmt.Println("c1=", c1)
//输出结果：97
fmt.Println("c2=", c2)
//输出结果：48
fmt.Println("c3=", c3)
//输出结果：38472
fmt.Println("c4=", c4)
//输出结果：33721
fmt.Println("c5=", c5)
/*
如果想要直接输出变量的赋值，不输出ASCII码值则
使用格式话输出Printf,下边代码中的\n是用来换行的转义符
*/
//输出结果：默认值null
fmt.Printf("c1=%c\n", c1)
//输出结果：a
fmt.Printf("c2=%c\n", c2)
//输出结果：0
fmt.Printf("c3=%c\n", c3)
//输出结果：c4=陈,c4对应的码值=38472
fmt.Printf("c4=%c,c4对应的码值=%d\n",c4,c4)
//c5=莹,c5对应的码值=33721
fmt.Printf("c5=%c,c5对应的码值=%d",c5,c5)
}
使用细节：
字符常量是用单引号括起来的单个字符。如：var c1 byte = ‘a’ var c2 int = ‘中’ var c3 byte = ‘9’
Go中允许使用转义字符’\‘来将其后的字符转变为特殊字符型常量。例如：var c3 char = ‘\n’其中\n表示换行符
Go语言的字符使用UTF-8编码（英文字母1个字节，汉字3个字节）查看字符编码（UTF-8） (mytju.com)
在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的码值
可以直接给某个变量赋一个数字，然后按格式化输出是%c，会输出该数字对应的unicode字符
package main import ( "fmt" ) func main() { var num1 int = 21271 //输出结果：num1=北,num1对应码值=21271 fmt.Printf("num1=%c,num1对应码值=%d", num1 ,num1) }字符类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码
package main import ( "fmt" ) func main() { var num1 int = 21271 var num2 int = 55 var num3 int = num1 + num2 //输出结果：num3=华,num3对应码值=21326 fmt.Printf("num3=%c,num3对应码值=%d", num3 ,num3) }
字符类型本质探讨：
字符型存储到计算机中，需要将字符对应的码值（整数）找出来
存储：字符——>对应码值——>二进制——>存储
读取：二进制——>码值——>字符——>读取
字符和码值的对应关系是通过字符编码表决定的（是规定好）
Go语言的编码都统一成了utf-8,和其他的变成语言来说。非常的方便，很统一，在也没有编码的困扰
布尔型
默认值：false
基本介绍：(主要用来表示真假判定)
布尔类型也叫bool类型，bool类型只允许取值true和false
bool类型只占有1个字节
package main import ( "fmt" "unsafe" ) func main() { var b = false //输出结果：b= false b的占用空间大小为： 1 字节 fmt.Println("b=", b, "b的占用空间大小为：", unsafe.Sizeof(b), "字节") }boolean类型适于逻辑运算，一般用于程序流程控制
if条件控制语句
for循环控制语句
字符串(String)
基本介绍：
字符串就是遗传固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码识别Unicode文本
基础使用：
package main import ( "fmt" ) func main() { var str string = "洛阳龙门石窟，yyds" //输出结果：洛阳龙门石窟，yyds fmt.Println(str) }注意事项和使用细节：
Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码，乱码问题不会在困扰
字符串的两种表现形式
- 双引号，会识别转义字符
- 反引号，以字符串的原生形输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
package main import "fmt" func main() { str := "Hello\nworld" /* 双引号可以识别转义符 输出结果： Hello world */ fmt.Println(str) //反引号不会识别转义符会按照赋值的是什么就是什么 var str2 string = ` // 引入包：文件所在包 package main //导入方法使用的包 import "fmt" func main() { fmt.Println("\t*\t\t\t\t\t\t\t\t\t\t\t\t*\t") fmt.Println("*\t\t*\t\t\t\tI love Golang\t\t\t*\t\t*") fmt.Println("\t*\t\t\t\t\t\t\t\t\t\t\t\t*\t") fmt.Println("\t\t*\t\t\t\t\t\t\t\t\t\t*\t\t") fmt.Println("\t\t\t*\t\t\t\t\t\t\t\t*\t\t\t") fmt.Println("\t\t\t\t*\t\t\t\t\t\t*\t\t\t\t") fmt.Println("\t\t\t\t\t*\t\t\t\t*\t\t\t\t\t") fmt.Println("\t\t\t\t\t\t*\t\t*\t\t\t\t\t\t") fmt.Println("\t\t\t\t\t\t\t*") }` fmt.Println(str2) }字符串拼接方式
package main import "fmt" func main() { var str1 = "hello world!" var str2 = "Luo Yang" str := str1+str2 //输出结果：hello world!Luo Yang fmt.Println(str) }当一行中多个字符串进行拼接时并且导致长度过长，需要使用到多行字符串，使用+号进行拼接，但是换行时加号必须在上边一行
package main import "fmt" func main() { str := "Hello " + "Luo Yang" + "Hello " + "Luo Yang" + "Hello " + "Luo Yang" + "Hello " + "Luo Yang" + "Hello " + "Luo Yang" + "Hello " + "Luo Yang" + "Hello " + "Luo Yang" //输出结果：Hello Luo YangHello Luo YangHello Luo YangHello Luo YangHello Luo YangHello Luo YangHello Luo Yang fmt.Println(str) }
基本数据类型的转换
介绍：
Golang和Java/C不同，Go在不同类型的变量之间赋值时需要显示转换。也就是说Golang中数据类型不能自动转换
基本语法：
表达式T(v)将值v转换为类型T
T：就是数据类型，比如int32,int64,float32等等
v：就是需要转换的变量
代码演示：
package main import "fmt" func main() { var i int = 42 //输出结果：i的类型为int,i的值为42 fmt.Printf("i的类型为%T,i的值为%d\n", i, i) var f float64 = float64(i) //输出结果：f的类型为float64,f的值为42 fmt.Printf("i的类型为%T,i的值为%v\n", f, f) var u uint8 = uint8(f) //输出结果：u的类型为uint8,u的值为42 fmt.Printf("i的类型为%T,i的值为%d\n", u, u) }注意事项以及细节说明：
- Go中，数据类型的转换可以从表示范围小->表示范围大，也可以范围大->范围小
- 被转换的时变量存储的数据（即值），变量本身的数据类型并没有变化！
- 在转换中，比如将int64转成int8，编译时不会报错，只是转换的结果时按溢出处理，和我们希望的结果不一样
注意事项以及细节说明演示代码：
package main import "fmt" func main() { var f float64 = 64.555 //输出结果：f的类型为float64,f的值为64.555 fmt.Printf("i的类型为%T,i的值为%v\n", f, f) var u uint8 = uint8(f) //输出结果：u的类型为uint8,u的值为64 fmt.Printf("i的类型为%T,i的值为%d\n", u, u) var i int = int(f) //输出结果：i的类型为int,i的值为64 fmt.Printf("i的类型为%T,i的值为%d\n", i, i) //输出结果：f的类型为float64,f的值为64.555 fmt.Printf("i的类型为%T,i的值为%v\n", f, f) }
基本数据类型和string的转换
介绍：
在程序开发中，我们经常需要将基本数据类型转换成string类型。或者将string类型转换成基本数据类型
基本数据类型转string类型：
方式1：fmt.Sprintf(“%参数”,表达式)
参数余姚和表达式的数据类型相匹配
fmt.Sprintf()会返回转换后的字符串
代码演示：
package main import "fmt" func main() { var i int = 99 var f float64 = 66.666 var bool bool = true var char byte = 'h' var s string //将i值转换为字符串 s = fmt.Sprintf("%d", i) //输出结果：s的类型为：string，s的值为："99" fmt.Printf("s的类型为：%T，s的值为：%q\n", s, s) //将f值转换为字符串 s = fmt.Sprintf("%f", f) //输出结果：s的类型为：string，s的值为："66.666000" fmt.Printf("s的类型为：%T，s的值为：%q\n", s, s) //将bool值转换为字符串 s = fmt.Sprintf("%t", bool) //输出结果：s的类型为：string，s的值为："true" fmt.Printf("s的类型为：%T，s的值为：%q\n", s, s) //将char值转换为字符串 s = fmt.Sprintf("%c", char) //输出结果：s的类型为：string，s的值为："h" fmt.Printf("s的类型为：%T，s的值为：%q\n", s, s) }方式2：使用strconv包函数
代码演示：
package main import ( "fmt" //导入strconv包 "strconv" ) func main() { var i int = 99 var f float64 = 66.666 var bool bool = true var u uint = 88 var num int = 4567 var s string //将bool类型转换为字符串类型 s = strconv.FormatBool(bool) //输出结果：s的数据类型为：string，数据的值为："true" fmt.Printf("s的数据类型为：%T，数据的值为：%q\n", s, s) /* 将f类型转换为字符串类型 传入参数： 第一个：需要转换的数据 第二个：格式，f为默认格式，其余格式参考接口文档 第三个：小数点后保留位数 第四个：需要转换的变量数据类型时float64还是float32 */ s = strconv.FormatFloat(f, 'f', 5, 64) //输出结果：s的数据类型为：string，数据的值为："66.66600" fmt.Printf("s的数据类型为：%T，数据的值为：%q\n", s, s) /* 将int类型转换为字符串类型, 传入参数： 第一个：需要转换的变量，参数类型需要为int64，如果不满足需要强制转换 第二个：需要转换的变量的进制此处为10进制（范围：2~36） */ s = strconv.FormatInt(int64(i), 10) //输出结果：s的数据类型为：string，数据的值为："99" fmt.Printf("s的数据类型为：%T，数据的值为：%q\n", s, s) /* 将uint类型转换为字符串类型 传入参数： 第一个：需要转换的变量，传入参数要求必须为uint64，不满足需强制转换 第二个：需要转换的变量的进制 */ s = strconv.FormatUint(uint64(u), 10) //输出结果：s的数据类型为：string，数据的值为："88" fmt.Printf("s的数据类型为：%T，数据的值为：%q\n", s, s) /* strconv包中还有一个函数Itoa用来将int类型转换为字符串 传入参数： 第一个：传入要转换为字符串类型的int类型数据 需要注意：传入的变量类型必须为int如果不是需要进行强转 */ s = strconv.Itoa(num) fmt.Printf("s的数据类型为：%T，数据的值为：%q\n", s, s) }
string类型转基本数据类型
使用strconv包函数
代码演示：
package main import ( "fmt" //导入strconv包 "strconv" ) func main() { var s1 string = "true" var s2 string = "12345" var s3 string = "66.666" var b bool var i int64 var f float64 var u uint64 /* 使用strconv的转换字符串为bool类型， 传入参数： 第一个：需要转换为bool类型的字符串 返回值： 第一个：数据类型：bool 转换后的bool类型的值 第二个：数据类型：err */ b, _ = strconv.ParseBool(s1) //输出结果：s的数据类型为：string，数据的值为：true fmt.Printf("b的数据类型为：%T，数据的值为：%t\n", b, b) /* 使用strconv的转换字符串为int类型， 传入参数： 第一个：需要转换为int类型的字符串 数据类型：string 第二个：返回值进制数，范围是2~36 数据类型：int 第三个：返回值整数类型，此处必须是无溢出的 数据类型：int 返回值： 第一个：数据类型：int 转换后的int类型的值 第二个：数据类型：err */ i, _ = strconv.ParseInt(s2, 10, 64) //输出结果：i的数据类型为：int64，数据的值为：12345 fmt.Printf("i的数据类型为：%T，数据的值为：%d\n", i, i) /* 使用strconv的转换字符串为int类型， 传入参数： 第一个：需要转换为int类型的字符串 数据类型：string 第二个：返回值数据类型，如果想要返回float32则传入参数填32，float64则填64 数据类型：int 返回值： 第一个：数据类型：float64 转换后的float64类型的值 第二个：数据类型：err */ f, _ = strconv.ParseFloat(s3, 64) //输出结果：f的数据类型为：float，数据的值为：66.666 fmt.Printf("f的数据类型为：%T，数据的值为：%f\n", f, f) /* 使用strconv的转换字符串为uint类型， 传入参数： 第一个：需要转换为uint类型的字符串 数据类型：string 第二个：返回值进制数，范围是2~36 数据类型：int 第三个：返回值整数类型，此处必须是无溢出的 数据类型：int 返回值： 第一个：数据类型：uint 转换后的uint类型的值 第二个：数据类型：err */ u, _ = strconv.ParseUint(s2, 10, 64) //输出结果：i的数据类型为：int64，数据的值为：12345 fmt.Printf("i的数据类型为：%T，数据的值为：%d\n", u, u) }
派生/复杂数据类型
指针（pointer）
数组
结构体（struct）
管道（Channel）
函数
切片（slice）
接口（interface）
map
变量
介绍
概念：白能量相当于内存中一个数据存储空间的表示，你可以把变量看作是一个房间的们的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量的值。
为什么需要变量
变量是程序的基本组成单位：不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位。
package main
import "fmt"
//getVal为自定义方法名，第一个大括号内为需要传入的参数以及参数类型，第二个括号内为返回值个数和数据类型
func getVal(num1 int, num2 int) (int, int){
//sum和sub均为定义的变量，num1和num2为传入的参数
sum := num1 + num2
sub := num1 - num2
return sum, sub //此处是返回值
}
//主函数(主方法)程序入口
func main() {
//定义变量sum和sub用来接收getVal的返回值，顺序与方法中的返回值顺序相同
sum, sub := getVal(30, 20)
fmt.Println("sum=", sum, "sub=", sub)
sum2, _ := getVal(30, 30)
fmt.Println("sum2=", sum2)
}运行结果如下所示：
使用步骤
- 变量声明(有人也叫: 定义变量)
- 赋值
- 使用
变量声明的方式以及使用
package main
import "fmt"
//全局变量：此变量可以在任何地方使用不需要传入
var tom = 100
var jack = 200
//一次声明多个全局变量
var(
marry = 18
kiko = 22
mimi = 44
)
func main () {
//方式一：指定变量类型定义后若不赋值则使用默认值:i是自定义的变量名，int是定义的变量的数据类型为int类型
var i int
fmt.Println("变量声明方式一：i=", i)
//方式二：根据值自行判定变量类型（类型推导）
var num = 10.11
fmt.Println("变量声明方式二：num=", num)
//方式三：省略var，注意:=左侧的变量不应该是已经声明过的，否则会导致编译错误
num2 := "hello"
//i := 1 //此处放开前边注释会导致编译错误，因为前边已经定义过变量名为i的变量
fmt.Println("变量声明方式三：num2=",num2)
//多变量声明方式一
var n1, n2, n3 int
fmt.Println("n1=", n1, "n2=", n2, "n3=", n3)
//多变量声明方式二
var n4, n5, n6 = 10, "tom", 888
fmt.Println("n4=", n4, "n5 =", n5, "n6=", n6)
//多变量声明方式三
n7, n8, n9 := 10, "cat", 666
fmt.Println("n7=", n7, "n8 =", n8, "n9=", n9)
//变量赋值，给自定义的i赋值为20
i = 20
//使用变量
fmt.Println("i=", i)
//输出全局变量
fmt.Println("tom=", tom, "jack", jack)
fmt.Println("marry=", marry, "kiko=", kiko, "mimi=", mimi)
}使用注意事项
变量表示内存中的一个存储区域
该区域有自己的名称（变量名）和类型（数据类型）
- 指定变量类型，声明后若不赋值，使用默认值
- 根据值自行判定变量类型（类型推导）
- 省略var，注意:=左侧的变量不应该是已经声明过的，否则会导致编译错误
多变量声明，在编程中，有时我们需要一次性声明多个变量，Golang也提供这样的语法
该区域的数据值可以在同一类型范围内不断变化
package main import "fmt" func main() { var i int //此处的输出结果为0 fmt.Println("初始默认值：", i) i = 30 //此处的输出结果为30 fmt.Println("第一次变化的值：", i) i = 50 //此处的输出结果为50 fmt.Println("第二次变化的值：", i) //i = 1.2 //变量i的数据类型为整数型因此只能存储整数型数据，此处删除行前的注释则会报错 }变量在同一作用域内(在一个函数或者在代码块)不能重名
package main import "fmt" func main() { var i int i := 99 //此处会报错，同一作用域内变量重复导致报错 }变量=变量名+值+数据类型
Golang的变量如果没有赋初值，编译器会使用默认值，比如int默认值为0，string默认值为空串
package main import "fmt" func main() { var i int //此处的输出结果为：int数据类型默认值: 0 fmt.Println("int数据类型默认值:", i) var str string //此处的输出结果为：string数据类型默认值:" " fmt.Println("string数据类型默认值:\"", str, "/"" }
