GO 数据类型
- 基本类型,如:int、float、bool、string;
- 结构化的(复合的),如:struct、array、slice、map、channel;
- 描述类型的行为的,如:interface。
结构化的类型没有真正的值,它使用 nil 作为默认值(在 Objective-C 中是 nil,在 Java 中是 null,在 C 和 C++ 中是NULL或 0。
值得注意的是,Go 语言中不存在类型继承。无符号的数据类型(带u的)比有符号的数据类型存储的值更大整数:
* int8(-128 -> 127)
* int16(-32768 -> 32767)
* int32(-2,147,483,648 -> 2,147,483,647)
* int64(-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807)
无符号整数:
* uint8(0 -> 255)
* uint16(0 -> 65,535)
* uint32(0 -> 4,294,967,295)
* uint64(0 -> 18,446,744,073,709,551,615)
浮点型(IEEE-754 标准):
* float32(± 1e-45 -> ± 3.4 * 1e38)
* float64(± 5 1e-324 -> 107 1e308)
布尔型
* true
* false
对于布尔值的好的命名能够很好地提升代码的可读性,例如以 is 或者 Is 开头的 isSorted、isFinished、isVisible
整型
* go 的整型默认声明为 int 型
* int 型是计算最快的一种类型。
* 整型的零值为 0,
* 在程序中查看变量的类型和字节大小
* bit 是计算机中最小的存储单位,byte 是计算机中基本存储单元
浮点型
* 浮点型的零值为 0.0。
* GO 浮点类型有固定的范围和字段长度,不受具体的OS 的影响
* 浮点数常有两种表示形式: 十进制数形式: 7.3(必须有点) 和科学计数法
* float32 精确到小数点后 7 位,float64 精确到小数点后 15 位。由于精确度的缘故,你在使用 == 或者 != 来比较浮点数时应当非常小心。你最好在正式使用前测试对于精确度要求较高的运算。
* 你应该尽可能地使用 float64,因为 math 包中所有有关数学运算的函数都会要求接收这个类型
字符类型
* Go 没有专门的字符类型,如果要存储单个字符,一般使用byte
* GO中字符串是一串固定长度的字符连接起来的字符序列,GO的字符串是由单个字节连接起来的,Go的字符串不同,它是由字节组成的。
* 字符常量是用单引号括起来的单个字符
* Go 中允许使用转义字符'\' ,来将其后的字符转变为 特殊字符的常量
* GO语言的字符使用UTF-8 编码
* 在Go中字符的本质是一个整数,直接输出是,是该字符对应的UTF-8 编码的码值
* 可以直接给某个变量赋一个数字。然后按格式化输出时 %c 会输入该数字对应的unicode 字符。
* 字符类型是可以进行运算的,相当于一个整数,因为他都对应Unicode 码、
var char byte = '1'
fmt.Println(char) // 码值
fmt.Printf("char 的字符形态 %c \n", char)
var char2 int = '我'
fmt.Println(char2) // 码值
fmt.Printf("char2 的字符形态 %c \n", char2)
结果:
49
char 的字符形态 1
25105
char2 的字符形态 我
布尔
* 类型 bool
* 只能去true 或者false
* 空间只有1个
字符串
* string 类型名称,是由字节组成的。
* GO语言的字符串的字节使用UTF-8 编码标识Unicode 文本,这样同一使用UTF-8 编码,避免中文乱码
* 字符串一旦赋值了,字符串就不能修改了,在GO中字符串不可变。
* 字符串的两种表示形式
(1) 双引号,会识别转义字符
(2)反引号 `` ,以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击,输出源代码等效果
* 字符串拼接 可以直接使用 +
str := `package main func main() { fmt.Println("hello world!") }`
fmt.Println(str)
注意:
- Go 中不允许不同类型之间的混合使用,但是对于常量的类型限制非常少,因此允许常量之间的混合使用
func jis2() {
var a int
var b int32
a = 15
b = a + a // 编译错误
b = b + 5 // 因为 5 是常量,所以可以通过编译
}
- 常量常量使用关键字 const 定义,用于存储不会改变的数据。存储在常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型。
const PI = 3.14 // const PI float= 3.14
const STRING = "stringconst" //const STRING string= "stringconst"
const INTEGER = 12 //const INTEGER int= 12
const BOOL = false //const BOOL bool = false
const FU = complex(1, 2) // 1+2i
const beef, two, c = "eat", 2, "veg" //多个
const Monday, Tuesday, Wednesday, Thursday, Friday,Saturday= 1, 2, 3, 4, 5, 6
const ( //枚举
Unknown = 0
Female = 1
Male = 2
)
const (
a = iota //0
b // 1
c //2
)
- 变量声明变量
var num int = 12;
var num1 int // 默认0
var num2 = 123.32
num3 := 12.23
var a,b,c = 12,13.12,"hello"
- 使用注意:
- (1) 该区域的数据值可以在同一个类型范围内不断变化
- (2)变量在同一作用于内不能重名
- (3)变量 = 变量名 + 值 + 数据类型
- Golang和 Java 与C 不同,Go在不同类型的变量之间赋值时需要显式转换,也就是或Golang基本数据类型不能自动转换。Java可以比如 float b = 4基本语法 表达式 T(v) 将值v 转换为类型T
func dateZhuan() {
var num int = 2
var num1 float32 = float32(num)
fmt.Println(num1)
}
-
GO中,数据类型的转换可以是从表示范围小 --> 表示范围答,也可以 范围大 --> 范围小
-
被转换的时变量存储的数据(即值),变量本身的数据类型并没有变化
-
在转换中,比如 将int64 转为8 ,编译时不会报错,只是转换的结果是按溢出处理,和我们希望的结果不一样、
-
基本数据类型转string方法1 fmt.Sprintf("%参数", 表达式) 较灵活
package main
import "fmt"
func main() {
var num1 int = 23
var num2 float64 = 23.23
var num3 bool = false
var mychar byte = 'a'
var str string
str = fmt.Sprintf("%d", num1)
fmt.Printf("str 的类型 %T, 和值 %v\n", str, str)
str = fmt.Sprintf("%f", num2)
fmt.Printf("str 的类型 %T, 和值 %v\n", str, str)
str = fmt.Sprintf("%t", num3)
fmt.Printf("str 的类型 %T, 和值 %v\n", str, str)
str = fmt.Sprintf("%c", mychar)
fmt.Printf("str 的类型 %T, 和值 %v\n", str, str)
// 第二种方法
str = strconv.FormatInt(int64(num1), 10)
fmt.Printf("str 的类型 %T, 和值 %q\n", str, str)
str = strconv.FormatFloat(num2, 'f', 8, 64) //保留8位小数,64表示这个小数是 float64
fmt.Printf("str 的类型 %T, 和值 %q\n", str, str)
str = strconv.FormatBool(num3)
fmt.Printf("str 的类型 %T, 和值 %q\n", str, str)
str = fmt.Sprintf("%c", mychar)
fmt.Printf("str 的类型 %T, 和值 %q\n", str, str)
}
第二种方法使用strconv包的函数。
strconv Go讲解 : https://studygolang.com/pkgdoc
string转基本数据类型
func stringToBase() {
num1, num2, num3 := "true", "12","23.23"
str,err := strconv.ParseBool(num1)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(str)
str1,err1 := strconv.ParseInt(num2, 10, 64 )
if err1 != nil {
fmt.Println(err1)
return
}
fmt.Println(str1)
str2,err2 := strconv.ParseFloat(num3, 64)
if err2 != nil {
fmt.Println(err2)
return
}
fmt.Println(str2)
}
- strconv Go讲解 : https://studygolang.com/pkgdoc
指针
- 基本数据类型,变量存的就是值,也叫值类型
- 获取变量的地址,用& ,var num int 获取num的地址,&num
- 指针类型,变量存的就是一个地址,这个地址指向的空间存的才是值。比如 var ptr *int = &num
- 获取指针类型所指向的值,使用 * , 比如使用 *ptr 获取ptr 指向的值 num
var num int = 10
var ptr *int = &num
fmt.Printf("num的地址 %v \n", &num )
fmt.Printf("num的值 %v \n", num )
fmt.Printf("指针地址 %v \n", ptr )
fmt.Printf("指针所指向的值 %v \n", *ptr )
所以由上面的值可以看出 ptr指向了 num的存储空间。指针变量接收某一个变量的地址。
- 值类型 ,都有对应的指针类型,形式为 *数据类型, 比如 *int。
Go 中值类型与引用类型
- 值类型 : 基本数据类型 int系列,float 系列,bool string,数组和结构体struct
- 引用类型: 指针、slice切片、map、管道chan、interface 等都是引用类型
- 值类型与引用类型的区别:
- 值类型:变量直接存储数据,内存通常在栈中分配
- 引用类型:变量存储的时一个地址,这个地址对应的空间才真正存储数据(值),内存通常在堆上分配,当没有任何变量引用这个地址时,该地址对应的数据空间就成为一个垃圾,有GC来回收。