3.Go语言变量与常量

基本结构说明

package main //包定义，main是生成可执行文件，其他的是提供给别人使用的类包
import "fmt" //导入语句，使用双引号包裹
//函数外面，只能做声明，而不能写逻辑语句
func main() {//main包一定要有一个main函数，是程序的入口函数，没有参数也没有返回值
    fmt.Println("hello word")
}
1
2
3
4
5
6

标识符

go语言中标识符由字母数字下划线组成，并且只能以字母和下划线开头。比如_12,abc,a123,a_1

关键字

特殊含义的标识符，关键字和保留字都不建议作为变量名。
go语言中有25个关键字，37个保留字。
https://learnku.com/go/t/46645

常量

恒定不变的值。多运用于运行期间不会改变的值。
常量在定义的时候必须赋值。

//单个定义
const pi = 3.14
//批量定义
const (
    pi = 3.14
    e = "test"
)

const (
    n1 = 100
    n2
    n3   //批量声明常量，如果某一行没有赋值，默认和上面的值是一样的
)
1
2
3
4
5
6
7
8
9
10
11
12
13

iota

是go语言的常量计数器，只能在 常量的表达式中使用。

在const关键字出现时，会被重置为0，每声明 一行，计数一次

const (
    n1 = iota //0
    n2 //1
    n3 //2
    n4 //3
)
1
2
3
4
5
6

package main
import "fmt"
const (
    d1, d2 = 1 + iota, 2 + iota
    d3, d4 = 2 + iota, 3 + iota
)
func main() {
    fmt.Println(d1) //1
    fmt.Println(d2) //2
    fmt.Println(d3) //3
    fmt.Println(d4) //4
}
1
2
3
4
5
6
7
8
9
10
11
12

变量

1）为什么有变量

相当于我们的名字，定位准确

2）变量的类型

• string
• int
• bool

3）变量声明

先声明再使用。

var a int : 声明一个变量，必须有类型

var name string
var age int
var isOk bool  // go语言中推荐使用小驼峰命名方式


//批量声明
var (
    name string
    age int
    isOk bool
)

//声明变量之后，变量是对应类型的空值

//赋值
name = "hello"

//变量声明了未使用，会编译失败。（全局的可以编译过去）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4）标准声明

var s1 string = "王小二" //声明变量并且同时赋值
var s2 = "王小二"  //类型自动推导
s3 := "哈哈哈" //简短声明，只能函数内使用
1
2
3

匿名变量:不占用内存
单独的下划线表示
x, := foo();

注意事项：
1.函数外的每个语句都必须以关键字开始（var const func等）
2. := 不能在函数外使用
3. _ 表示占位，忽略值
4. 用一个作用域中不能重复声明同一个变量。

5）基本数据类型

基本数据类型： 整型、浮点型、 布尔型、字符串、
复杂的数据类型：数组、切片、结构体、函数、map、通道

整型

• 1.带符号的整数类型：int8\int16\int32\int64
• 2.不带符号的整数: uint8\uint16\uint32\uint64
• 3.特殊整型：uint、int根据操作系统; uintptr 无符号整型用于存放一个指针。注意不同操作系统上的兼容问题。

八进制数和十六进制数：

八进制数前缀为0

var b int = 077
1

十六进制数，前缀0X

var b int = 0xff
1

%s表示字符串
%d表示十进制数
%o表示八进制数（文件权限）
%x表示十六进制数（内存地址）
%b表示二进制数据
%T表示数据类型

fmt.Printf("%d", d1) d1 //不同进制的数字在打印的时候会转换为10进制的数字输出
1

上面的数都是int类型的
怎么查看变量的类型

浮点型

• float32
• float64

两个类型的变量不能互相赋值，两个数据的类型完全不同。go属于强类型语言

复数

用的比较少,一般用于搞科学运算
复数有实部和虚部，

z = a+bi

a 称为实部，b 称为虚部，i 称为虚数单位

complex64
complex128

package main
import "fmt"
var c1 complex64
var c2 complex128
func main() {
    c1 = 1 + 2i
    c2 = 2 + 3i
    fmt.Printf("%T", c1) //complex64
    fmt.Printf("%T", c2) //complex128
}
1
2
3
4
5
6
7
8
9
10

布尔型

声明之后的默认值是fasle
不允许将整数强转布尔型
不能与其他类型转换

fmt占位符总结

• %T查看变量类型
• %v 查看变量值
• %#v 查看变量值带有类型的标识符
• %d查看数字十进制
• %b查看数值二进制
• %o查看数值 的八进制
• %x查看数值 的十六进制
• %s 字符串

字符串

默认utf-8编码，支持中文。定义字符串变量时只能使用双引号包裹起来，单引号的是字符。

package main
import (
    "fmt"
    "strings"
)
func main() {
    c1 := "测试"
    c2 := '你'
    c3 := `你 是
    谁`
    fmt.Printf("%T", c1) //string
    fmt.Printf("%T", c2) //int32
    fmt.Printf("%v", c3) //原样输出
    //字符串拼接
    fmt.Println(c1 + c3) //字符串加号连接输出，不能与c2连接因为是int32类型的
    ss := fmt.Sprintf("%s%s", c1, c3)
    fmt.Printf("%v", ss) //输出函数拼接的结果
    //字符串分割
    ret := strings.Split(ss, "你")
    fmt.Printf("%T", ret) //[]string
    //字符串内的包含
    fmt.Println(strings.Contains(ss, "你")) //true
    //判断字符串前缀
    fmt.Println(strings.HasPrefix(ss, "测试")) //true
    //判断字符串前缀
    fmt.Println(strings.HasSuffix(ss, "测试")) //false
    //子串的位置
    fmt.Println(strings.Index(ss, "试")) //3
    //子串的最后出现位置
    fmt.Println(strings.LastIndex(ss, "试")) //3
    //拼接
    fmt.Println(strings.Join(ret, "试")) //3
    //遍历字符
    for _, c := range c1 {
        fmt.Printf("%c\n", c)
    }
    //修改字符串。字符串不能修改，修改的时候转换为另外一种类型去修改。
    slices := []rune(c1) //切片里面保存的 是字符的集合
    slices[1] = '焕'
    fmt.Println(string(slices))
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

字符串转义符号
\r 回车
\n 换行

类型转换

整型、浮点型互转
字符串和字符转换