当前位置： 首页 > news >正文

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

news 2024/11/3 3:19:29

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、变量

变量的使用：

  1. 声明
  2. 赋值
  3. 使用

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

package main
import "fmt"//全局
var aa int = 1func main(){//声明变量var a int//变量赋值a = 10//变量使用fmt.Println(a)//声明变量并赋值var str string = "hello world"//变量使用fmt.Println(str)//局部var aa int = 3fmt.Println(aa)//输出3，局部变量优先
}

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

方式二：自动类型推断

package main
import "fmt"//全局变量
var glo1 = 100
var glo2 = "str"//不能在函数外面使用:=，:=只能在函数里面使用
glo5 := 300//全局变量一次性声明
var(glo3 = 200glo4 = "hello"
)func main(){//局部变量//1、指定变量类型，并赋值var n1 int = 10fmt.Println(n1)//2、指定变量类型，不赋值，使用默认值var n2 intvar n3 stringfmt.Println(n2) //0fmt.Println(n3) //""//3、不指定变量类型，根据值自行判断变量类型var n4 = 100var n5 = "hello"fmt.Println(n4)fmt.Println(n5)//4、省略var，注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误n6 := 200n7 := "world"fmt.Println(n6)fmt.Println(n7)//5、一次性声明多个变量var n8,n9 int = 100,200var n10,n11 string = "hello","world"fmt.Println(n8,n9)fmt.Println(n10,n11)//6、一次性声明多个变量，省略varn12,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语言的数据类型可以分为以下几类：

  1. 基本数据类型：

    • 整数类型：int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, byte (等价于 uint8), rune (等价于 int32)
    • 浮点数类型：float32, float64
    • 布尔类型：bool
    • 字符串类型：string

  2. 复合数据类型：

    • 数组类型：[n]T，其中 n 是数组的长度，T 是数组元素的类型。
    • 切片类型：[]T，切片是动态数组，可以自动增长。
    • 映射类型：map[K]V，映射是键值对的集合，其中 K 是键的类型，V 是值的类型。
    • 结构体类型：struct，结构体是由一系列具有相同或不同类型的字段组成的数据集合。
    • 指针类型：*T，指针是变量的内存地址。
    • 函数类型：func，函数是可以被调用的代码块。
    • 接口类型：interface，接口是一组方法的签名，任何实现了这些方法的类型都可以称为实现了该接口。

  3. 其他数据类型：

    • 通道类型：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 = 1fmt.Println(num1) //1var num2 float64 = 1.2323fmt.Println(num2) //1.2323//科学计数法表示,e/E表示10的多少次方var num3 float64 = 1.23e2fmt.Println(num3) //12.3var num4 float64 = 1.23E-2fmt.Println(num4) //0.0123//精度对比var num5 float32 = 1.23456789var num6 float64 = 1.23456789fmt.Println(num5) //1.2345679fmt.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)//97var c2 byte = '6'fmt.Println(c2)//54var 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和falsevar flag2 bool = falsevar flag3 bool = 1 < 10fmt.Println(flag1) //truefmt.Println(flag2) //falsefmt.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 youfmt.Println(len(s1)) //16// 错误的写法// var s2 string// v2 = "golang"// 正确的写法var s2 string = "golang"fmt.Println(s2) //golangfmt.Println(len(s2)) //6// 多行字符串(或有特殊字符)，使用反引号``var s3 string = `helloworld`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)  //intfmt.Println()//将int64转为int8的时候，编译不会出错的，但是会数据的溢出var n3 int64 = 888888var n4 int8 = int8(n3)fmt.Println(n4)//56var n5 int32 = 12var n6 int64 = int64(n5) + 30  //一定要匹配=左右的数据类型fmt.Println(n5)fmt.Println(n6)var n7 int64 = 12var 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 = 1111var n2 float32 = 4.324var n3 bool = truevar 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 = 1111var 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.324var s2 string = strconv.FormatFloat(n2,'f',10,64) //第一个参数必须转为float64类型，第二个参数f指定字面值的进制形式为十进制，第三个参数10指定精度为10位，第四个参数64指定字面值的类型为float64fmt.Printf("s2的类型为：%T\n, s2的值为：%q\n",s2,s2) //s2的类型为：string, s2的值为："4.3240000000"var b1 bool = truevar 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 -> boolvar sl string = "true"var b boolb,_ = strconv.ParseBool(sl)fmt.Printf("b的类型为：%T, b的值为：%v\n",b,b) //b的类型为：bool, b的值为：true//string -> int64var s2 string = "123456"var num1 int64num1,_ = strconv.ParseInt(s2,10,64)fmt.Printf("num1的类型为：%T, num1的值为：%v\n",num1,num1) //num1的类型为：int64, num1的值为：123456//string -> float64var s3 string = "123.456"var num2 float64num2,_ = 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 boolb1,_ = strconv.ParseBool(s4)fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1) //b1的类型是：bool,b1=falsevar s5 string = "golang"var num3 int64num3,_ = 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 = 10086fmt.Println(&a) // 0xc00001a0b8
}

指针变量：

package mainimport ("fmt"
)func main() {var age int = 18//&符号+变量 就可以获取这个变量内存的地址fmt.Println(&age)//定义一个指针变量：//var代表要声明一个变量//ptr 指针变量的名字//ptr对应的类型是：*int 是一个指针类型 （可以理解为 指向int类型的指针）//&age就是一个地址，是ptr变量的具体的值var ptr *int = &agefmt.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 = 111var 变量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 int64num1,_ = 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’"



 

6、关键字和预定义标识符

关键字就是程序发明者规定的有特殊含义的单词，又叫保留字。 

 预定义标识符：一共36个预定标识符，包含基础数据类型和系统内嵌函数


http://www.mrgr.cn/news/64432.html

相关文章：

  • 【C++ 算法进阶】算法提升九
  • Linux 安装MySQL(Cenots版本)
  • ML2001-1 机器学习/深度学习 Introduction of Machine / Deep Learning
  • TestNG详解，Java自动化用例管理利器！
  • 部署Prometheus、Grafana、Zipkin、Kiali监控度量Istio
  • 鸿蒙系统：核心特性、发展历程与面临的机遇与挑战
  • 图文深入介绍Oracle DB link（二）
  • 【资调实习报告】华中农业大学资源调查与评价实习报告
  • 信息学奥赛一本通 1394：连接格点(grid)
  • R6：LSTM实现糖尿病探索与预测
  • 基于微信小程序的校园失物招领系统的研究与实现（V4.0）
  • 0-1规划的求解
  • Java 中 HashMap集合使用
  • wireshark抓包查看langchain的ChatOpenAI接口发送和接收的数据
  • next项目app router 中layout命名规范
  • ViT面试知识点
  • Google Guava 发布订阅模式/生产消费者模式 使用详情
  • SpringMVC的执行流程以及运行原理
  • 单链表OJ题（3）：合并两个有序链表、链表分割、链表的回文结构
  • Oracle视频基础1.4.2练习
  • FFmpeg 4.3 音视频-多路H265监控录放C++开发十. 多线程控制帧率。
  • 大学新生入门编程的最佳选择：为什么我推荐Python？
  • RSI是指在5G通信技术中用于标识小区的特定参数
  • Spring框架中的AOP是什么？如何使用AOP实现切面编程和拦截器功能？
  • 3.2链路聚合
  • P3-2.【结构化程序设计】第二节——知识要点：多分支选择语句