目 录
1. 变量
1.1 变量的声明方式
1.1.1 声明单个变量
1、只声明变量
语法格式:
var 变量名 变量类型
示例:
package main
import "fmt"
func main() {
//声明变量
var name string
//赋值
//name = "小明"
fmt.Println("name:" + name)
}
2、声明变量并赋值进行初始化
语法格式:
var 变量名 变量类型 = 值
示例:
package main
import "fmt"
func main() {
var name string = "小明"
//var name = "小明"
fmt.Println("name:" + name)
}
注意点:由于 Go 能够根据初始值自动推断变量类型,因此在有初始化的情况下,变量类型可以省略不写。
1.1.2 声明多个变量
1、声明同类型的多个变量
语法格式:
var 变量名1,变量名2 变量类型 = 值1,值2
示例:
package main
import "fmt"
func main() {
var staff1, staff2 string = "小明", "小李"
//var staff1, staff2 string
//staff1 = "小明"
//staff2 = "小李"
fmt.Println("staff1:", staff1, "staff2:", staff2)
}
2、声明不同类型的多个变量
语法格式:
var(
变量1 = 值1
变量2 = 值2
)
示例
package main
import "fmt"
func main() {
var (
name = "小明"
age = 23
height = 175
)
//亲测效果同上 var name1,age,height = "小明", 23,175
fmt.Println("name:", name, "age:", age, "height:", height)
}
1.1.3 简短声明
使用 := 操作符进行声明,使用要求是所有使用此方式声明的变量都要有初始值。
语法格式:
变量名 := 值
示例:
package main
import "fmt"
func main() {
name, age, height := "小明", 23, 175
fmt.Println("name:", name, "age:", age, "height:", height)
}
2. 基本类型
Go 语言支持的基本类型如下:
- 布尔类型:bool
- 数字类型:
- int8, int16, int32, int64, int
- uint8, uint16, uint32, uint64, uint
- float32, float64
- complex64, complex128
- byte
- rune
- 字符串类型:string
2.1 布尔类型
bool 类型的值为 true 或 false
示例:
package main
import "fmt"
func main() {
a := true
b := false
fmt.Println("a:", a, "b:", b)
c := a && b
fmt.Println("c:", c)
d := a || b
fmt.Println("d:", d)
}
运行结果:
a: true b: false
c: false
d: true
2.2 数字类型
数字类型:
- int8, int16, int32, int64, int
- uint8, uint16, uint32, uint64, uint
- float32, float64
- complex64, complex128
- byte
- rune
数字类型比较多,又可以将它们分为有符号整型、无符号整型、浮点型、复数类型、其它数字类型
2.2.1 有符号整型
名称 | 含义 | 大小 | 范围 |
---|---|---|---|
int8 | 表示8位有符号整型 | 8位 | -128~127 |
int16 | 表示16位有符号整型 | 16位 | -32768~32767 |
int32 | 表示32位有符号整型 | 32位 | -2147483648~2147483647 |
int64 | 表示64位有符号整型 | 64位 | -9223372036854775808~9223372036854775807 |
int | 根据不同的底层平台(Underlying Platform),表示32或64位整型。除非对整型的大小有特定的需求,否则你通常应该使用 int 表示整型 | 在32位系统下是32位,而在64位系统下是64位 | 在32位系统下是 -2147483648~2147483647,而在64位系统是 -9223372036854775808~9223372036854775807 |
2.2.2 无符号整型
名称 | 含义 | 大小 | 范围 |
---|---|---|---|
uint8 | 表示8位无符号整型 | 8位 | 0~255 |
uint16 | 表示16位无符号整型 | 16位 | 0~65535 |
uint32 | 表示32位无符号整型 | 32位 | 0~4294967295 |
uint64 | 表示64位无符号整型 | 64位 | 0~18446744073709551615 |
uint | 根据不同的底层平台,表示 32 或 64 位无符号整型 | 在 32 位系统下是 32 位,而在 64 位系统下是 64 位 | 在 32 位系统下是 0~4294967295,而在 64 位系统是 0~18446744073709551615 |
2.2.3 浮点型
名称 | 含义 |
---|---|
float32 | 32 位浮点数 |
float64 | 64 位浮点数 |
float64 是浮点数的默认类型,不做特别声明时,使用的是64位浮点数。
示例:
package main
import "fmt"
func main() {
a, b := 3.95, 6.63
fmt.Printf("type of a %T b %T\n", a, b)
sum := a + b
diff := a - b
fmt.Println("sum", sum, "diff", diff)
no1, no2 := 45, 33
fmt.Println("sum", no1+no2, "diff", no1-no2)
}
运行结果:
type of a float64 b float64
sum 10.58 diff -2.6799999999999997
sum 78 diff 12
2.2.4 复数类型
名称 | 含义 |
---|---|
complex64 | 实部和虚部都是 float32 类型的的复数 |
complex128 | 实部和虚部都是 float64 类型的的复数 |
内建函数 complex
内建函数 complex 用于创建一个包含实部和虚部的复数,它的定义如下:
func complex(r, i FloatType) ComplexType
参数分别代表实部和虚部,函数返回一个复数类型。实部和虚部要相同类型,也就是 float32 或 float64。如果实部和虚部都是 float32 类型,那么函数会返回一个 complex64 类型的复数。如果实部和虚部都是 float64 类型,那么函数会返回一个 complex128 类型的复数。
使用内建函数创建复数的示例:
package main
import "fmt"
func main() {
c1 := complex(5, 7)
fmt.Println("得到的复数:", c1)
}
输出结果:
得到的复数: (5+7i)
使用简短语法创建复数
语法如下:
c := 5 + 7i
使用示例:
package main
import "fmt"
func main() {
c1 := complex(5, 7)
c2 := 4 + 9i
sum := c1 + c2
fmt.Println("两个复数的和是:", sum)
data := c1 * c2
fmt.Println("两个复数的乘积是:", data)
}
运行结果:
两个复数的和是: (9+16i)
两个复数的乘积是: (-43+73i)
2.2.5 其它数字类型
名称 | 含义 |
---|---|
byte | uint8 的别名 |
rune | int32 的别名 |
2.3 string类型
使用示例:
package main
import "fmt"
func main() {
data := "学习"
out := "go语言"
result := data + out
fmt.Println(result)
}
运行结果:
学习go语言
2.4 类型转换
示例:
package main
import "fmt"
func main() {
i := 10
//将int类型转换成浮点型
var j float64 = float64(i)
fmt.Println("j的值是:", j)
}
结果:
j的值是: 10