Go变量与数据类型
-
-
- 1 变量
-
- 1.1 变量概念
- 1.2 变量的使用步骤
- 1.3 变量的注意事项
- 1.4 “+”的使用
- 2 数据类型介绍
- 3 整数类型
-
- 3.1 有符号整数类型
- 3.2 无符号整数类型
- 3.3 其他整数类型
- 3.4 整型的使用细节
- 4 小数类型/浮点型
-
- 4.1 浮点型的分类
- 4.2 简单使用
- 5 字符类型
-
- 5.1 字符类型的使用
- 5.2 转义字符
- 5.3 字符使用的注意事项
- 6 布尔类型
- 7 字符串类型
-
- 7.1 基本使用
- 7.2 string使用注意事项
- 8 基本数据类型的转换
-
- 8.1 基本使用
- 8.2 基本数据类型转化为string类型
- 8.3 string类型转化为基本数据类型
-
1 变量
1.1 变量概念
变量相当于内存中一个数据存储空间的表示
1.2 变量的使用步骤
(1)声明变量(也叫:定义变量)
(2)非变量赋值
(3)使用变量
1.3 变量的注意事项
(1)变量表示内存中的一个存储区域
(2)该区域有自己的名称(变量名)和类型(数据类型)
(3)Golang变量使用的三种方式
- 第一种:声明后不赋值,使用默认值,例如:int数据类型默认值为 ‘0’
func main() {
// 声明不赋值,int数据类型默认值为 0
var i int
fmt.Println("i=", i)
}
- 第二种:根据值自行判断变量类型(类型推导,自动判断)
func main() {
// 根据自行判定变量类型(类型推导,自动判断)
var num = 10.11
fmt.Println("num=", num)
}
- 第三种:省略var,注意: = 左侧的变量不应该是已经声明过的,否则会导致编译错误
func main() {
// 第三种:省略var,等价于 var name string, name = "tom"
num := "tom"
fmt.Println("num=", num)
}
(4)多变量声明
一次性声明多个变量
func main() {
// 对应上面第一种方式
var a1, a2, a3 int
fmt.Println("a1=", a1, "a2=", a2, "a3=", a3)
// 对应上面第二种方式
var b1, b2, b3 = 100, "tom", 888
fmt.Println("b1=", b1, "b2=", b2, "b3=", b3)
// 对应上面第三种方式
c1, c2, c3 := 100, "tom", 888
fmt.Println("c1=", c1, "c2=", c2, "c3=", c3)
}
(5)全局变量的声明
package main
// 定义全局变量
var n1 = 100
var n2 = 200
var n3 = "Tom"
// 一次性声明
var (
n4 = 300
n5 = "Mary"
)
func main() {
// 注意:这里声明的变量和全局变量不能名字重复,
// var n1 = 1000
// 相当于把全局变量的n1值给修改
n1 = 1000
println("n1=", n1, "n2=", n2, "n3=", n3, "n4=", n4, "n5=", n5)
}
(6)该区域的数据值可以在同一数据类型范围内
重复赋值(变化,修改)
func main() {
var i int
i = 1
i = 2
i = 3
fmt.Println(i)
// i = 1.1 报错:数据类型不同
}
(7)变量在同一个作用域(在一个函数或者在代码块)内不能重名
func main() {
var i int
i = 1
// var i int 报错:重名
// i := 2 报错:同上,因为这个是两个语句的合体
fmt.Println("i=", i)
}
(8)变量=变量名+值+数据类型,注意这是变量的三要素
(9)Golang的变量如果没有赋初值,编译器会使用默认值,比如int默认值 0 , string默认值 空串,小数默认值 0
1.4 “+”的使用
- 当左右两边都是数值型时,做加法运算
- 当左右两边都是字符串时,做字符串拼接
func main() {
var a, b = 1, 2
fmt.Println("a+b=", a+b)
var n1, n2 = "你", "好"
fmt.Println("n1+n2=", n1+n2)
}
2 数据类型介绍
每一种数据都定义了明确的数据类型,在内存中分配了不同大小的内存空间
下面是主要和常用的数据类型
不过少了rune(int32的别名,表示一个Unicode码,处理带中文的字符串)和complex64,128(复数数据类型)
区别于java,不使用short等来区分内存空间大小,例如:int8 占用8位
,也就是1个byte
注意:
-
没有字符型char这种数据类型,使用byte存储时,只能存
字母
,不能存单个汉字
-
string 在go语言属于基本数据类型
3 整数类型
简单的说,就是用于存放整数值的,比如10,-45,6712等等。
3.1 有符号整数类型
PS:127怎么算出来的?
01111111 –>二进制 —》转为十进制:
12^6 + 12^5 + 12^4 + 12^3 + 12^2 + 12^1 + 1*2^0
= 64 + 32 + 16 + 8 + 4 + 2 + 1
= 127PS:-128怎么算出来的?
10000000 —>二进制 —>一看就是个负数进行负数的二进制计算
减1:01111111
取反:10000000 —》得到一个正数 2^7 = 128
加负号:-服务器托管网128
3.2 无符号整数类型
表数范围的边界计算:
11111111= 2^7+127 = 128 + 127 = 255
00000000 = 0
3.3 其他整数类型
3.4 整型的使用细节
-
Golang各整数类型分为:有符号和无符号,int uint 的大小和系统有关
-
Golang的整数类型,默认声明为int类型
func main() {
var a = 1
// fmt.Printf()可以用于做格式化输出
fmt.Printf("a 的数据类型:%T", a)
// 输出:a 的数据类型:int
}
- 如何在程序查看某个遍历的占用字节大小和数据类型(使用较多)
func main() {
var n1 byte = 10
// fmt.Printf()可以用于做格式化输出
// unsafe.Sizeof(a) 是unsafe包的一个函数,可以返回n1变量占用的字节数
fmt.Printf("n1 的数据类型:%T ,n1占用的字节数是 %d ", n1, unsafe.Sizeof(n1))
// 输出:n1 的数据类型:uint8 服务器托管网,n1占用的字节数是 1
}
- Golang程序中整型变量在使用时,遵守保小不保大的原则,即:在保证程序正确运行下,尽量使用占用空间小的数据类型。如:年龄,可以使用byte,就占用一个字节
- bit:计算机中的最小存储单位。byte:计算机中基本存储单元。一个byte = 8bit
4 小数类型/浮点型
简单的说,就是用于存放小数值的,比如3.14、0.28、-7.19等等。
4.1 浮点型的分类
PS: 底层存储空间和操作系统无关
PS:浮点类型底层存储:符号位+指数位+尾数位,所以尾数位只是存了 一个大概,很可能会出现精度的损失。
4.2 简单使用
func main() {
num1 := 5.12
num2 := 0.12
// 科学计数法的使用
num3 := 5.1234e2 // 5.1234 * 10的2次方
fmt.Println("num1=", num1, "num2=", num2, "num3=", num3)
// 输出:num1= 5.12 num2= 0.12 num3= 512.34
fmt.Printf("num3的数据类型: %T", num3)
// 输出:num3的数据类型: float64
}
注意:推荐使用float64
5 字符类型
5.1 字符类型的使用
- Golang中没有专门的字符类型,如果要存储单个字符(字母),一般使用byte来保存。
- Golang中字符使用UTF-8编码
func main() {
var a byte = 'a'
var b byte = '0'
fmt.Println("a = ", a, ",b = ", b)
// 输出:a = 97 ,b = 48
}
ASCII码表:
左面是不可见字符 右面是可见字符
- 如果我们需要输出对应字符,需要使用格式化输出
func main() {
var a byte = 'a'
var b byte = '0'
fmt.Printf("a = %c ,b = %c", a, b)
// 输出:a = a ,b = 0
}
- 输出汉字的方式
func main() {
//var a byte = '北' // overflow溢出
var a int = '北'
fmt.Printf("a=%c,a对应码值=%d", a, a)
}
5.2 转义字符
转义字符:将后面的字母表示为特殊含义
5.3 字符使用的注意事项
- 字符常量是用单引号
''
括起来的单个字符 - Go语言的字符使用UTF-8编码
英文字母1个字节,汉字3个字节
- 字符的本质是一个整数,直接输出时,是该字符对应的UTF-8编码码值
- 格式化输出%C,会输出该数字对应的unicode字符
- 字符类型是可以进行运算的,相当于一个整数,因为它都对应有
Unicode
码
PS:字符型 存储到 计算机中
- 存储:字符 -> 对应码值 -> 二进制 -> 存储
- 读取:二进制 -> 码值 -> 字符 -> 读取
PS:GO语言的编码都统一成了utf-8。非常的方便,很统一,再也没有编码乱码的困扰了。
6 布尔类型
- 布尔类型也叫bool类型,bool类型数据只允许取值
true
和false
- 布尔类型占1个字节。
- 布尔类型适于逻辑运算,一般用于程序流程控制
func main() {
var n = false // 不允许使用 0,1
fmt.Println("n =", n)
}
7 字符串类型
7.1 基本使用
字符串
就是一串固定长度的字符
连接起来的字符序列。
func main() {
var address string = "北京长城 110 hello world"
fmt.Println("address = " + address)
// 输出:address = 北京长城 110 hello world
}
7.2 string使用注意事项
- Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本,这样Golang统一使用UTF-8编码,
中文乱码问题
不会再困扰程序员。 - 字符串一单赋值了,字符串就不能修改了:在Go中字符串是不可变的
func main() {
var address string = "北京长城 110 hello world"
// address[0] = '哈' // 报错!不能修改!
fmt.Println("address = ", address)
}
- 字符串的两种表示形式
- 双引号,会识别转义字符
- 反引号,以字符串的原生形式输出,包括换行和特殊字符,可以实现
防止攻击
、输出源代码等效果
8 基本数据类型的转换
8.1 基本使用
Go在不同类型的变量之间赋值时需要显式转换,并且只有显式转换(强制转换)。
语法:
表达式T(v)将值v转换为类型T
T
: 就是数据类型
v
: 就是需要转换的变量
func main() {
var n1 int32 = 100
// var n2 float32 = n1 报错
var n2 float32 = float32(n1)
fmt.Printf("n1 = %v n2 = %v ", n1, n2)
}
**注意:**转换的结果如果超出范围,就会按照溢出处理,不会编译错误,只是会和我们希望的结果不一样。
8.2 基本数据类型转化为string类型
在程序开发中,我们经常需要将基本数据类型转成string类型。或者将string类型转成基本数据类型。
基本类型转string类型的两种方式
方式1:
fmt.Sprintf(“%参数”,表达式) —》 重点练习这个,推荐方式
方式2:
使用strconv包的函数
方式1 代码演示:
import "fmt"
func main() {
var num1 int = 99
var str1 string = fmt.Sprintf("%d", num1)
fmt.Printf("str1 type:%T, str1 = %v", str1, str1)
fmt.Println()
var num2 float64 = 23.456
str2 := fmt.Sprintf("%f", num2)
fmt.Printf("str2 type:%T, str2 = %v", str2, str2)
fmt.Println()
var b bool = true
str3 := fmt.Sprintf("%t", b)
fmt.Printf("str3 type:%T, str3 = %v", str3, str3)
fmt.Println()
var myChar byte = 'h'
str4 := fmt.Sprintf("%b", myChar)
fmt.Printf("str4 type:%T, str4 = %v", str4, str4)
}
输出:
str1 type:string, str1 = 99
str2 type:string, str2 = 23.456000
str3 type:string, str3 = true
str4 type:string, str4 = 1101000
方式2 代码演示:
func main() {
var num1 int = 99
// 表示10进制
str1 := strconv.FormatInt(int64(num1), 10)
// str1 := strconv.Itoa(num1) 同上
fmt.Printf("str1 type:%T, str1 = %vn", str1, str1)
var num2 float64 = 23.456
// 'f' 格式 10:表示小数位保留10位 64 表示是float64
str2 := strconv.FormatFloat(num2, 'f', 10, 64)
fmt.Printf("str2 type:%T, str2 = %vn", str2, str2)
var b bool = true
str3 := strconv.FormatBool(b)
fmt.Printf("str3 type:%T, str3 = %vn", str3, str3)
var myChar byte = 'h'
// str4 := strconv.FormatInt(int64(myChar), 2)
str4 := string(myChar)
fmt.Printf("str4 type:%T, str4 = %vn", str4, str4)
}
输出:
str1 type:string, str1 = 99
str2 type:string, str2 = 23.456000
str3 type:string, str3 = true
str4 type:string, str4 = h
8.3 string类型转化为基本数据类型
func main() {
// 说明:num1, _ := strconv.ParseInt() 表示忽略第二个函数的返回值,使用下划线"_"
str1 := "99"
// num1, _ := strconv.Atoi(str1) // 与下面这个相同
num1, _ := strconv.ParseInt(str1, 10, 64) // 只能转化为int64,但是不能为int类型,int类型只能用上面这个
fmt.Printf("num1 type:%T, num1 = %vn", num1, num1)
str2 := "23.456"
num2, _ := strconv.ParseFloat(str2, 64)
fmt.Printf("num2 type:%T, num2 = %vn", num2, num2)
str3 := "true"
b, _ := strconv.ParseBool(str3)
fmt.Printf("b type:%T, b = %vn", b, b)
str4 := "h"
// myChar2 := str4[0] 结果与下面这个相同
myChar := byte(str4[0])
fmt.Printf("myChar type:%T, myChar = %vn", myChar, myChar)
}
输出为:
num1 type:int64, num1 = 99
num2 type:float64, num2 = 23.456
b type:bool, b = true
myChar type:uint8, myChar = 104
注意事项:
确保转换之间的数据类型没有问题,不然Golang不会报错,但是数据是当前数据类型的默认值
可以把“123”转为一个整数,但不能把“hello”转成一个整数,如果这样做,Golang直接将其转成默认值 0
例子:
func main() {
var str string = "hello"
var num int64
num, _ = strconv.ParseInt(str, 10, 64)
fmt.Printf("num type = %T, num value = %d n", num, num)
// 输出为:num type = int64, num value = 0
}
Over!!!!下一步学习Go指针,冲冲冲!!!
服务器托管,北京服务器托管,服务器租用 http://www.fwqtg.net