7.常量
常量是一个简单的值的标识符，在程序运行时，不会被修改的量。
const 常量名 [type]= 值
常量中的数据类型值可以是布尔型、数字型(整数、浮点和复数)和字符串型
我们可以省略说明符 [type],因为编译器可以根据变量的值来判断其类型。
- 显式类型定义: const b string=“abc”
- 隐式类型定义: const b=“abc”
多个不同类型的声明可以简写为:
const a, b, c = 3.14, "sdsd", 20
package main // 这里的包一定要写成 main. import "fmt" // 导入包 func main() { // 主函数 const URL string = "www.jsxs1.cn:8089" //显式定义 const URL2 = "www.jsxs1.cn:8091" //隐式定义 const a, b, c = 3.14, "sdsd", 20 fmt.Println(URL) fmt.Println(URL2) fmt.Println(a, b, c) }
8.常量iota💥
iota , 特殊常量，可以认为是一个可以被编译器修改的常量。iota是go语言的常量计数器。
iota在const关键字出现时将被充值为0 (const内部的第一行之前),const中每新增一行常量声明将使iota基数一次 (iota可理解为const语句块中的行索引)。
iota 可以被用作枚举值:
假如说被其他值给打断了，那么就会复制上面的值直到新出来一个iota
package main // 这里的包一定要写成 main. import "fmt" // 导入包 func main() { // 主函数 const ( a = iota //0 b // 1 c // 2 d // 3 e // 4 f = "sdsds" g // sdsds h = 100 i //100 j = iota // 9 k // 10 ) const ( m = iota n ) fmt.Println(a, b, c, d, e, f, g, h, i, j, k, m, n) }
(四)、基本数据类型
Go语言是一种静态类型的编程语言，在Go编程语言中，数据类型用于声明函数和变量。数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要大数据的时候才需呀申请大内存，就可以充分利用内存，编译器进行编译的时候，就要知道每个值的类型，这样编译器就知道要为这个值分配多少内存，并且知道这段分配的内存表示什么。
1.布尔类型 (bool)
%T 是类型, %t 是值
package main // 这里的包一定要写成 main. import "fmt" func main() { // 主函数 var isFlag bool = true //默认为false fmt.Println(isFlag) // 打印输出类型 fmt.Printf("类型是: %T, 值是: %t\n", isFlag, isFlag) // %T是类型 %t是值 \n是换行 }
2.数字型 (int float byte)
整形 int 和浮点型 float32.float64.Go语言支持整形和浮点型数字，并且支持复数，其中位的运算采用补码。
Go也有基于架构的类型，列如: unit 无符号、int 有符号(可为负数)
| 序号 | 类型和描述 |
| 1 | byte 类似于uint8 |
| 2 | rune 类似于 int32 |
| 3 | uint 32 或 64 |
| 4 | int 32或 64 |
| 5 | uintptr 无符号整形,用于存放一个指针 |
package main // 这里的包一定要写成 main. import "fmt" func main() { // 主函数 // 定义一个整形 var age int = 18 fmt.Printf(" %T , %d ", age, age) // 类型依旧是 %T; 但整形是%d取值 // 定义一个浮点型 var money float32 = 20.31 fmt.Printf(" %T , %.2f ", money, money) // 类型依旧是 %T; 但浮点型是%f取值->默认保留6位小数，%.nf 保留n位小数 }
3.字符串 (string)
字符串就是遗传固定长度的字符链接起来的字符序列
Go的字符串是由单个字节连接起来的，GO语言的字符串使用UTF-8编码表示和Unicode文本。
package main // 这里的包一定要写成 main. import "fmt" func main() { // 主函数 // 字符串 -> 双引号 var str string str = "hello jsxs" fmt.Printf(" %T , %s\n", str, str) // 类型依旧是%T, 但是字符串的值是: %s // 字符 -> 单引号 var v1 int32 = 'A' v2 := 'B' fmt.Printf("%T,%c\n", v1, v1) fmt.Printf("%T,%c\n", v2, v2) fmt.Println("hello"+"world") //字符串的拼接使用+或者,进行链接，其他的使用,进行链接 fmt.Println("hello ", "world") //字符串的拼接使用+号进行链接，字符串和其他类型拼接需要使用,进行链接 }
- Go语言的字符串链接可以通过 + 实现 或者 , 实现
- Go语言的字符串与其他非字符串的链接使用的是: ,
- 双引号指的是: 字符串, 单引号指的是 字符
- 字符用 %c来定义，其类型是 int32
- 转义字符 \n 换行 \t 空格
4.数据类型的转换
在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值，由于Go语言不存在隐式类型转换,因此所有的类型转化都必须显式的声明:
转换成的类型type(被转换的变量名)
package main // 这里的包一定要写成 main. import "fmt" func main() { // 主函数 var ( a int = 5 b float32 = 5.0 ) // 需求: 将int类型的a转换位 float64类型 var c float64 = float64(a) d := int(b) fmt.Printf("%T\n", a) fmt.Printf("%T\n", b) fmt.Printf("%T\n", c) fmt.Printf("%T\n", d) }
类型转换只能定义正确的情况下才能转换成功，列如一个取值范围较小的类型转换到一个取值范围较大的类型 (将int16转换到int32).当从一个取值范围较大的类型转换到取值范围较小的类型时(将int32转换到int16时),会发生精度丢失的问题(截断)
(五)、派生数据类型
1.指针类型 (*)
指针变量指向了一个值的内存地址
指针类型的声明格式为var var_name *var-type，使用*类型表示为某某类型的指针。
- 比如
var ptr *string就表示ptr为指向string类型的指针。指针的赋值为&变量名称。 - 比如 var a = “abcde”；var ptr = &a，同样的，指针类型可以根据值自动判断类型。
- 如果只定义了指针变量，而并没有给他赋值，那么该指针就会指向一个空的内存地址，也就是nil，类似其他语言中的null
- 指针的意思: 就是指向一个地址,它的值是一个门牌号(地址)
var var_name *var-type
package main // 这里的包一定要写成 main. import "fmt" var a = "abcde" var ptr *string //声明一个string类型的指针 var ptr1 *string = &a //声明一个string类型的指针 func main() { // 主函数 fmt.Println(ptr) //当前指针ptr为空 ptr = &a //让ptr指向a的内存地址 fmt.Println(ptr) //现在ptr指向a的内存地址了 fmt.Println(ptr1) // 获取地址 fmt.Println(*ptr1) //获取值 }
2.数组类型 ([])
数组是一组长度固定的统一数据类型的集合，注意：不同长度的数组属于不同的数据类型
数组的声明方式也很简单var a [n]int，n为数组的长度。后面我们会认识切片slice，其与数组最大的区别就是切片没有固定长度，是对数组的引用，所以在GO中切片比数组要常用许多。
数组的三种定义方式
// 数组的第一中定义 var a [3]int = [3]int{1, 2, 3} // 数组的第二种定义 var b [3]int b[0] = 1 // 数组的第三种定义方式 c := [3]int{1, 2, 3} fmt.Println(a, " ", b, " ", c)
for i, v := range a { // 这里的i是 idex,v是 value fmt.Printf("%d %d\n", i, v) }
数组的遍历
package main // 这里的包一定要写成 main. import "fmt" func main() { // 主函数 a := [3]int{1, 2, 3} // 定义长度为3的数组，并且初始化值为1,2,3 fmt.Println("以下是下标和值: ") //range循环数组的时候可以循环下标和值 for i, v := range a { // 这里的i是 idex,v是 value fmt.Printf("%d %d\n", i, v) } fmt.Println("以下是值: ") //也可以只循环值，把下标丢弃 for _, v := range a { fmt.Printf("%d\n", v) } }
