【Go 基础】基本数据类型

数值型

整数类型

int 有符号的整数类型:

类型 有无符号 占用存储空间 表数的范围 备注
int8 1字节 -128-127
int16 2字节 -2^15-2^15-1
int32 4字节 -2^31-2^32-1
int64 8字节 -2^63-2^63-1

int 无符号的整数类型:

类型 有无符号 占用存储空间 表数的范围 备注
uint8 1字节 0-2^8-1
uint16 2字节 0-2^16-1
uint32 4字节 0-2^32-1
uint64 8字节 0-2^64-1

1024是2^10次方,256是2^8次方。

int 的其他类型:

类型 有无符号 占用存储空间 表数的范围 备注
int 32位系统4个字节,64位系统8个字节 -2^31-2^31-1,-2^63-2^63-1
uint 32位系统4个字节,64位系统8个字节 0-2^32-1,0-2^64-1
rune 与int32一样,4个字节 -2^31-2^32-1 等价于int32,表示一个Unicode码|
byte 与uint8一样,1个字节 0-255 当要存储字符时,选用byte|

整型的使用细节:
1)Go 各整数类型分有符号和无符号,int uint的大小和系统有关。
2)Go 的整型默认声明为 int 型。
3)Go 程序中整型变量在使用时,遵守保小不保大的原则,即在保证程序正确运行下,尽量使用占用空间小的数据类型。比如年龄使用 byte(0-255)的数据类型即可。
4)Byte 是计算机中的基本存储单元,bit 是计算机中的最小存储单位,1Byte = 8bit

注:如何查看某个变量的数据类型和字节大小?

var n1 int64 = 10
// fmt.Printf() 可以用于做格式化输出,使用%T可查看数据类型。
// unsafe.Sizeof(n1) 是unsafe包的一个函数,可以返回n1变量占用的字节数
fmt.Printf("n1 的 类型 %T n1占用的字节数是 %d ", n1, unsafe.Sizeof(n1))

引入多个包的推荐使用如下类型:

import (
 "fmt"
 "unsafe"
)

浮点类型

浮点类型的分类:

类型 占用存储空间 表数范围
单精度 float32 4个字节 -3.403E38 - 3.403E38
双精度 float64 8字节 -1.798E308 - 1.798E308

浮点型常量有两种形式:
1)十进制数形式。
2)科学计数法形式。

// 十进制数形式:如:5.12 .512 (必须有小数点)
 num6 := 5.12
 num7 := .123 //=> 0.123
 fmt.Println("num6=", num6, "num7=", num7)

 // 科学计数法形式
 num8 := 5.1234e2 // ? 5.1234 * 10的2次方
 num9 := 5.1234E2 // ? 5.1234 * 10的2次方 shift+alt+向下的箭头
 num10 := 5.1234E-2 // ? 5.1234 / 10的2次方 0.051234
 fmt.Println("num8=", num8, "num9=", num9, "num10=", num10)

0E-16 代表 0.0000000000000000。

使用细节:
1)浮点数都是有符号的,关于浮点数在机器中存放形式,浮点数=符号位+指数位+尾数位。
2)float64 的精度比 float32 的要准确,通常情况下,应该使用 float64 ,因为它比 float32 更精确。
3)使用浮点数的时候,一定要记住其尾数部分可能丢失,造成精度损失。
4)Go 浮点类型默认声明为 float64 类型。
5)Go 浮点类型有固定的范围和字段长度,不受具体操作系统的影响。

字符型

Go 中没有专门的字符类型,如果要存储单个字符(字母),一般使用 byte来保存。

注:字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的,而 Go 的字符串不是由字符组成的,它是由字节组成的。

使用示例:

package main
import (
 "fmt"
)

func main() {
 var c1 byte = 'a'
 var c2 byte = '0' // 字符的0

 // 当我们直接输出byte值,就是输出了的对应的字符的码值
 fmt.Println("c1=", c1) // c1=97
 fmt.Println("c2=", c2) // c2=48
 // 如果我们希望输出对应字符,需要使用格式化输出
 fmt.Printf("c1=%c c2=%c\n", c1, c2) // c1=a c2=0

 // var c3 byte = '北' // 21271 overflow byte 溢出
 var c3 int = '北'
 fmt.Printf("c3=%c c3对应码值=%d\n", c3, c3) // c3=北 c3对应码值=21271

 // 可以直接给某个变量赋一个数字,然后按格式化输出时%c,会输出该数字对应的 unicode 字符
 var c4 int = 22269 // 22269 -> '国' 120->'x'
 fmt.Printf("c4=%c\n", c4) // c4=国

 // 字符类型是可以进行运算的,相当于一个整数,运算时是按照码值运行
 var n1 = 10 + 'a'
 fmt.Println("n1=", n1) // 10 + 97 = 107

}

对上面的代码进行说明:
1) 如果我们保存的字符在 ASCII 表的,比如[0-1, a-z,A-Z..]直接可以保存到 byte
2) 如果我们保存的字符对应码值大于 255,这时我们可以考虑使用 int 类型保存。
3) 如果我们需要安装字符的方式输出,这时我们需要格式化输出,即 fmt.Printf(“%c”, c1)..

使用注意事项:
1)字符常量是用单引号('')括起来的单个字符。例如:

var c1 byte = 'a' var c2 int = '中' var c3 byte = '9`

2)Go 中允许使用转义字符 '\'来将其后的字符转变为特殊字符型常量。例如:

var c3 char = '\n' // '\n'表示换行符

3)Go 语言的字符使用 UTF-8编码,英文字母-1个字节,汉字-3个字节。
4)在 Go 中,字符的本质是一个整数,直接输出时,是该字符对应的 UTF-8 编码的码值。
5)可以直接给某个变量赋一个数字,然后按格式化输出时%c,会输出该数字对应的 Unicode 字符。
6)字符类型是可以进行运算的,相当于一个整数,因为它都对应有 Unicode 码。

关于加号的使用:
1)当左右两边都是数值型时,则做加法运算。
2)当左右两边都是字符串,则做字符串拼接。

package main
import "fmt"

func main() {

 var i = 1
 var j = 2
 var r = i + j // 做加法运算
 fmt.Println("r=", r) // r=3

 var str1 = "hello "
 var str2 = ",world"
 var res = str1 + str2 // 做拼接操作
 fmt.Println("res=", res) // res=hello,world

 // 字符类型是可以进行运算的,相当于一个整数,运算时是按照码值运行
 var n1 = 10 + 'a'
 fmt.Println("n1=", n1) // 10 + 97 = 107

}

布尔类型

布尔类型也叫 bool 类型,bool类型数据只允许取值 truefalse,不能取空。其占用1个字节的内存空间,适于逻辑运算,一般用于程序流程控制。

字符串

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

字符串一旦赋值了,字符串就不能修改了,也就是说在 Go 中字符串是不可变的。

var str = "hello"
str[0] = 'a' // cannot assign to str[0]

字符串的两种表示形式:

1)双引号, 会识别转义字符。

 str2 := "abc\nabc"
 fmt.Println(str2) // abc 换行 abc

2)反引号,以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击、输出源代码等效果。

 str3 := ` 
 package main
 import (
  "fmt"
  "unsafe"
 )
 func main() {
  var b = false
  fmt.Println("b=", b)
  fmt.Println("b 的占用空间 =", unsafe.Sizeof(b) )
 }
 `
 fmt.Println(str3) // 输出源代码

3)字符串拼接方式:

var str = "hello " + "world"
str += " haha!"

4)当一行字符串太长时,需要使用到多行字符串,可以作如下处理:

 str4 := "hello " + "world" + "hello " + "world" + "hello " + 
 "world" + "hello " + "world" + "hello " + "world" + 
 "hello " + "world"
 fmt.Println(str4)

字符串太长时可以分行写,但是需要注意的是必须将+保留在上一行,否则会报如下错误:

invalid operation: + untyped string

基本数据类型的默认值

在 Go 中,数据类型都有一个默认值,当编写程序没有赋值时,就会保留默认值,在 Go 中,默认值又叫零值。

基本数据类型的默认值如下所示:

数据类型 默认值
整型 0
浮点型 0
字符串 ""
布尔类型 false
func main() {
 var a int // 0
 var b float32 // 0
 var c float64 // 0
 var isMarried bool // false 
 var name string // ""
 // 这里的%v 表示按照变量的值输出
 fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v name=%v",a,b,c,isMarried, name)
 // a=0,b=0,c=0,isMarried=false name=
}

基本数据类型的相互转换

GoJava 或者 C 语言之间的转换不同,Go 在不同类型的变量之间赋值时需要显式转换(强制转换),也就是说 Go 中数据类型不能自动转换。
基本语法:T(v)
T: 就是数据类型,比如 int32int64float32 等。
v: 就是需要转换的变量。

示例:

package main
import "fmt"

func main() {
 var i int32 = 100
 // 希望将 i => float
 var n1 float32 = float32(i)
 var n2 int8 = int8(i)
 var n3 int64 = int64(i) //低精度->高精度

 fmt.Printf("i=%v n1=%v n2=%v n3=%v \n", i, n1, n2, n3)
 // i=100 n1=100 n2=100 n3=100

 // 被转换的是变量存储的数据(即值),变量本身的数据类型并没有变化
 fmt.Printf("i type is %T\n", i) // i type is int32

 // 在转换中,比如将 int64 转成 int8 【-128---127】 ,编译时不会报错,
 // 只是转换的结果是按溢出处理,和我们希望的结果不一样
 var num1 int64 = 999999
 var num2 int8 = int8(num1)
 fmt.Println("num2=", num2) // num2= 63
}

使用注意事项:
1)Go 中数据类型的转换可以是从表示范围小到表示范围大,也可以范围大到范围小。
2)被转换的是变量存储的数据(即值),变量本身的数据类型并没有变化。
3)在转换中,比如将 int64 转成 int8 (-128---127),编译时不会报错,只是转换的结果是按溢出处理,和我们希望的结果不一样,是不可确定的,因此在转换时,需要考虑范围。

上面示例中,经多次转换后,i的数据类型仍然为32位。

示例说明:

package main
import "fmt"

func main() {
 var n1 int32 = 12
 var n2 int64
 var n3 int8


 n2 = n1+ 20 // int32 ---> int64 错误
 n3 = n1 + 20 // int32 ---> int8 错误
 fmt.Println("n2=", n2, "n3=", n3)

 n2 = int64(n1) + 20 // int32 ---> int64 正确
 n3 = int8(n1) + 20 // int32 ---> int8 正确
 fmt.Println("n2=", n2, "n3=", n3)

 var n1 int32 = 12
 var n3 int8
 var n4 int8
 n4 = int8(n1) + 127 // 编译通过,但是结果不是127+12 ,按溢出处理
 n3 = int8(n1) + 128 // 编译不过
 fmt.Println(n4)
}

基本数据类型和 string 之间的转换

基本类型转 string 类型

方式一:使用 fmt.Sprintf 方法

func Sprintf(format string, a ...interface{}) string

Sprintf 根据 format 参数生成格式化的字符串并返回该字符串。

示例说明:

 // 使用 fmt.Sprintf 方法
 var num1 int = 99
 var num2 float64 = 23.456
 var b bool = true
 var myChar byte = 'h'
 var str string // 空的str

 str = fmt.Sprintf("%d", num1)
 fmt.Printf("str type %T str=%q\n", str, str) // str type string str="99"

 str = fmt.Sprintf("%f", num2)
 fmt.Printf("str type %T str=%q\n", str, str) // str type string str="23.456000"

 str = fmt.Sprintf("%t", b)
 fmt.Printf("str type %T str=%q\n", str, str) // str type string str="true"

 str = fmt.Sprintf("%c", myChar)
 fmt.Printf("str type %T str=%q\n", str, str) // str type string str="h"

注:
%d 表示为十进制。
%f 有小数部分但无指数部分,如123.456。
%T 值的类型的 Go 语法表示。
%c 该值对应的 unicode 码值。
%t 单词 truefalse
%q 该值对应的单引号括起来的 Go 语法字符字面值,必要时会采用安全的转义表示。

方式二:使用 strconv 包的函数。

func FormatInt(i int64, base int) string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
func FormatBool(b bool) string
func Itoa(i int) string
func FormatUint(i uint64, base int) string

示例说明:

// 使用 strconv 函数
 var num3 int = 99
 var num4 float64 = 23.456
 var b2 bool = true
 var str string // 空的str

 str = strconv.FormatInt(int64(num3), 10)
 fmt.Printf("str type %T str=%q\n", str, str) // str type string str="99"

 // strconv.FormatFloat(num4, 'f', 10, 64)
 // 说明: 'f' 格式 10:表示小数位保留10位 64 :表示这个小数是float64
 str = strconv.FormatFloat(num4, 'f', 10, 64)
 fmt.Printf("str type %T str=%q\n", str, str) // str type string str="23.4560000000"

 str = strconv.FormatBool(b2)
 fmt.Printf("str type %T str=%q\n", str, str) // str type string str="true"

 // strconv包中有一个函数Itoa
 var num5 int64 = 4567
 str = strconv.Itoa(int(num5))
 fmt.Printf("str type %T str=%q\n", str, str) // str type string str="4567"

string 类型转基本数据类型

使用时 strconv 包的函数:

func ParseBool(str string) (value bool, err error)
func ParseFloat(s string, bitSize int) (f float64, err error)
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (n uint64, err error)

示例说明:

var str string = "true"
 var b bool
 // func ParseBool(str string) (value bool, err error)
 b, _ = strconv.ParseBool(str) // 函数会返回两个值 (value bool, err error) 使用b接收value,使用_忽略error
 fmt.Printf("b type %T b=%v\n", b, b) // b type bool b=true

 var str2 string = "1234590"
 var n1 int64
 var n2 int
 // func ParseInt(s string, base int, bitSize int) (i int64, err error)
 n1, _ = strconv.ParseInt(str2, 10, 64)
 n2 = int(n1)
 fmt.Printf("n1 type %T n1=%v\n", n1, n1) // n1 type int64 n1=1234590
 fmt.Printf("n2 type %T n2=%v\n", n2, n2) // n2 type int n2=1234590

 var str3 string = "123.456"
 var f1 float64
 // func ParseFloat(s string, bitSize int) (f float64, err error)
 f1, _ = strconv.ParseFloat(str3, 64)
 fmt.Printf("f1 type %T f1=%v\n", f1, f1) // f1 type float64 f1=123.456

在将 string 类型转基本数据类型时,要确保 string 类型能够转成有效的数据。比如上面的示例中,我们可以把"1234590"转成一个整数,但是不能把"hello"转成一个整数,如果非要转Go会直接将其转为0。

 var str4 string = "hello"
 var n3 int64 = 11
 // func ParseInt(s string, base int, bitSize int) (i int64, err error)
 n3, _ = strconv.ParseInt(str4, 10, 64)
 fmt.Printf("n3 type %T n3=%v\n", n3, n3) // n3 type int64 n3=0

 var str5 string = "xiong"
 var w bool = true
 w, _ = strconv.ParseBool(str5)
 fmt.Printf("b type %T b=%v\n", w, w) // b type bool b=false

字符串转布尔值,如果没有转成功默认为false,即使定义了true也会变成false

相关推荐

微信扫一扫,分享到朋友圈

【Go 基础】基本数据类型
返回顶部

显示

忘记密码?

显示

显示

获取验证码

Close