• go语言的使用方法

    一.go语言的介绍

    1.简介

    2.应用领域

    3.使用go语言的公司

    4.go语言开发工具介绍

    5.go语言开发环境搭建

    【1】搭建Go开发环境-安装和配置SDK

    基本介绍:

    • 1).SDK的全称(Software Development Kit软件开发工具包）
    • 2).SDK是提供给开发人员使用的，其中包含了对应的开发语言的工具包。

    【2】.SDK下载

    【3】.安装sdk：

    • 请注意:安装路径不要有中文或者特殊符号如空格等
    • SDK安装目录建议:一般我安装在d:golang安装时，基本上是傻瓜式安装，解压可以使用
    • 一定要注意看版本号哦，不然会下错的哦
    • 解压之后会出现一个go的整个文件夹就是配置环境

    6.DOS

    【1】.DOS操作系统

    • --Microsoft公司推出的操作系统。(在windows之前的操作系统)
    • --Dos是英文"Dis Operating System"的缩写，在其中含意是"磁盘操作系统"
    • --Dos是单用户、单任务操作系统(只能执行一个任务)

    【2】.Dos命令

    • --在windows中，我们通过鼠标菜单来操作系统，而在dos操作系统中，要通过dos命令来操作系统。
    • --是Dos操作系统的命令，是一种面向键盘的操作命令
    • --不区分大小写

    【3】命令学习

    • 命令提示符:win+r---->cmd

    【4】具体dos命令

    • 1).显示详细信息:dir

    • 2).清屏:cls
    • 3).切换历史命令:上下箭头
    • 4).补全命令:tab按键
    • 5).创建命令、删除命令:

    7.测试SDK环境搭建成功

    【1】进入到go语言的目录下查看是否安装成功

    【2】如果我想要在任意的路径下执行某个命令，需要将这个命令所在的目录配置到环境变量path中

    【3】.重新验证一下:

    二.go语言的使用

    1.第一段程序:Helloworld快速入门

    【1】.go语言基本结构:

    【2】第一个Helloworld

    1. package main  //声明文件所在的包，每个go文件必须有归属的包
    2. import "fmt" //引入程序中需要用的包，为了使用包下的函数
    3. func main() {  //主函数，程序的入口
    4. 	fmt.Println("Hello Golang!")  //在控制台打印输出一句话，双引号中的内容会原样输出
    5. }

    【3】对源文件test.go进行编译:

    go build

    【4】执行操作:

    【5】通过go run直接可以帮我们编译执行源文件:

    【6】.编译的注意事项:

    可以在编译的时候重新去命名一个新的名字

    2.语法上的注意事项

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

    3.注释的作用:

    • 用于注释说明解释程序的文字就是注释，注释提高了代码的阅读性；
    • 注释是一个程序原必须要具有的良好的编程习惯
    • 将自己的思想通过注释先整理出来，在用代码去体现

    【2】Golang中注释类型

    • 1).行注释 // ctrl +/在按一次取消注释
    • 2).块注释(多行注释) /**/ shift + alt + a再按一次取消注释

    go语言的官方文档库：https://studygolang.com/pkgdoc

    三.基本变量与类型

    变量

    1.变量的引入
    • 一个程序就是一个世界
    • 不论是使用哪种高级程序语言编写程序，变量都是程序的基本组成单位
    2.变量的介绍

    变量相当于内存中一个数据存储空间的表示

    3.变量的使用步揍
    • 声明
    • 赋值
    • 使用

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	// 1.变量的声明
    7. 	var age int
    8. 	// 2.变量的赋值
    9. 	age = 18
    10. 	// 3.变量的使用
    11. 	fmt.Println("age = ", age)
    12.  
    13. 	// 声明和赋值可以合成一句
    14. 	var age2 int = 19
    15. 	fmt.Println("age2 = ", age2)
    16. }

    如果一个变量age被重复定义之后会报错 ，不可以再赋值的时候给不匹配的类型

    4.变量四种的使用形式
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	// 第一种:变量的使用方式
    7. 	var num int = 18
    8. 	fmt.Println(num)
    9. 	// 第二种:使用变量的类型，但是不赋值，使用默认值
    10. 	var num2 int
    11. 	fmt.Println(num2)
    12.  
    13. 	// 第三种:如果没有写变量的类型，那么会根据等号后面的值进行判定变量的类型(自动类型的判断)
    14. 	var num3 = "tom"
    15. 	fmt.Println(num3)
    16.  
    17. 	// 第四种:省略var :=不能写为=
    18. 	sex := "男"
    19. 	fmt.Println(sex)
    20. }

    5.声明多个变量
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 全局变量:定义再函数外面的变量叫做全局变量
    6. var n7 = 100
    7. var n8 = 9.7
    8.  
    9. // 以上定义全局变量太麻烦了，可以一次性声明
    10. var (
    11. 	n9  = 715
    12. 	n10 = "myy"
    13. )
    14.  
    15. func main() {
    16. 	// 定义在{}里面的变量叫做局部变量
    17. 	// 第一种:变量的使用方式
    18. 	var num int = 18
    19. 	fmt.Println(num)
    20. 	// 第二种:使用变量的类型，但是不赋值，使用默认值
    21. 	var num2 int
    22. 	fmt.Println(num2)
    23.  
    24. 	// 第三种:如果没有写变量的类型，那么会根据等号后面的值进行判定变量的类型(自动类型的判断)
    25. 	var num3 = "tom"
    26. 	fmt.Println(num3)
    27.  
    28. 	// 第四种:省略var :=不能写为=
    29. 	sex := "男"
    30. 	fmt.Println(sex)
    31.  
    32. 	fmt.Println("-----------------------------------------------------")
    33.  
    34. 	// 声明多个变量
    35. 	var n1, n2, n3 int
    36. 	fmt.Println(n1)
    37. 	fmt.Println(n2)
    38. 	fmt.Println(n3)
    39.  
    40. 	var n4, name, n5 = 10, "jack", 7.5
    41. 	fmt.Println(n4)
    42. 	fmt.Println(name)
    43. 	fmt.Println(n5)
    44.  
    45. 	n6, height := 6.9, 100.6
    46. 	fmt.Println(n6)
    47. 	fmt.Println(height)
    48.  
    49. 	fmt.Println(n7)
    50. 	fmt.Println(n8)
    51. 	fmt.Println(n9)
    52. 	fmt.Println(n10)
    53. }

    数据类型

    整数类型

    1.整数类型介绍

    简单来说，用于存放整数值的，比如10，-45

    2.有符号整数类型:

    代码测试超出范围:

    3.无符号整数类型

    超出边界报错：

    4.其他数据类型
    类型有无符号占用存储空间
    int有

    32位系统~4字节

    64位系统~8字节

    uint无

    32位系统~4字节

    64位系统~8字节

    rune有等价int32
    byte无等价uint8

    变量占用的字节数:

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"unsafe"
    6. )
    7.  
    8. func main() {
    9. 	// 定义一个整数类型
    10. 	var num1 int8 = 120
    11. 	fmt.Println(num1)
    12.  
    13. 	// var num2 uint8 = 200
    14. 	// fmt.Println(num2)
    15. 	var num3 = 28
    16. 	// printf函数的作用：格式化，把num3类型填充到%p的位置上
    17. 	fmt.Printf("num3的类型是:%p", num3)
    18. 	fmt.Println(unsafe.Sizeof(num3))
    19. }

    浮点类型:

    1.浮点类型介绍:

    简单来说，就是用于存放小数值的，比如3.14、0.28

    2.浮点类型种类:

    • 底层存储空间和操作无关
    • 浮点类型底层存储:符号位+指数位+尾数位，所以尾数位只存了一个大概，很可能会出现精度的损失
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	// 定义浮点类型的数据
    7. 	var num1 float32 = 3.14
    8. 	fmt.Println(num1)
    9. 	// 可以表示正浮点数，也可以表示负浮点数
    10. 	var num2 float32 = -3.14
    11. 	fmt.Println(num2)
    12. 	// 浮点数可以用十进制表示，也可以用科学计数法表示形式，E大小写都可以
    13. 	var num3 float32 = 314e-2
    14. 	fmt.Println(num3)
    15. 	var num4 float32 = 314e+2
    16. 	fmt.Println(num4)
    17. 	var num5 float32 = 314e+2
    18. 	fmt.Println(num5)
    19. 	var num6 float64 = 314e+2
    20. 	fmt.Println(num6)
    21.  
    22. 	// 浮点数可能会有精度损坏，所以通常情况下，建议你使用:float64
    23. 	var num7 float32 = 256.00000000916
    24. 	fmt.Println(num7)
    25. 	var num8 float64 = 256.00000000916
    26. 	fmt.Println(num8)
    27.  
    28. 	// golang中默认的浮点类型为:float64
    29. 	var num9 = 3.17
    30. 	fmt.Printf("num9对应的默认的类型为:%T", num9)
    31. }

    字符类型

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	// 定义字符类型的数据:
    7. 	var c1 byte = 'a'
    8. 	fmt.Println(c1) //97
    9. 	var c2 byte = '6'
    10. 	fmt.Println(c2) //54
    11. 	var c3 byte = '('
    12. 	fmt.Println(c3 + 20) //40
    13. 	// 字符类型,本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出
    14. 	// 字母，数字，标点等字符，底层是按照ASCII进行存储
    15.  
    16. 	var c4 int = '中'
    17. 	fmt.Println(c4)
    18. 	// 汉字字符，底层对应的是Unicode码值
    19. 	// 对应的码值为20013,byte类型溢出，能存储范围:可以用int
    20. 	// 总结:Golang的字符对应的使用是UTF-8编码
    21.  
    22. 	var c5 byte = 'A'
    23. 	// 想显示对应的字符，必须采用格式化输出
    24. 	fmt.Printf("c5对应的具体的字符为:%c",c5)
    25. }

    1.转义字符
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	// 练习转义字符
    7. 	// \n换行
    8. 	fmt.Println("aaa\nbbb")
    9. 	// \b退格
    10. 	fmt.Println("aaa\bbbb")
    11. 	// \r 光标回到本行开头，后续输入就会替换原本的字符
    12. 	fmt.Println("aaaaa\rbbb")
    13. 	// \t制表符
    14. 	fmt.Println("aaaaaaaaaa")
    15. 	fmt.Println("aaaa\tbbbb")
    16. 	fmt.Println("aaaaaaaa\tbbbb")
    17.  
    18. 	// \"
    19. 	fmt.Println("\"Golang\"")
    20. }

    布尔类型

    • 布尔类型也叫bool类型，bool类型只允许取值true和false
    • 布尔类型占1个字节
    • 布尔类型适合于逻辑运算，一般用于流程来控制
      1. package main
      2.  
      3. import "fmt"
      4.  
      5. func main() {
      6. 	// 测试布尔类型的数值:
      7. 	var flag01 bool = true
      8. 	fmt.Println(flag01)
      9.  
      10. 	var flag02 bool = false
      11. 	fmt.Println(flag02)
      12.  
      13. 	var flag03 bool = 5 < 9
      14. 	fmt.Println(flag03)
      15. }

    字符串类型

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

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	// 1.定义一个字符串:
    7. 	var s1 string = "你好全面拥抱Golang"
    8. 	fmt.Println(s1)
    9. 	// 2.字符串是不可变的:指的是字符串一旦定义好，其中的字符的值不能改变
    10. 	// var s2 string = "abc"
    11. 	// s2 = "def"
    12. 	// s2[0] = 't'
    13. 	// fmt.Println(s2)
    14. 	// 3.字符串的表示形式:
    15. 	// (1).如果字符串没有特殊字符，字符串的表示形式用双引号
    16. 	var s3 string = "abcdefghigklmnopqrstuvwsyz"
    17. 	fmt.Println(s3)
    18. 	// (2).如果字符串中有特殊符号，字符串的表示形式用反引号``
    19. 	var s4 string = `
    20. 		package main
    21. 		import "fmt"
    22. 		func main() {
    23. 			// 测试布尔类型的数值:
    24. 			var flag01 bool = true
    25. 			fmt.Println(flag01)
    27. 			var flag02 bool = false
    28. 			fmt.Println(flag02)
    30. 			var flag03 bool = 5 < 9
    31. 			fmt.Println(flag03)
    32. 		}`
    33. 	fmt.Println(s4)
    34.  
    35. 	//4.字符串的拼接效果
    36. 	var s5 string = "abc" + "def"
    37. 	s5 += "hijk"
    38. 	fmt.Println(s5)
    39.  
    40. 	// 5.当一个字符串过长的时候:
    41. 	var s6 string = "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" + "def"
    42.  
    43. 	fmt.Println(s6)
    44. }

    基本类型的默认值

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	var a int
    7. 	var b float32
    8. 	var c float64
    9. 	var d bool
    10. 	var e string
    11. 	fmt.Println(a)
    12. 	fmt.Println(b)
    13. 	fmt.Println(c)
    14. 	fmt.Println(d)
    15. 	fmt.Println(e)
    16. }

     数据类型之间的转换

    • Go在不同类型的变量之间赋值时需要显式转换，并且只有显示转换(强制转换).
    • 表达式T(v)将值转换为类型T
    • T:就是数据类型
    • v:就是需要转换的变量
      1. package main
      2.  
      3. import "fmt"
      4.  
      5. func main() {
      6. 	// 进行类型转换:
      7. 	var n1 int = 100
      8. 	// var n2 float32 = n1 在这里 自动转换不好使，比如显示转换
      9. 	fmt.Println(n1)
      10. 	// fmt.Println(n2)
      11. 	var n2 float32 = float32(n1)
      12. 	fmt.Println(n2)
      13. 	// 注意:n1的类型其实还是int类型，只是将n1的值100转为了float32而已,n1还是int的类型
      14. 	fmt.Printf("%T", n1) //int
      15. 	fmt.Println()
      16.  
      17. 	// 将int64转为int8的时候，编译不会出错的，但是会数据的溢出
      18. 	var n3 int64 = 888888
      19. 	var n4 int8 = int8(n3)
      20. 	fmt.Println(n4) //56
      21.  
      22. 	var n5 int32 = 12
      23. 	var n6 int64 = int64(n5) + 30 //一定匹配=左右的数据类型
      24. 	fmt.Println(n5)
      25. 	fmt.Println(n6)
      26.  
      27. 	var n7 int64 = 12
      28. 	var n8 int8 = int8(n7) + 127 //编译通过，但是结果可能会溢出
      29. 	// var n9 int8 = int8(n7) + 128  //编译不会溢出
      30. 	fmt.Println(n8)
      31. 	// fmt.Println(n9)
      32. }
    1.基本数据类型转为String

    基本数据类型和string的转换介绍

    • 在程序开发中，我们经常需要将基本数据类型转成string类型。或者将string类型转换成基本数据类型

    基本类型转型为string类型

    • 方式1:fmt.Springf("%参数",表达式)  ---- 重点关注，推荐使用
      1. package main
      2.  
      3. import "fmt"
      4.  
      5. func main() {
      6. 	var n1 int = 19
      7. 	var n2 float32 = 4.78
      8. 	var n3 bool = false
      9. 	var n4 byte = 'a'
      10.  
      11. 	var s1 string = fmt.Sprintf("%d", n1)
      12. 	fmt.Printf("s1对应的类型是:%T,s1=%q \n", s1, s1)
      13.  
      14. 	var s2 string = fmt.Sprintf("%f", n2)
      15. 	fmt.Printf("s2对应的类型是:%T,s2=%q \n", s2, s2)
      16.  
      17. 	var s3 string = fmt.Sprintf("%t", n3)
      18. 	fmt.Printf("s3对应的类型是:%T,s3=%q \n", s3, s3)
      19.  
      20. 	var s4 string = fmt.Sprintf("%c", n4)
      21. 	fmt.Printf("s4对应的类型是:%T,s4=%q \n", s4, s4)
      22. }
    • 方式2:使用strconv包的函数
      1. package main
      2.  
      3. import (
      4. 	"fmt"
      5. 	"strconv"
      6. )
      7.  
      8. func main() {
      9. 	var n1 int = 18
      10. 	var s1 string = strconv.FormatInt(int64(n1), 10) //参数:第一个参数必须转为int64类型，第二个参数指定字面值的进制形式为十进制
      11. 	fmt.Printf("s1对应的类型是:%T,s1=%q \n", s1, s1)
      12.  
      13. 	var n2 float64 = 4.29
      14. 	var s2 string = strconv.FormatFloat(n2, 'f', 9, 64)
      15. 	// 第二个参数:'f'(-ddd.ddd) 第三个参数:9保留小数后面9位
      16. 	fmt.Printf("s2对应的类型是:%T,s1=%q \n", s2, s2)
      17.  
      18. 	var n3 bool = true
      19. 	var s3 string = strconv.FormatBool(n3)
      20. 	fmt.Printf("s3对应的类型是:%T,s1=%q \n", s3, s3)
      21. }

    2.String转为基本数据类型

    string类型转为基本数据类型

    方法：使用strconv包的函数

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"strconv"
    6. )
    7.  
    8. func main() {
    9. 	// string --->bool
    10. 	var s1 string = "true"
    11. 	var b bool
    12. 	// ParseBool这个函数的返回值有两个:(value bool,err,error)
    13. 	// value就是我们得到的布尔类型的数据，err出现的错误
    14. 	// b = strconv.ParseBool(s1)
    15. 	// 我们只关注得到的布尔类型的数据，err可以用_直接忽略
    16. 	b, _ = strconv.ParseBool(s1)
    17. 	fmt.Printf("b对应的类型是:%T,b=%v \n", b, b)
    18.  
    19. 	// string --->int64
    20. 	var s2 string = "19"
    21. 	var num1 int64
    22. 	num1, _ = strconv.ParseInt(s2, 10, 64)
    23. 	fmt.Printf("num1的类型是:%T,num1=%v \n", num1, num1)
    24.  
    25. 	// string -->float32/float64
    26. 	var s3 string = "3.14"
    27. 	var f1 float64
    28. 	f1, _ = strconv.ParseFloat(s3, 64)
    29. 	fmt.Printf("f1的类型是:%T,f1=%v \n", f1, f1)
    30.  
    31. 	var s4 string = "true"
    32. 	var b1 bool
    33. 	b1, _ = strconv.ParseBool(s4)
    34. 	fmt.Printf("b1对应的类型是:%T,b1=%v \n", b1, b1)
    35.  
    36. 	// 注意:string向基本数据类型转换的时候，一定确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应类型的默认值输出
    37. 	var s5 string = "19"
    38. 	var num2 int64
    39. 	num2, _ = strconv.ParseInt(s5, 10, 64)
    40. 	fmt.Printf("num2的类型是:%T,num2=%v \n", num2, num2)
    41. }

    复杂数据类型

    1.指针

    基本数据类型和内存：

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. func main() {
    8. 	var age = 18
    9. 	// &符号+变量就可以获取这个变量的内存地址
    10. 	fmt.Println(&age) //0xc00005c030
    11.  
    12. 	// 定义一个指针变量
    13. 	// var 代表要声明一个变量
    14. 	// ptr对应的类型是:*int是一个指针类型(可以理解位指向int类型的指针)
    15. 	// &age就是一个地址,是ptr变量得具体的值
    16. 	var ptr *int = &age
    17. 	fmt.Println(ptr)
    18. 	fmt.Println("ptr本身这个存储空间得地址为:", &ptr)
    19.  
    20. 	// 想获取ptr这个指针或者这个地址指向得那个数据:
    21. 	fmt.Printf("ptr指向得数值为:%v", *ptr) //ptr指向得数值为:18
    22.  
    23. }

     

    指针的细节:

    • 可以通过指针改变指向值
    • 指针变量接收的一定是地址值
    • 指针变量的地址不可以不匹配
    • 铺设：*float32意味着这个指针指向的是float32类型的数据，但是&num对应的int类型的不可以。
    • 基本数据类型(又叫值类型),都对应的指针类型，形式为*数据类型，比如int的对应的指针就是*int,float32对应的指针类型就是*float32,依此类推
    2.标识符:

    变量，方法等，只能是起名字的地方，那个名字叫做标识符

    标识符的定义规则:

    • 三个可以(组成部分):数字,字母,下划线_
    • 不建议使用，建议字母:26字母
    • 四个注意:不可以以数字开头，严格区分大小写，不能包含空格，不可以使用go中的保留关键字。
    • 见名知意：增加可读性
    • 下划线”_“本身在Go中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如：忽略某个返回值)。所以仅能被作为占位符使用，不能单独作为标识符使用。
    • 可以用如下形式，但是不建议：varint=10(int,float32,float64等不算是保留关键字，但是也尽量不要使用)
    • 长度无限制, 但是不建议太长 asdfasdfasdfasdfasdfasdfasdfasdfasdfasfd

    起名规则:

    • (1)包名:尽量保持package的名字和目录保持致， 尽量采取有意义的包名，简短，有意义，不要和标准库不要冲突
    • (2)变量名、函数名、常量名:采用驼峰法。
    • (3)如果变量名、函数名、常量名首字母大写，则可以被其他的包访间;如果首字母小写，则只能在本包中使用

    注意:

    • import导入语句通常放在文件开头包声明语句的下面。
    • 导入的包名需要使用双引号包裹起来。
    • 包名是从$GOPATH/src/后开始计算的，使用/进行路径分隔。

    需要定义一个环境变量

    main/test.go 

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"gocode/testproject01/unit2/demo17/test"
    6. )
    7.  
    8. // 程序的入口函数
    9. func main() {
    10. 	// 如果util.go中定义的是StuNo的话,那么在test.go中应该能够访问到
    11. 	fmt.Println(test.StuNo)
    12. }

    test/utils.go

    1. package test
    2.  
    3. var StuNo int = 20034 //定义学生的学号
     3.关键字和预定义标识符:

    关键字就是程序发明者规定得有特殊含义得单词，又叫保留字。go语言中一共有25个关键字

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

     

    四.运算符

    1.算术运算符

    算数运算符:+_*/%++,--

    算术运算符是对数值类型得变量进行运算的，比如，加减乘除

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	// +加号
    7. 	// 1.正数2.相加操作3.字符串拼接
    8. 	var n1 int = +10
    9. 	fmt.Println(n1)
    10. 	var n2 int = 4 + 7
    11. 	fmt.Println(n2)
    12. 	var s1 string = "abc" + "def"
    13. 	fmt.Println(s1)
    14.  
    15. 	//  / 除号
    16. 	fmt.Println(10 / 3)   //两个int类型数据运算,结果一定为整数类型
    17. 	fmt.Println(10.0 / 3) //浮点类型参与运算,结果为浮点类型
    18.  
    19. 	// %取模,等价公式
    20. 	fmt.Println(10 % 3)
    21. 	fmt.Println(-10 % 3)
    22. 	fmt.Println(10 % -3)
    23. 	fmt.Println(-10 % -3)
    24.  
    25. 	// ++自增操作
    26. 	var a int = 10
    27. 	a++
    28. 	fmt.Println(a)
    29. 	// ++自增 加1操作,--自减 减1操作
    30. 	// go语言里,++,--操作非常简单,只能单独使用,不能参与到运算中
    31. 	// ++,--只能再变量后面,不能写在变量的前面 --a  ++a都是错误的
    32. }

     

    2.赋值运算符

    • 赋值运算符:=,+=,-=*=,/=,%=
    • 赋值运算符就是将某个运算后得值，赋给指定的变量
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	var num1 int = 10
    7. 	fmt.Println(num1)
    8. 	var num2 int = (10+20)%3 + 3 - 7 //=右侧得值清楚后,再赋值给左侧
    9. 	fmt.Println(num2)
    10.  
    11. 	var num3 int = 10
    12. 	num3 += 20
    13. 	fmt.Println(num3)
    14.  
    15. 	// 练习:交换两个值并输出结果
    16. 	var a int = 8
    17. 	var b int = 4
    18. 	fmt.Printf("a = %v,b = %v", a, b)
    19. 	// 交换
    20. 	// 引入一个中间变量
    21. 	var t int
    22. 	t = a
    23. 	a = b
    24. 	b = t
    25. 	fmt.Printf("a = %v,b=%v", a, b)
    26. }

  • 相关阅读:
    知识图谱相关的操作
    vue实现一个基础的虚拟列表
    vue3全屏功能实现
    悠易科技LinkFlow徐涛：CDP就是数字营销时代的ERP
    移动云获取推拉流地址
    java Maven入门笔记
    稀疏数组举例详解（Java形式表示）
    机器学习和数据挖掘01- lasso regularization
    【Azure 环境】【Azure Developer】使用Python代码获取Azure 中的资源的Metrics定义及数据
    数组篇-其之一-数组的概念与一维数组
  • 原文地址：https://blog.csdn.net/2201_76041915/article/details/139236717