变量
变量的定义
1.声明
2.赋值
3.使用
// 声明:var 变量名 变量类型
var name string
// 赋值:
name = "xiaoming"
// 使用:
fmt.Println(name)
// 声明+赋值
// var 变量名 变量类型 = 变量值
var age int = 18
// 使用
fmt.Println(age)
完整代码如下:
package main
import "fmt"
func main() {
// 1.变量的声明
var name string
// 2.变量的赋值
name = "xiaoming"
// 3.变量的使用
fmt.Println(name)
// 1.声明+赋值
var age int = 18
// 2.变量的使用
fmt.Println(age)
}
变量的4种使用形式
1.指定变量的类型并且赋值
2.指定变量的类型不赋值使用默认值
3.如果不指定变量的类型,会根据变量的值来进行判定变量的类型(自动类型推断)
4.省略 var 关键字,直接使用:=
Ps: 这种方法只适合函数内部,函数外边不能使用
完整代码如下:
package main
import "fmt"
func main() {
// 第一种:指定变量的类型并且赋值
var num int = 18
fmt.Println(num)
// 第二种:指定变量的类型不赋值使用默认值
var num2 int
fmt.Println(num2)
// 第三种:如果不指定变量的类型,会根据变量的值来进行判定变量的类型(自动类型推断)
var num3 = 10
fmt.Println(num3)
// 第四种:省略 var 关键字,直接使用 `:=`
// 注意:这种方法只适合函数内部,函数外边不能使用
sex := "男"
fmt.Println(sex)
}
批量声明多个变量
package main
import "fmt"
// 多变量声明
func main() {
// 第一种方式
var n1, n2, n3 int
fmt.Println(n1, n2, n3)
// 第二种方式
var (
n4 string
n5 int
n6 bool
)
fmt.Println(n4, n5, n6)
// 第三种方式
var name, age, sex = "jack", 18, "男"
fmt.Println(name, age, sex)
// 第四种方式
name1, age1, sex1 := "xiaoming", 20, "nan"
fmt.Println(name1, age1, sex1)
}
全局变量
定义在函数之外的变量
package main
import "fmt"
// 全局变量:定义在函数之外的变量
var name string = "xiaoming"
var age = 20
func main() {
fmt.Println(name)
fmt.Println(age)
}
数据类型
分为基本数据类型和复杂数据类型/派生数据类型
基本数据类型:
- 数值型
- 整数类型(int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,byte)
- 浮点类型(float32,float64)
- 字符型(没有单独的字符型,使用byte来保存单个字母字符)
- 布尔型(bool)
- 字符串(string)
复杂数据类型:
- 指针
- 数组
- 结构体
- 管道
- 函数
- 切片
- 接口
- map
整数类型
用于存放整数值,比如 10,-45,6789等
有符号整数类型
类型 | 有无符号 | 占用字符空间 | 表数范围 |
---|---|---|---|
int8 | 有 | 1字节 | -128~127 |
int16 | 有 | 2字节 | -32768~32767 |
int32 | 有 | 4字节 | -2147483648~2147483647 |
int64 | 有 | 8字节 | -2^63~2^63-1 |
无符号整数类型
类型 | 有无符号 | 占用字符空间 | 表数范围 |
---|---|---|---|
uint8 | 无 | 1字节 | 0~255 |
uint16 | 无 | 2字节 | 0~2^16-1 |
uint32 | 无 | 4字节 | 0~2^31-1 |
uint64 | 无 | 8字节 | 0~2^63-1 |
其他整数类型
类型 | 有无符号 | 占用存储空间 | 表数范围 |
---|---|---|---|
int | 有 | 32位系统 4 字节 | -2^31 ~ -2^31-1 |
int | 有 | 64位系统 8 字节 | -2^63 ~ -2^63-1 |
uint | 无 | 32位系统 4 字节 | 0~2^32-1 |
uint | 无 | 64位系统 8 字节 | 0~2^64-1 |
rune | 有 | 等价int32 | -2^31~2^31-1 |
byte | 无 | 等价uint8 | 0~255 |
Ps: Golang
的整数类型默认声明为 int
类型
package main
import "fmt"
func main() {
var age = 18
// Printf函数作用是格式化输出,把age的类型填充到%T的位置上
fmt.Printf("age的类型是: %T", age)
// unsafe.Size():返回数据所占用的字节数
fmt.Println(unsafe.Sizeof(age))
}
浮点类型
用于存放小数值的,比如 3.14,0.5,-2.4
浮点类型种类
类型 | 存储空间 | 表数范围 |
---|---|---|
float32 | 4字节 | -3.403E38 ~ 3.403E38 |
float64 | 8字节 | -1.798E308 ~ 1.798E308 |
Ps: Golang中默认的浮点类型为:float64
package main
import "fmt"
func main() {
// 定义浮点类型的数据
var num1 float32 = 3.14
fmt.Println(num1)
var num2 float32 = -3.14
fmt.Println(num2)
var num3 = 5.6
// num3的类型为:float64
fmt.Printf("num3的类型为:%T", num3)
}
字符类型
Golang 中没有专门的字符类型,如果要存储单个字符(字母)一般使用
byte
来保存Golang 中字符使用
UTF-8
编码字符类型:本质就是一个整数,也可以直接参与运算,输出字符的时候,会将对应一个码值输出
字母、数字、标点等字符,底层是按照 ASCII 进行存储
ASCII表
package main
import "fmt"
func main() {
// 定义字符类型的数据
var c1 byte = 'a'
fmt.Println(c1) // 97
var c2 byte = '6'
fmt.Println(c2) // 54
var c3 byte = '('
fmt.Println(c3) // 40
// 字符类型:本质就是一个整数,也可以直接参与运算,输出字符的时候,会将对应一个码值输出
// 字母、数字、标点等字符,底层是按照 ASCII 进行存储
// 想显示对应的字符,必须采用格式化输出
var c4 byte = 'A'
fmt.Printf("c4=%c", c4) //c4=A
}
布尔类型
布尔类型也叫 bool 类型,bool 类型数据只允许取值
true
和false
布尔类型占 1 个字节
布尔类型适合用于逻辑运算,一般用于流程控制
package main
import "fmt"
func main() {
// 布尔类型的数值
var b1 bool = true
fmt.Println(b1)
var b2 bool = false
fmt.Println(b2)
}
字符串类型
字符串就是一串固定长度的字符连接起来的字符序列
package main
import "fmt"
func main() {
// 字符串
var name string = "xiaoming"
fmt.Println(name)
// 字符串是不可变的,字符串一旦定义好其中字符的值不能改变
var s1 string = "abc"
fmt.Println(s1)
// 字符串的表示形式
// (1) 如果字符串中没有特殊字符,字符串表示形式用双引号
var s2 string = "hello,world"
fmt.Println(s2)
// (2) 如果字符串中有特殊字符,字符串表示形式用 ``
var s3 string = `hello "world"`
fmt.Println(s3)
// 字符串的拼接
var s4 string = "abc" + "def"
fmt.Println(s4)
s4 += "ghi"
fmt.Println(s4)
// 当字符串过长时:注意将 + 号保留在上一行
var s5 string = "abcdefghijklmnopqrstuvwxyz" +
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
fmt.Println(s5)
}
1.字符串是不可变的,字符串一旦定义好其中字符的值不能改变
2.字符串的表示形式
(1) 如果字符串中没有特殊字符,字符串表示形式用双引号
(2) 如果字符串中有特殊字符,字符串表示形式用 ``3.字符串的拼接使用
+
号4.当字符串过长时:注意将
+
号保留在上一行
基本数据类型之间的转换
Go 在不同类型的变量之间赋值时需要
显式转换
,并且只有显式转换(强制转换)
语法:
表达式T(v)将值v
转换为类型T
T
就是数据类型
v
就是需要转换的变量
package main
import "fmt"
func main() {
// 类型转换
var n1 int = 100
// T(v):float32(n1)
var n2 float32 = float32(n1)
fmt.Println(n2)
// n1的类型其实还是int类型,只是把n1的值转换为float32类型
}
基本数据类型转为string
在程序开发中经常需要将基本数据类型转为
string
类型或者将string
类型转为基本数据类型基本类型转 string 类型
方式1:fmt.Sprintf("%参数",表达式)
方式2:使用strconv
包的函数
方式1:
package main
import (
"fmt"
)
func main() {
// 基本数据类型转为 string 类型
var n1 int = 19
var n2 float32 = 4.145
var n3 bool = false
var n4 byte = 'A'
s1 := fmt.Sprintf("%d", n1)
fmt.Printf("%T,%v\n", s1, s1)
s2 := fmt.Sprintf("%f", n2)
fmt.Printf("%T,%v\n", s2, s2)
s3 := fmt.Sprintf("%t", n3)
fmt.Printf("%T,%v\n", s3, s3)
s4 := fmt.Sprintf("%c", n4)
fmt.Printf("%T,%v\n", s4, s4)
}
方式2:
package main
import (
"fmt"
"strconv"
)
func main() {
var n1 int = 10
var n2 float32 = 3.14
var n3 bool = true
// 参数:第一个参数必须转为 int64类型,第二个参数指定字面值的进制形式为十进制
s1 := strconv.FormatInt(int64(n1), 10)
fmt.Printf("s1的类型为:%T,对应的值为:%v\n", s1, s1)
// 参数:第一个参数必须为 float64类型,第二个参数'f'(-ddd.dddd),第三个参数保留小数点后几位,第四个参数指 float64类型
s2 := strconv.FormatFloat(float64(n2), 'f', 9, 32)
fmt.Printf("s2的类型为:%T,对应的值为:%v\n", s2, s2)
// 参数:第一个参数必须为 bool 类型
s3 := strconv.FormatBool(n3)
fmt.Printf("s3的类型为:%T,对应的值为:%v\n", s3, s3)
}
string类型转基本类型
使用
strconv
包的函数
package main
import (
"fmt"
"strconv"
)
func main() {
// string --> bool
var s1 string = "true"
// ParseBool这个函数的返回值有两个 bool, error
// bool 是我们得到的布尔类型的数据,error代表出现的错误
// 我们只关注得到的布尔类型的数据,error可以使用 _ 直接忽略
b, _ := strconv.ParseBool(s1)
fmt.Printf("B的类型为:%T,B的值为:%v\n", b, b)
// string --> int64
var s2 string = "19"
n1, _ := strconv.ParseInt(s2, 10, 64)
fmt.Printf("n1的类型为:%T,n1的值为:%v\n", n1, n1)
// string --> float32/64
var s3 string = "3.14"
f1, _ := strconv.ParseFloat(s3, 64)
fmt.Printf("f1的类型为:%T,f1的值为:%v\n", f1, f1)
}
复杂数据类型-指针
指针就是内存地址
& : 取内存地址
*: 根据内存地址取具体的值
基本数据类型变量
package main
import "fmt"
func main() {
// 在内存中为age开辟一个空间,这个空间存储的数值为18
var age int = 18
// & 加上变量可以获取这个变量的地址
// age对应的地址
fmt.Println(&age) // 0xc00001c048
}
指针数据变量
package main
import "fmt"
func main() {
// 在内存中为age开辟一个空间,这个空间存储的数值为18
var age int = 18
// & 加上变量可以获取这个变量的地址
// age对应的地址
fmt.Println(&age) // 0xc00001c048
// 定义一个指针变量
// var 代表要声明一个变量
// ptr 指针变量的名字
// ptr对应的类型是:*int,它是一个指针类型(指向int类型的指针)
// &age 就是一个地址,是 ptr 变量具体的值
var ptr *int = &age
// 获取ptr这个指针指向的具体数据,使用 *变量名
fmt.Println(*ptr)
}
可以通过指针更改指向值
package main
import "fmt"
func main() {
// 定义一个int类型的变量num,值为10
var num int = 10
// 定义一个指针变量ptr,值为num变量的内存地址
var ptr *int = &num
// 通过 *ptr 修改这个内存地址所指向的具体数值为20
*ptr = 20
// num值变为:20
fmt.Println(num) // 20
fmt.Println(*ptr)// 20
}
指针变量接收的一定是地址值
指针变量的地址不可以不匹配
Ps:*float32
意味着这个指针指向的是 float32
类型的数据,但 &num
对应的是 int
类型
基本数据类型(又叫值类型),都有对应的指针类型,形式为 *数据类型,比如 *int