Go语言基础 基本数据类型使用

变量的定义以及使用

golang 变量使用的细节

第一种：指定变量类型，声明后若不赋值 使用默认值

package main
import (
	"fmt"
)
func main() {
	// 赋值的情况 定义一个 int 类型的变量 赋值为10
	var i int
	 i=10
	fmt.Println("i=",i)
}
## 结果
PS D:\golang\go_helloword\src\go_code\project01\main> go run test.go
i= 10
#############################################################################
package main
import (
	"fmt"
)
func main() {
	// 赋值的情况 定义一个 int 类型的变量 赋值为10
	var i int
	fmt.Println("i=",i)
}
PS D:\golang\go_helloword\src\go_code\project01\main> go run test.go
i= 0

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

第二种 根据值自行判定变量类型（类型推导）

package main
import (
	"fmt"
)
func main() {
	var name="tom"
	fmt.Println("name= ",name)
}
PS D:\golang\go_helloword\src\go_code\project01\main> go run test.go
name=  tom
1
2
3
4
5
6
7
8
9
10

第三种 省略var 注意 := 左侧的变量不应该是已经声明过的 否则会导致编译错误

package main
import (
	"fmt"
)
func main() {
	// 这种方式等价 var name string="tom"
	name:="tom"
	fmt.Println("name = ",name)
}
PS D:\golang\go_helloword\src\go_code\project01\main> go run test.go
name =  tom
1
2
3
4
5
6
7
8
9
10
11

多变量声明

package main
import (
	"fmt"
)
func main() {
//如何一次性声明多个变量	
//  var n1,n2 int
//  fmt.Println("n1",n1,"n2",n2)
// 一次性声明多个变量的方式2
// var n1,name,n3=100,"tom",888
// fmt.Println("n1=",n1,"name=",name,"n3=",n3)
//类型推导
 n1,name,n3:=100,"tom加",888
fmt.Println("n1=",n1,"name=",name,"n3=",n3)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

变量的数据类型

整数的类型

package main
import (
	"fmt"
	"unsafe"
)
func main() {
	// int uint rune byte 的使用
	var a int =8900
	fmt.Println("a=",a)
	var b uint =1
	var c byte =255
	fmt.Println("b=",b,"c="c)
	// 整型的使用细节
	var n1=100
	fmt.Println("n1 的类型 %T \n",n1)
	var n2 int64 =10
	fmt.Println("n2 的类型 %T n2 占用的字节数是 %d",n2,unsafe.Sizeof(n2))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

整型的使用细节

1，go 各整数类型分 ：有符号喝无符号 int uint 的大小喝系统有关
2，go 的整型默认声明为int 型
3，如何在程序查看某个变量的字节大小和数据类型
4，go 程序中整型变量在使用时 遵守保小不保大的原则 即 在保证程序正确运行下 尽量使用占用空间小的数据类型
5，bit 计算机中的最小存储单位 byte 计算机中基本存储单元

浮点类型

浮点类型的分类

说明一下：
1 关于浮点数在机器中存放形式的简单说明 浮点数=符号位+指数位+尾数位
2 尾数部分可能丢失 造成精度损失
3 浮点型的存储分为三个部分 符号位+指数位+尾数位 在存储过程中 精度会有丢失。

package main

import "fmt"

func main() {
	var num1 float32 = -0.00089
	var num2 float64 = -5997487.09
	fmt.Println(num1, num2)

	// 尾数部分丢失 造成精度损失
	var num3 float32 = -123.0000901
	var num4 float64 = -123.0000901
	fmt.Println(num3, num4)
}

C:\Users\86152\AppData\Local\Temp\GoLand\___go_build_gopl_helloword.exe
// 结果
-0.00089 -5.99748709e+06
-123.00009 -123.0000901


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

浮点类型使用的细节

1. go浮点类型有固定的范围喝字段长度 不受具体的OS（操作系统）的影响
2. go 的浮点类型默认声明为float64 类型
3. 浮点型常量有两种表示形式 十进制 跟科学计数法的形式
4. 通常情况下 使用的是 float64 因为比 float 32 更加精准。

字符类型（char）

go 中没有专门的字符类型 如果要存储单个字符 （例如字母）一般使用byte 来保存
字符串就是一串固定长度的字符链接起来的字符序列 GO 的字符串是由单个字节链接起来的也就是说多个传统的字符组成 而GO的字符串不同 它是由字节组成的

基本使用

package main

import "fmt"

func main() {
	var c1 byte = 'a'
	var c2 byte = '0' // 这个是字符的0
	//当我们直接输出byte值 就是输出了对应的字符的码
	fmt.Println("c1 ==", c1)
	fmt.Println("c2 ==", c2)
	// 如果希望输出的对应字符 需要做格式化
	fmt.Printf("c1=%c x2=%c", c1, c2)
}
// 结果
C:\Users\86152\AppData\Local\Temp\GoLand\___go_build_gopl_Stringtest.exe
c1 == 97
c2 == 48
c1=a x2=0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

**1，如果是在ASCII 表的 比如【0-1，a_z,A-Z】直接用byte 存储 **
2，如果我们保存的字符对应码值大于255这时我们就可以考虑用int 类型保存
3，如果我们需要安装字符的方式输出 只需要格式化fmt.Printf(“c1=%c x2=%c”, c1, c2)

布尔类型

1，布尔类型也叫bool 类型 bool 类型数据只允许取值 true 和flase
2,bool 类型占1个字节
3，boolean 类型始于逻辑运算 一般用于程序流程控制 注：这个后面会详细介绍
if 条件控制语句
for循环控制语句

package main

import "fmt"

func main() {
	var c1 bool = true
	fmt.Println(c1)
	// 注意事项 布尔类型
}

1
2
3
4
5
6
7
8
9
10

字符串类型 ：String

基本介绍

字符串就是一串固定长度的字符链接起来的字符序列 Go 的字符串是由单个字节连接起来的 GO 语言的字符串使用的UTF-8 编码标识 Unicode 文本

package main

import "fmt"
func main() {
	name := "冯娇娇"
	fmt.Println("name:=", name)
}
1
2
3
4
5
6
7

注意事项喝使用的细节

1， go 语言的字符串的字节使用UTF-8 编码标识Unicode 文本 这样go 统一使用 utf-8 编码乱码问题就没有了
2， 字符串一旦赋值了 字符创就不能修改了 在Go 中字符串是不可变的。

3，字符串的两种表示形式
（1），双引号 如上面所示 但是会识别转义字符
（2）反引号 以字符串的原生形式输出 包括换行喝特殊字符 可以实现防止攻击，输出源代码

package main

func main() {
	test := `

	fdjbeti[jghetopjhijryhi4t6uj80hyjn
	hpknoyrkhjryo
`
	println(test)
}
1
2
3
4
5
6
7
8
9
10

基本数据类型默认值

基本数据类型一览表

基本数据类型的转换

go 和java/c 不同 Go 在不同类型的变量之间赋值时需要显式转换 也就是说 go 不会自动转换

基本语法

表达式T（v）将值v 转换为类型T
T：就是数据类型 比如int32 int64 float32 …
V:就是需要转换的变量

案例演示

package main

import "fmt"

func main() {
	var i int32 = 100
	// 把i 转换=》float
	var n2 float32 = float32(i)
	var n3 int32 = int32(i)
	fmt.Println(n2, n3)
	fmt.Printf("n3=%T", n3)
}
C:\Users\86152\AppData\Local\Temp\GoLand\___go_build_gopl_Stringtest.exe
100 100
n3=int32
Process finished with the exit code 0


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

基本数据类型的转换

1，GO 中数据类型的转换可以是从表示范围小–> 表示范围大 也可以 范围大–> 范围小
2，被转换的是变量存储的数据（即值）变量本身的数据类型并没有变化
3，在转换中 比如将int64 转成int8 编译时不会报错 只是转换的结果是按照溢出处理

基本数据类型和String

基本类型转string 类型

第一种 fmt.Sprintf

1，fmt.Sprintf(“%参数”，表达式)
2，参数需要喝表达式的数据类型相匹配
3，fmt.Sprintf 会返回转换后的字符串

package main

import "fmt"

func main() {
	var num int = 99
	num1 := 45.66
	b := true
	// 用fmt.Sprintf 转换
	str := fmt.Sprintf("%d", num)
	fmt.Sprintf("%d", num1)
	fmt.Sprintf("%d", b)
	fmt.Printf("str type%T", str)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

第二种方法 strconv 函数转换

package main

import (
	//"fmt"
	"strconv"
)

func main() {
	var num int = 99
	num1 := 45.66
	b := true
	strconv.Itoa(num) 
	strconv.FormatInt(int64(num),10)
	strconv.FormatFloat(num1,'f',10,64)
	strconv.FormatBool(b)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

String 转换基本数据类型

package main

import (
	"fmt"
	"strconv"
)
func main() {
	str := "123"
	i, _ := strconv.ParseInt(str, 0, 64)
	fmt.Println(i)
	str1 := "true"
	parseBool, _ := strconv.ParseBool(str1)
	fmt.Println(parseBool)
	str2 := "45.66"
	// ,_ 的意思是有两个返回值 但是我当前只需要在意第一个 第二个可以写成_表示忽略
	float, _ := strconv.ParseFloat(str2, 64)
	fmt.Println(float)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在将string类型转成基本数据类型时，要确保String类型能够转成有效的数据，比如我们可以把"123",转成一个整数，但是不能把"hello”转成一个整数，如果这样做，Golang直接将其转成0