Go语言基础之变量
前言
Hey，大家好呀，我是星期八，这次咱们继续学习Go基础之变量叭。
变量
为什么需要变量
简单点说，我们写的程序默认数据都是保存在内存条中的，我们不可能直接通过地址找到这个变量，因为地址太长了，而且不容易记。
通常我们是通过变量名找到对应的地址上面的值，再进行一系列操作。
变量类型
现在不管是什么语言，常用的变量分为以下类型。
- 整数，
1，6，2，8，4... - 浮点数，
1.1，5.7767，23.99... - 布尔型，
真，假 - 字符串类型，
"张三"，"李四"... - List
- Map
大概会分为以上几种类型，不过这个不用记，了解就好。
变量定义
声明变量
格式如下。
var 变量名 变量类型
例如:
var age int
var gender bool
批量声明
上面声明变量是一个一个声明的，如果需要一次性声明一些变量，可以这样写。
var (
age int
gender bool
name string
id int
height int
...
)
声明时赋值
上述方式，只是声明了变量，但是并没有赋值，在后期需要时可以在赋值。
如果在声明时，就确定值是什么，可以直接赋值。
格式如下。
var 变量名 类型 = 值
例如:
var age int = 18
var name string = "张三"
在Go中的一个强制要求
在Go中，变量必须使用，至少需要fmt.Println(变量)。
类型推导方式声明变量赋值
在上述声明变量并且赋值时，还需要指定变量类型。
在Go，Go具有类型推导方式声明时赋值变量。
var age = 18
var name = "张三"
其实就是变量名后面不用写变量类型了。
:=方式变量赋值
在Go，还有一种更简单的方式声明变量赋值。
格式如下。
age := 18
name := "张三"
学过Python的可能有点开心了，除了多个一个:号，其他基本和Pyton定义变量方式一样。
注意:
age := 18 //本质是执行的两句话
//同上
var age int
age = 18
全局变量
简单说就是，在最外面的定义的变量就是全局变量。
在Go中，全局变量是有要求的。
package main
//全局变量:
// 方式一，声明全局变量，必须跟类型
//var age int
//方式二，声明变量且赋值，类型可以不用写
//var age = 18
//var age int = 18
//方式三，错误示例，全局变量要么只声明变量，要么声明就赋值
//var age int
//age =18
//方式四，错误示例，:=方式声明赋值
// 方式四其实就等于方式三的写法，所以不能用在全局变量中
//age := 18
func main() {
}
PS:全局变量要么只声明，要么声明时就赋值，不能写两行赋值，所以:=方式不能应用在全局变量中
匿名变量
匿名变量多用于函数返回值场景中，比如函数返回了俩值，俩值要第一个值，就可以使用匿名变量。
因为Go中，变量必须使用，如果某个变量需要忽略，使用_即可。
值得注意的是，匿名变量不会占用内存。
package main
func get_info() (string， int) {
return "张三"， 18
}
func main() {
//标准写法
//name， age := get_info()
//fmt.Println(name， age)
//匿名变量方式
//name， _ := get_info()
//fmt.Println(name)
//_，age := get_info()
//fmt.Println(age)
}
常量
其实常量和变量基本一样，但是常量是不能修改的。
通常常量以大写定义。
package main
import "fmt"
func main() {
//单个声明
const PI1 int = 3
const PI2 = 3.14
//同时声明多个
const (
PI3 = 3.14
PI4 = 3.14
)
//同上声明多个变量时，如果省略了值表示和上一行相同
const (
girl1 = 18
girl2 // 18，和上一行相同
girl3 // 18，和上一行相同
girl4 = 17
girl5 // 17，和上一行相同
)
fmt.Println(girl3， girl5)
}
注:常量声明时就必须赋值
错误示例。
package main
func main() {
const age int
age = 18
//error
}
iota
iota是Go中的一个常量计数器，只能在跟常量(const)一块使用。
我们先来理解这一段话。
iota在const关键字出现时将被重置为0
const中每新增一行常量，iota将计数(+1)一次
示例1:
package main
import "fmt"
func main() {
const (
n1 = iota //在const关键字出现时将被重置为0
n2 //没写相当于写了个n2=iota，每新增一行常量iota计数(+1)一次，n2 = 1
n3 //同上 n3 = 2
n4 // 同上 n4 = 3
)
fmt.Println(n1， n2， n3， n4)
}
示例2:
遇到_会是什么情况。
package main
import "fmt"
func main() {
const (
n1 = iota //在const关键字出现时将被重置为0
n2 // n2=1
_ //匿名变量，相当于写了个 _=iota，所以此时iota=2
n4 //n4=3
)
fmt.Println(n1， n2， n4)
}
示例3:
一行多个iota。
package main
import "fmt"
func main() {
const (
a， b = iota + 1， iota + 2 //在const关键字出现时，iota=0，并且两次赋值在同一行，iota没有做+1
c， d //同理，新增一行常量，常量个数为俩，仍然是一行，所以iota=1
//c， d = iota + 1， iota + 2 同上，此时iota=1，c=2，d=3
e， f // 同理，同上，e=3，f=4
)
fmt.Println(a， b， c， d， e， f)
}
整型
整数，很简单了，就是像1，2，3，7，11，..这样的整型数字了。
但是在Go中，整数分为两大类，正整数和没有符号的整数。
u开头的不能存负数
| 类型 | 描述 |
|---|---|
uint8 | 无符号 8位整型 (0 到 255) |
uint16 | 无符号 16位整型 (0 到 65535) |
uint32 | 无符号 32位整型 (0 到 4294967295) |
uint64 | 无符号 64位整型 (0 到 18446744073709551615) |
int8 | 有符号 8位整型 (-128 到 127) |
int16 | 有符号 16位整型 (-32768 到 32767) |
int32 | 有符号 32位整型 (-2147483648 到 2147483647) |
int64 | 有符号 64位整型 (-9223372036854775808 到 9223372036854775807) |
在不同平台上的差异。
| 类型 | 描述 |
|---|---|
uint | 32位操作系统上就是uint32，64位操作系统上就是uint64 |
int | 32位操作系统上就是int32，64位操作系统上就是int64 |
uintptr | 无符号整型，用于存放一个指针 |
示例:
package main
import "fmt"
func main() {
var a = 10 //定义一个十进制数
fmt.Printf("%T\n"， a) //功能:打印变量类型，结果:默认为int类型，也叫int64
fmt.Printf("%d \n"， a) //功能:十进制输出，结果:10
fmt.Printf("%b \n"， a) //功能:二进制输出，结果:1010
fmt.Printf("%o \n"， a) //功能:二进制输出，结果:12
var b = 0b1010011010 //定义一个二进制数1010011010，以0b开头
fmt.Printf("%d\n"， b) //结果:666
var c = 077 //定义一个八进制数77
fmt.Printf("%d\n"， c) //结果:63
var d = 0x42 //定义一个十六进制42
fmt.Printf("%d\n"， d) //结果:66
}
浮点型
在Go中，只有float32和float64，默认使用的是float64。
示例:
package main
import "fmt"
func main() {
var a = 1.21 //默认为float64
fmt.Printf("%T\n"， a) //结果:float64
fmt.Printf("%f\n"，a)//功能:输出浮点型数，结果:1.210000
fmt.Printf("%.1f\n"，a)//功能:输出浮点型数，保留小数点一位，其他忽略，结果:1.2
fmt.Printf("%.2f\n"，a)//功能:输出浮点型数，保留小数点二位，其他忽略，结果:1.21
}
布尔值
在Go中，bool类型就俩值，true和false。
无示例。
注:
-
bool类型默认值为false。 -
true != 1，在Go中，bool类型和整型不能混用。
字符串
终于到字符串了，在Go中，字符串是基本数据类型，在栈中存储。
字符串的值为双引号("")中的内容。
示例:
package main
import "fmt"
func main() {
var name = "hello"
var name2 = "张三"
fmt.Println(name，name2)
}
在Go中，字符串内存布局如下。
其实在Go中，字符串的本质就是一个个的字符拼接成的。
多行字符串
有时候我们可能需要一个长篇大论，需要很长的字符串，这时候我们需要用到`号。
package main
import "fmt"
func main() {
var lyric = `
昨夜同门云集bai 推杯又换盏
今朝du茶凉酒寒 豪言成笑谈
半生累 尽徒然zhi 碑文完美有谁看dao
隐居山水之间 誓与浮名散
湖畔青石板上 一把油纸伞
`
fmt.Println(lyric)
}
字符串常用操作
| 方法 | 介绍 |
|---|---|
len(str) | 求长度 |
+或fmt.Sprintf | 拼接字符串 |
strings.Split | 分割 |
strings.contains | 判断是否包含 |
strings.HasPrefix，strings.HasSuffix | 前缀/后缀判断 |
strings.Index()，strings.LastIndex() | 子串出现的位置 |
strings.Join(a[]string， sep string) | join操作 |
示例代码
package main
func main() {
//len() 求字符串字节长度
//var name = "你好，世界"
//fmt.Println(len(name)) //因为中文是utf8，一个文字三个字节，再加一个，号，所以是13
//fmt.Sprintf 或 + 拼接字符串
//name1 := "张"
//name2 := "三"
//name :=name1 + name2 //拼接字符串
//fmt.Println(name)
//name := fmt.Sprintf("%s%s"， name1， name2)//同上，不过这种更灵活，推荐
//name := fmt.Sprintf("我的姓名是:%s%s"， name1， name2)//自定义拼接
//fmt.Println(name)
//strings.Split 分割字符串
//name := "张三|18|男|法外狂徒"
//info := strings.Split(name， "|")
//fmt.Println(info) //返回的是切片，[张三 18 男 法外狂徒]
//strings.contains 是否包含
//name := "张三666"
//result := strings.Contains(name， "6")
//fmt.Println(result) //返回的是bool类型，true
//strings.HasPrefix 判断前缀(是不是以什么开头)
//name := "web/student/xxx.html"
//result := strings.HasPrefix(name， "web")
//fmt.Println(result) //true
//strings.HasSuffix 判断后缀(是不是以什么结尾)
//name := "web/student/xxx.html"
//result := strings.HasSuffix(name， "html")
//fmt.Println(result)//true
//strings.Index() 返回第一个字符串出现的位置
//name := "hello world"
//index := strings.Index(name， "o")
//fmt.Println(index) //4
//strings.LastIndex() // 正向数，返回最后一个字符串出现的位置
//name := "hello world"
//index := strings.LastIndex(name， "o")
//fmt.Println(index) // 7
//strings.Join(a[]string， sep string) 字符串拼接
//info_list := []string{"张三"， "男"， "18"} //定义一个列表
//name := strings.Join(info_list， "|")
//fmt.Println(name) //张三|男|18
}
上文之字符串回顾
在上述文章中，我们学过了字符串类型。
在Go语言中，字符串类型是基本类型，在栈中存储，其结构如下。
可以看到，在Go中，字符串其实就是指向了一个连续的内存地址，并且记录了长度，读取是一次性读取出来的。
那么，如上图所示，内存里面存的一个个字母叫啥呢？？？
byte和rune类型
字符串是一个个字符拼接成的，反过来，也是一个个字符拼接成的字符串，而一个个的字符，就被称为字节(byte)
字节占用1个字节大小，只能存字母了，标点符号之类的，不能存中文。
当然，存中文怎么办???在Go中有一个rune，和byte类似，本质和byte一样，只不过rune一个占用4个字节
rune使用utf-8编码，可以存中文，各种语言。
所以，处理中文尽量用rune类型。
定义个(字节)byte类型变量
字符用单引号'号包裹起来。
代码
package main
import "fmt"
func main() {
var a byte = 'a'
fmt.Println(a)
}
小朋友，是否有很多疑问???为什么是97
原因
byte代表的是一个ASCII码的一个字符，同理，rune可以理解为是byte的一个超集，向下兼容byte。
package main
import "fmt"
func main() {
var a rune = 'a'
fmt.Println(a)
}
结果:
但是rune里面可以写中文，byte不行。
byte不能存中文
rune可以存中文
发现了吗，打印的竟然是一个数字?这是为啥？？？
就拿字母a来说，其实打印的是ASCII对应的数字，打印的是他的十进制。
同理，字符张也是，这里就不做例子了，因为utf-8表太大了。
遍历字符串
方式一
package main
import "fmt"
func main() {
s := "我是法外狂徒，张三，hahaha"
for _， r := range s {
fmt.Printf("%c \n"，r)
}
}
方式二
package main
import "fmt"
func main() {
s := "我是法外狂徒，张三，hahaha"
for i := 0; i < len(s); i++ {
//中文会乱码，不推荐
fmt.Printf("%c \n"，s[i])
}
}
修改字符串
同理，字符串相当于是字节列表组成的，是不能直接修改的，想要直接修改需要打散成字节列表才行。
package main
import "fmt"
func main() {
//只有英文的情况下
s1 := "hello world"
var s1_byte_list = []byte(s1) //打散成字符列表
s1_byte_list[6] = 'F' //修改下表为6的字符为F
s1 = string(s1_byte_list) //打散的字符列表在组装成字符串
fmt.Println(s1) //输出 hello 6orld
//带有中文的情况
s2 := "天空好像下雨，我好像住你隔壁vay"
var s2_rune_list = []rune(s2) //打散成utf-8字符列表
s2_rune_list[5] = '雪' //修改下表为5的字符为雪
s2 = string(s2_rune_list) //打散的utf8字符转字符串
fmt.Println(s2) //输出 天空好像下雪，我好像住你隔壁
}
总结
我是码农星期八，如果觉得还不错，记得动手点赞以下哈。
感谢你的观看。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
