Go The Way 之 数据类型

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来回收。