Golang--DOS命令、变量、基本数据类型、标识符

1、DOS命令

切换盘符（大小写没有区别）：
c:         //切换到c盘
d:         //切换到d盘
e:         //切换到e盘

显示文件内信息：
指令：dir

切换路径：

指令：cd 绝对路径 / 相对路径

. 表示当前目录

.. 表示上一层目录
cd ..

清屏：
指令：cls

切换历史命令：
上下箭头

补全命令：
tab按键

创建目录：
指令：md 目录名

删除目录：
指令：rd 目录名

复制文件：
指令：copy 源文件目标文件

删除文件：
指令：del 文件（del后面接目录，那么删除的是该目录下的文件，而不是该目录）

源文件(.go) -> 编译 -> 可执行程序（运行可执行程序 -> 执行结果）：
指令：go build 源文件（得到可执行程序）

指令：go build -o 目标文件源文件（指定编译后的文件名）

源文件(.go) -> 编译并运行 -> 执行结果：

指令：go run 源文件（直接得到执行结果）

文件格式化操作：
指令：gofmt 源文件，只是效果展示，不会写入源文件中

指令：gofmt -w 源文件，格式化并写入源文件中

2、语法基础

源文件以".go"为扩展名。
程序的执行入口是main()函数。
严格区分大小写。
方法由一条条语句构成，每个语句后不需要分号(Go语言会在每行后自动加分号)，这也体现出Golang的简洁性。
Go编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多条语句写在同一个，否则报错
定义的变量或者import的包如果没有使用到，代码不能编译通过。
大括号都是成对出现的，缺一不可
注释：行注释使用//，块注释使用/**/

package main //声明文件所在的包，每个go文件都必须声明所在的包，
//main包是程序的入口包，main函数是程序的入口函数
import "fmt" //导入fmt包，fmt包实现了格式化I/O（输入/输出）的函数
func main() { // 主函数，程序的入口函数
	// 调用 fmt 包中的 Println 函数，打印 Hello World 到控制台
	fmt.Println("Hello World123444")
}

go的设计者想要开发者有统一的代码风格，一个问题尽量只有一个解决方案是最好的

3、变量

变量的使用：

声明
赋值
使用

方式一：声明，赋值，使用分开，或声明变量并赋值

package main
import "fmt"

//全局
var aa int = 1

func main(){
	//声明变量
	var a int
	//变量赋值
	a = 10
	//变量使用
	fmt.Println(a)

	//声明变量并赋值
	var str string = "hello world"
	//变量使用
	fmt.Println(str)
	//局部
	var aa int = 3
	fmt.Println(aa)//输出3，局部变量优先
}

注意：变量不可以在同一作用域中定义多次，遵循局部变量优先。

方式二：自动类型推断

package main
import "fmt"

//全局变量
var glo1 = 100
var glo2 = "str"

//不能在函数外面使用:=，:=只能在函数里面使用
glo5 := 300

//全局变量一次性声明
var(
	glo3 = 200
	glo4 = "hello"
)

func main(){
	//局部变量
	
	//1、指定变量类型，并赋值
	var n1 int = 10
	fmt.Println(n1)
	
	//2、指定变量类型，不赋值，使用默认值
	var n2 int
	var n3 string
	fmt.Println(n2) //0
	fmt.Println(n3) //""

	//3、不指定变量类型，根据值自行判断变量类型
	var n4 = 100
	var n5 = "hello"
	fmt.Println(n4)
	fmt.Println(n5)

	//4、省略var，注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误
	n6 := 200
	n7 := "world"
	fmt.Println(n6)
	fmt.Println(n7)

	//5、一次性声明多个变量
	var n8,n9 int = 100,200
	var n10,n11 string = "hello","world"
	fmt.Println(n8,n9)
	fmt.Println(n10,n11)

	//6、一次性声明多个变量，省略var
	n12,n13 := 100,"hello"
	fmt.Println(n12,n13)

	fmt.Println(glo1)
	fmt.Println(glo2)
	fmt.Println(glo3)
	fmt.Println(glo4)
}

注意：在Go语言中，全局变量的声明和赋值通常使用var关键字，而不是:=（会报编译错误）。:=是用于在函数内部进行局部变量的声明和赋值的简短声明形式。在函数外部，即全局作用域中，应该使用var关键字来声明全局变量。

4、Golang数据类型

在Go语言中，数据类型用于定义变量可以存储的数据种类。Go语言的数据类型可以分为以下几类：

基本数据类型：
- 整数类型：int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, byte (等价于 uint8), rune (等价于 int32)
- 浮点数类型：float32, float64
- 布尔类型：bool
- 字符串类型：string
复合数据类型：
- 数组类型：[n]T，其中 n 是数组的长度，T 是数组元素的类型。
- 切片类型：[]T，切片是动态数组，可以自动增长。
- 映射类型：map[K]V，映射是键值对的集合，其中 K 是键的类型，V 是值的类型。
- 结构体类型：struct，结构体是由一系列具有相同或不同类型的字段组成的数据集合。
- 指针类型：*T，指针是变量的内存地址。
- 函数类型：func，函数是可以被调用的代码块。
- 接口类型：interface，接口是一组方法的签名，任何实现了这些方法的类型都可以称为实现了该接口。
其他数据类型：
- 通道类型：chan，通道用于在并发goroutine之间传递数据。
- 错误类型：error，错误类型用于表示函数执行过程中出现的错误。

在Go语言中，变量的类型是在编译时确定的，并且一旦确定就不能更改。这意味着你不能将一个整数类型的值赋给一个字符串类型的变量。

在你的代码示例中，你使用了多种数据类型，包括整数类型（int）、字符串类型（string）、布尔类型（bool）和切片类型（[]int）。例如：

var num int = 10
var str string = "hello world"
var isTrue bool = true
var slice []int = []int{1, 2, 3, 4, 5}

4.1 基本数据类型

4.1.1 整数类型

有符号整数类型：

无符号整数类型：

其他整数类型：

Golang程序中整型变量在使用时，遵守保小不保大的原则。（在保证程序正确运行下,尽量使用占用空间小的数据类型）

注意：Golang默认声明为int类型

%T为变量类型的占位符。

Sizeof()函数：返回变量占用的字节数

包：unsafe
package main
import (
	"fmt"
	"unsafe"
)

func main(){
	var a int64 = 111;
	fmt.Println(unsafe.Sizeof(a)) // 8
}

4.1.2 浮点类型

注意：浮点类型底层存储：符号位+指数位+尾数位，尾数位可能只存了一部分，很可能会出现精度的损失。

package main
import (
	"fmt"
)

func main(){
	var num1 float32 = 1
	fmt.Println(num1) //1
	var num2 float64 = 1.2323
	fmt.Println(num2) //1.2323
	//科学计数法表示,e/E表示10的多少次方
	var num3 float64 = 1.23e2
	fmt.Println(num3) //12.3
	var num4 float64 = 1.23E-2
	fmt.Println(num4) //0.0123
	//精度对比
	var num5 float32 = 1.23456789
	var num6 float64 = 1.23456789
	fmt.Println(num5) //1.2345679
	fmt.Println(num6) //1.234567919921875
}

4.1.3 字符类型

Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存。
Golang中字符使用UTF-8编码
字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出
字母，数字，标点等字符，底层是按照ASCII进行存储。
汉字字符，底层对应的是Unicode码值 （byte类型溢出，可以用int来存储）
想显示对应的字符，必须采用格式化输出（Printf()）

总结：Golang的字符对应的使用的是UTF-8编码（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案）

package main
import "fmt"
func main(){
		//定义字符类型的数据：
		var c1 byte = 'a'
		fmt.Println(c1)//97
		var c2 byte = '6'
		fmt.Println(c2)//54
		var c3 byte = '('
		fmt.Println(c3 + 20)//40
		//字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出
		//字母，数字，标点等字符，底层是按照ASCII进行存储。
		var c4 int = '中'
		fmt.Println(c4) //20013
		//汉字字符，底层对应的是Unicode码值
		//对应的码值为20013，byte类型溢出，可以用int类型来保存
		//总结：Golang的字符对应的使用的是UTF-8编码（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案）
		var c5 byte = 'A'
		//想显示对应的字符，必须采用格式化输出
		fmt.Printf("c5对应的具体的字符为:%c",c5) //A
}

\转义字符：将后面的字母表示为特殊含义

4.1.4 布尔类型（bool类型）

bool类型数据只允许取值true和false（不能用数字替代）
布尔类型占1个字节
布尔类型适于逻辑运算，一般用于程序流程控制

package main
import "fmt"

func main(){
	var flag1 bool = true //不能直接使用数字来表示布尔类型，只能使用true和false
	var flag2 bool = false
	var flag3 bool = 1 < 10

	fmt.Println(flag1) //true
	fmt.Println(flag2) //false
	fmt.Println(flag3) //true
}

4.1.5 字符串类型

字符串就是一串固定长度的字符连接起来的字符序列。

package main
import "fmt"

func main(){
	//定义字符串类型的数据：
	//字符串定义后，不能修改，不能通过下标来修改
	var s1 string = "I aways miss you"
	fmt.Println(s1) //I aways miss you
	fmt.Println(len(s1)) //16

	// 错误的写法
	// var s2 string
	// v2 = "golang"
	// 正确的写法
	var s2 string = "golang"
	fmt.Println(s2) //golang
	fmt.Println(len(s2)) //6

	// 多行字符串(或有特殊字符)，使用反引号``
	var s3 string = `
		hello
		world
	`
	fmt.Println(s3) //hello
					//world

	//字符串拼接：
	var s4 string = "hello"
	var s5 string = "world"
	var s6 string = s4 + s5 //字符串拼接，不能使用+号拼接数字，只能拼接字符串
	fmt.Println(s6) //helloworld

	//当需要拼接的字符串过多的时候，可以使用+保留在上一行的最后
	var s7 string = "hello" +
		"world" +
		"golang"
	fmt.Println(s7) //helloworldgolang
}

4.1.6 基础数据类型的默认值（零值）

4.1.7 基础数据类型之间的转换

Go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换(强制转换)。
语法：
表达式T(v)将值v转换为类型T
T : 就是数据类型
v : 就是需要转换的变量
在Go语言中，当进行类型转换时，需要确保转换的目标类型能够容纳原始值。如果目标类型无法容纳原始值，编译器会报错。

package main
import "fmt"
func main(){
        //进行类型转换：
        var n1 int = 100
        //var n2 float32 = n1  在这里自动转换不好使
        fmt.Println(n1)
        //fmt.Println(n2)
        var n2 float32 = float32(n1)
        fmt.Println(n2)
        //注意：n1的类型其实还是int类型，只是将n1的值100转为了float32而已，n1还是int的类型
        fmt.Printf("%T",n1)  //int
        fmt.Println()

        //将int64转为int8的时候，编译不会出错的，但是会数据的溢出
        var n3 int64 = 888888
        var n4 int8 = int8(n3)
        fmt.Println(n4)//56

        var n5 int32 = 12
        var n6 int64 = int64(n5) + 30  //一定要匹配=左右的数据类型
        fmt.Println(n5)
        fmt.Println(n6)
		
        var n7 int64 = 12
        var n8 int8 = int8(n7) + 127  //编译通过，但是结果可能会溢出
        //var n9 int8 = int8(n7) + 128 //编译不会通过
        fmt.Println(n8)
        //fmt.Println(n9)
}

4.1.8 基本数据类型转换为string

方式1: fmt.Sprintf("%参数",表达式)
方式2: 使用strconv包的函数

方式1：

package main
import "fmt"

func main(){
	var n1 int = 1111
	var n2 float32 = 4.324
	var n3 bool = true
	var n4 byte = 'a'

	var s1 string = fmt.Sprintf("%d2345",n1)
	var s2 string = fmt.Sprintf("%fabc",n2)
	var s3 string = fmt.Sprintf("%t or false",n3)
	var s4 string = fmt.Sprintf("%c",n4)

	fmt.Printf("s1的类型为：%T\n, s1的值为：%q\n",s1,s1) //s1的类型为：string, s1的值为："11112345"
	fmt.Printf("s2的类型为：%T\n, s2的值为：%q\n",s2,s2) //s2的类型为：string, s2的值为："4.324000abc"
	fmt.Printf("s3的类型为：%T\n, s3的值为：%q\n",s3,s3) //s3的类型为：string, s3的值为："true or false"
	fmt.Printf("s4的类型为：%T\n, s4的值为：%q\n",s4,s4) //s4的类型为：string, s4的值为："a"
}

方式2：

package main
import(
	"fmt"
	"strconv"
)

func main(){
	var n1 int = 1111
	var s1 string = strconv.FormatInt(int64(n1),2) //第一个参数必须转为int64类型，第二个参数2指定字面值的进制形式为二进制
	fmt.Printf("s1的类型为：%T\n, s1的值为：%q\n",s1,s1) //s1的类型为：string, s1的值为："10011001011"
	
	var n2 float64 = 4.324
	var s2 string = strconv.FormatFloat(n2,'f',10,64) //第一个参数必须转为float64类型，第二个参数f指定字面值的进制形式为十进制，第三个参数10指定精度为10位，第四个参数64指定字面值的类型为float64
	fmt.Printf("s2的类型为：%T\n, s2的值为：%q\n",s2,s2) //s2的类型为：string, s2的值为："4.3240000000"

	var b1 bool = true
	var s3 string = strconv.FormatBool(b1)
	fmt.Printf("s3的类型为：%T\n, s3的值为：%q\n",s3,s3) //s3的类型为：string, s3的值为："true"
}

4.1.9 string转为基本类型

方式：使用strconv包的函数

package main
import(
	"fmt"
	"strconv"
)

func main(){
	//string -> bool
	var sl string = "true"
	var b bool
	b,_ = strconv.ParseBool(sl)
	fmt.Printf("b的类型为：%T, b的值为：%v\n",b,b) //b的类型为：bool, b的值为：true

	//string -> int64
	var s2 string = "123456"
	var num1 int64
	num1,_ = strconv.ParseInt(s2,10,64)
	fmt.Printf("num1的类型为：%T, num1的值为：%v\n",num1,num1) //num1的类型为：int64, num1的值为：123456

	//string -> float64
	var s3 string = "123.456"
	var num2 float64
	num2,_ = strconv.ParseFloat(s3,64)
	fmt.Printf("num2的类型为：%T, num2的值为：%v\n",num2,num2) //num2的类型为：float64, num2的值为：123.456

	//注意：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应类型的默认值输出
	var s4 string = "golang"
	var b1 bool
	b1,_ = strconv.ParseBool(s4)
	fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1) //b1的类型是：bool,b1=false

	var s5 string = "golang"
	var num3 int64
	num3,_ = strconv.ParseInt(s5,10,64)
	fmt.Printf("num3的类型是：%T,num3=%v \n",num3,num3) //num3的类型是：int64,num3=0
}

4.2 复杂数据类型

4.2.1 指针

使用&var就可以获取这个变量内存的地址
使用*地址就可以进行取值

package main
import "fmt"

func main(){
	var a int = 10086
	fmt.Println(&a) // 0xc00001a0b8
}

指针变量：

package main

import (
	"fmt"
)

func main() {
	var age int = 18
	//&符号+变量 就可以获取这个变量内存的地址
	fmt.Println(&age)

	//定义一个指针变量：
	//var代表要声明一个变量
	//ptr 指针变量的名字
	//ptr对应的类型是：*int 是一个指针类型 （可以理解为 指向int类型的指针）
	//&age就是一个地址，是ptr变量的具体的值
	var ptr *int = &age
	fmt.Println(ptr)
	fmt.Println("ptr本身这个存储空间的地址为：", &ptr)
	
	//想获取ptr这个指针或者这个地址指向的那个数据：
	fmt.Printf("ptr指向的数值为：%v", *ptr) //ptr指向的数值为：18
}

5、标识符

变量，方法等,只要是起名字的地方,那个名字就是标识符，例如：var a int = 1，a就是一个标识符。
标识符定义规则：由字母（包括中文，但不建议）、数字、下划线_组成。

package main
import "fmt"

func main(){
	//不建议使用中文作为变量名
	var 变量1 = 111
	var 变量2 = "hello"
	fmt.Println(变量1)
	fmt.Println(变量2)
}

注意：

不可以以数字开头，严格区分大小写，不能包含空格，不可以使用Go中的保留关键字 ；
下划线"_"本身在Go中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如:忽略某个返回值)。所以仅能被作为占位符使用，不能单独作为标识符使用。
int,float32,float64等不算是保留关键字，但是也尽量不要使用

package main
import (
	"fmt"
	"strconv"
)

func main(){
	var s2 string = "19"
	var num1 int64
	num1,_ = strconv.ParseInt(s2,10,64)
	fmt.Printf("num1的类型是:%T, num1的值是:%v",num1,num1)//num1的类型是:int64, num1的值是:19
}

起名规则：

包名:尽量保持package的名字和目录保持一致（尽量，不强制），尽量采取有意义的包名，简短，有意义，和标准库不要冲突。

为什么之前在定义源文件的时候，一般我们都用package main 包？

main包是一个程序的入口包，所以你main函数它所在的包建议定义为main包，如果不定义为main包，那么就不能得到可执行文件。

变量名、函数名、常量名 : 采用驼峰法
var stuNum string = "101010111"

如果变量名、函数名、常量名首字母大写，则可以被其他的包访问;

如果首字母小写，则只能在本包中使用（利用首字母大写小写完成权限控制）

import导入语句通常放在文件开头包声明语句的下面。
导入的包名需要使用双引号包裹起来。
根据Go语言的规范，包的导入路径应该是从$GOPATH/src开始的相对路径或者是绝对路径

需要配置一个环境变量：GOPATH

注意：最新版本需要禁止GO111MODULE，否则无法使用GOPATH实现下述操作。
禁止/启用GO111MODULE：
禁止（Windows）：set GO111MODULE=off，请注意，这个设置只在当前cmd会话中有效。

启用（Windows）：set GO111MODULE=on

禁止（PowerShell）：$env:GO111MODULE = "off"，请注意，这个设置只在当前PowerShell会话中有效。

启用（PowerShell）：$env:GO111MODULE = "on’"