【go语言入门教程】——2. 变量及类型

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