Golang学习历程【第二篇 fmt包&变量、常量的界说】

前言：包是指由官方大概自界说的一系列功能集合体。使用前需要先引入，例如本日所讲的fmt包。引入方式如下： import "fmt"
  1. fmt 包

   fmt 包是一个非常重要且广泛使用的尺度库包，它提供了格式化I/O（输入/输出）功能，类似于C语言中的 printf 和 scanf。通过这个包，你可以读取输入并将数据格式化输出到尺度输出或其他写入器（writers）
  1.1 打印（print）

   打印功能，简单来说就是体系输出功能，英文简义为Print，驼峰命名，首字母大写，后缀ln换行寄义。后缀f体现可格式化打印
  1.1.1 Print 打印

1. // package 包声明： 可以理解为一个文件夹
2. package main
4. // import 导入：一般指导入官方或自定义功能包
5. import "fmt"
7. // main函数 入口函数
8. func main() {
9.         /**
10.          * 打印输出功能
11.          */
12.         fmt.Print('C')           // 打印字符，单引号，语法灵活易学
13.         fmt.Print("a")           // 打印字符串
14.         fmt.Print("Hello World") // 打印字符串，双引号
15.         fmt.Print(123)           // 打印整数
16.         fmt.Print(3.1415926)     // 打印小数
17.         fmt.Print(true)          // 打印布尔值
18. }

复制代码

上述效果：

1. 67aHello World1233.1415926true

复制代码

  总结：Print仅打印功能，可打印任意类型，仔细的朋侪可能发现，单引号字符串'C'输出效果为67，单引号代表单个字符，输出的效果是ASCII值，双引号体现打印字符串。如果使用'ABC'。运行效果会报错more than one character in rune literal。中文意思是：符文笔墨中有多个字符。
  1.1.2 Println 打印后换行

上述代码如果使用Println 打印，代码如下：
注：以下代码以后只表现关键代码段，main函数不予展示。

1. fmt.Println('C')           // 打印字符，单引号，语法灵活易学
2. fmt.Println("a")           // 打印字符串
3. fmt.Println("Hello World","你好") // 打印字符串，双引号
4. fmt.Println(123)           // 打印整数
5. fmt.Println(3.1415926)     // 打印小数
6. fmt.Println(true)          // 打印布尔值

复制代码

效果清楚明了，如下：

1. 67
2. a
3. Hello World 你好
4. 123        
5. 3.1415926
6. true

复制代码

1.1.3 Printf 打印格式化参数

可指定格式打印。常用格式类型如下：
格式化符号形貌重要程度(个人观点)%T打印变量类型高%v以默认格式输出变量高%t输出 true 或 false高%b二进制体现高%cUnicode 对应字符低%d十进制体现高%o八进制体现高%x十六进制体现（小写字母）高%X十六进制体现（大写字母）低%UUnicode 格式输出低%f十进制浮点数高%e科学计数法（小写 e）低%E科学计数法（大写 E）低%g主动选择 %f 或 %e 的简便体现高%s平凡字符串高%q带双引号的字符串或字符低%p指针地址低 示例代码：

1. fmt.Printf("布尔值：%t \n", false)          // 打印布尔值
2. fmt.Printf("Unicode 65对应字符：%c \n", 65)  // Unicode 对应字符
3. fmt.Printf("默认格式65：%v \n", 65)           // 二进制打印
4. fmt.Printf("二进制65：%b \n", 65)           // 二进制打印
5. fmt.Printf("十进制65：%d \n", 65)           // 十进制打印
6. fmt.Printf("八进制65：%o \n", 65)           // 八进制打印
7. fmt.Printf("十六进制1024（小）：%x \n", 1024)   // 十六进制小写打印
8. fmt.Printf("十六进制1024（大）：%X \n", 1024)   // 十六进制大写打印
9. fmt.Printf("'C' Unicode值：%U \n", 'C')   // Unicode输出
10. fmt.Printf("浮点数：%f \n", 3.1415926)      // 十进制浮点数
11. fmt.Printf("科学计数法（小）：%e \n", 3.1415926) // 科学计数法（小写 e）
12. fmt.Printf("科学计数法（大）：%E \n", 3.1415926) // 科学计数法（大写 e）

复制代码

运行效果：

1. 布尔值：false
2. Unicode 65对应字符：A
3. 默认格式65：65
4. 二进制65：1000001
5. 十进制65：65
6. 八进制65：101
7. 十六进制1024（小）：400        
8. 十六进制1024（大）：400        
9. 'C' Unicode值：U+0043
10. 浮点数：3.141593
11. 科学计数法（小）：3.141593e+00
12. 科学计数法（大）：3.141593E+00

复制代码

1.2 输入(Scan)

   输入用Scan体现，后缀f体现格式化输入
  1.2.1 Scan 输入

示例：

1. // 基本变量声明：var <变量名> <类型>
2. var name string // 声明字符串类型
3. var age int     // 声明整数类型
4. fmt.Print("请输入姓名和年龄：")
5. fmt.Scan(&name, &age) // 录入姓名和年龄
6. fmt.Printf("name=%s,age=%d \n", name, age) // 格式化输出姓名和年龄

复制代码

运行效果：

1. 请输入姓名和年龄：张三 18
2. name=张三,age=18  

复制代码

1.2.2 Scanf 格式化输入

示例：

1.         // 基本变量声明：var <变量名> <类型>
2.         var name string // 声明字符串类型
3.         var age int     // 声明整数类型
4.         fmt.Print("请输入姓名和年龄：")
5.         fmt.Scanf("%s %d", &name, &age)
6.         fmt.Printf("name=%s,age=%d \n", name, age)

复制代码

运行如下示例，体验到：Go语言灵活多变，适合0底子学习

1. PS F:\go_project> go run main.go
2. 请输入姓名和年龄：张三
3. name=张三,age=0
4. PS F:\go_project> go run main.go
5. 请输入姓名和年龄：张三 18
6. name=张三,age=18
7. PS F:\go_project> go run main.go
8. 请输入姓名和年龄：张三 李四
9. name=张三,age=0
10. PS F:\go_project> go run main.go
11. 请输入姓名和年龄：张三 李四 18
12. name=张三,age=0
13. PS F:\go_project> go run main.go
14. 请输入姓名和年龄：张三 18 李四
15. name=张三,age=18
16. PS F:\go_project> go run main.go
17. 请输入姓名和年龄：18 张三
18. name=18,age=0     
19. PS F:\go_project>

复制代码

2. 变量

   变量，存储数据的容器，可以存放任何数据值。变量名由字母、数字、下划线组成，数字不能开头。Go中的关键字和生存字不能作为变量名
  2.1 变量的声明

声明变量，指的是界说变量
总共有以下几种方式：

1. // var <变量名> <数据类型>
2. var a string
3. // var <变量名>=<值>
4. var b = "张三"
5. fmt.Printf("a=%v,b=%v", a, b) // a没有赋值，默认为空

复制代码

效果：

1. a=,b=张三

复制代码

---

默认初始值测试：

1. var a string                                     // 字符串，默认为空
2. var b int                                        // 整型，默认为0
3. var c bool                                       // 布尔值，默认为false
4. var d float32                                    // 浮点类型，默认为0
5. fmt.Printf("a=%v, b=%v, c=%v, d=%v", a, b, c, d) // a没有赋值，默认为空

复制代码

效果

1. a=, b=0, c=false, d=0

复制代码

  提示：Go语言中变量声明必须使用，否则会报错提示 declared and not used，意思是声明了并没有使用
  

---

2.2 变量初始化，赋值

1. // 变量初始化声明的三种方式
2. // 1.1 先声明变量 格式： var <变量名> <变量类型>
3. var name string
4. // 1.2 后赋值 格式：<变量名> = <值>
5. name = "张三"
6. // 2. 声明的同时进行赋值 格式：var <变量名> = <值>
7. var age = 18
8. // 3.短变量声明法 格式：<变量名> := <值>
9. sex := "男"
10. score := 80
11. fmt.Print(name, age, sex, score)

复制代码

效果：

1. 张三18男80

复制代码

2.2 声明多个变量

1. // 1. 一次声明相同类型 var <变量名1>,<变量名2>... <数据类型>
2. var a1, a2, a3 string
3. a1 = "张三"
4. a2 = "李四"
5. a3 = "王五"
6. fmt.Println(a1, a2, a3)
7. /*
8.          * 2. 先声明，后赋值
9.                  var (
10.                         <变量名1> <数据类型>
11.                         <变量名2> <数据类型>
12.                         ...
13.                 )
14. */
15. var (
16.         name string
17.         age  int
18. )
19. name = "赵六"
20. age = 20
21. fmt.Println(name, age)
22. /*
23.         3. 声明即赋值
24.         var (
25.                 <变量名1> = <值>
26.                 <变量名2> = <值>
27.                 ...
28.         )
29. */
30. var (
31.         num1 = 1
32.         num2 = 2
33. )
34. fmt.Println(num1, num2)
35. // 4. 短变量声明法 <变量名1>,<变量名2>,<变量名3> := <值1>,<值2>,<值3>
36. num3, num4, num5 := 3, 4, "Hello"
37. fmt.Println(num3, num4, num5)

复制代码

效果：提示：Println具有加空格及换行功能

1. 张三 李四 王五
2. 赵六 20
3. 1 2
4. 3 4 Hello

复制代码

  var声明可用于全局界说使用，短变量声明只能用于局部变量。
  2.3 匿名变量

   匿名变量顾名思义没有变量名，一次性吸收，用_体现
  示例：

1. package main
3. import "fmt"
5. // 先举示例，函数的定义后续学习讲解
6. func getUserInfo() (string, int) {
7.         return "zhangsan", 10
8. }
10. // main函数 入口函数
11. func main() {
12.         // var声明接收
13.         var name, age = getUserInfo()
14.         fmt.Println(name, age)
15.         // _匿名变量，用于丢弃赋值
16.         var _, age1 = getUserInfo()
17.         fmt.Println(age1)
18.         var name1, _ = getUserInfo()
19.         fmt.Println(name1)
20. }

复制代码

效果：

1. zhangsan 10
2. 10
3. zhangsan

复制代码

  匿名变量不占用命名空间，可以重复使用，但是var，:=声明的变量名称不可重复
  3. 常量

   变量是可以修改，变更的值，而常量是不可改变的值，用const声明
  3.1 常量的声明

1.         // const 定义一个常量 * 最常用
2.         const A = "TEST1"
3.         fmt.Println(A)
4.         // 定义多个常量
5.         const (
6.                 B = "TEST2"
7.                 C = "TEST3"
8.                 D = "TEST4"
9.         )
10.         fmt.Println(B, C, D)
11.         // 定义多个常量，给定一个值
12.         const (
13.                 E = "TEST5"
14.                 F
15.                 G // 值默认与上一个相同
16.                 H = "TEST6"
17.                 I // 值默认与上一个相同
18.         )
19.         fmt.Println(E, F, G, H, I)

复制代码

效果：

1. TEST1
2. TEST2 TEST3 TEST4
3. TEST5 TEST5 TEST5 TEST6 TEST6

复制代码

3.2 iota 自增长

   iota为Go中的计数器，常与const结合使用
  示例：

1.         // iota 计数器使用
2. const (
3.         n1          = iota                 // 0
4.         n2                                 // 1
5.         _                                  // 匿名跳过计数
6.         n3                                 // 3
7.         n4          = iota                 // 4
8.         n5                                 // 5
9.         n6          = 100                  // 100 插队赋值
10.         n7          = iota                 // 7
11.         n8, n9, n10 = iota, iota, iota + 1 // 8,8,9 多变量声明iota不会计数叠加，
12. )
13. fmt.Println(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10)

复制代码

效果：

1. 0 1 3 4 5 100 7 8 8 9

复制代码

4. 总结：Go常量变量命名规则

• 变量名必须由数字，字母，下划线_组成
  
• 标识符开头不能是数字
  
• 标识符不能是生存字和关键字(var、if、where等)
  
• 变量的名字是严格区分大小写的，name、Name、NAme以及NAME是差别的四个变量。Go语法支持，但不推荐如许写。
  
• 变量界说尽可能见名思意
  
• 变量名一般接纳驼峰命名法。驼峰命名：首字母小写，后续每个单子首字母大写，例如：maxAge。如果是专属名词，例如DNS,IP等，可直接接纳大写。
  

   上一篇：Golang学习历程【第一篇 入门】
下一篇：Golang学习历程【第三篇 基本数据类型】 待续。。。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。