02go基本数据类型

go数据类型介绍

参考： http://docscn.studygolang.com/pkg/fmt/

go语言数据类型：

• 基本数据类型

  1. 整型
  2. 浮点型
  3. 布尔型
  4. 字符串

• 复合数据类型

  1. 数组
  2. 切片
  3. 结构体
  4. 函数
  5. map
  6. 通道（channel）
  7. 接口
  8. 等等

1、整型

分类：

• 有符号整型：int8、int16、int32、int64
• 无符号整型：uint8、uint16、uint32、uint64

特殊整型

int和uint:根据底层平台，表示32或64位整数。除非需要使用特定大小的整数，否则通常应该使用int来表示整数。

类型	说明
int	32 位操作系统上就是 int32，64 位操作系统上就是 int64
uint	32 位操作系统上就是 uint32，64 位操作系统上就是 uint64
uintptr	无符号整型，用于存放一个指针

注意事项 ：实际项目中整数类型、切片、 map 的元素数量等都可以用 int 来表示。 在涉及
到二进制传输、为了保持文件的结构不会受到不同编译目标平台字节长度的影响 ， 不要使
用 用 int 和 和 uint 。

package main
import (
	"fmt"
)
func main() {
	var num int64
	num = 123
	//%v => 值  %T => 变量的类型
	fmt.Printf("值:%v 类型%T", num, num) //值:123 类型int64
}

unsafe.Sizeof

unsafe.Sizeof(n1) 是 unsafe 包的一个函数，可以返回 n1 变量占用的字节数。

package main
import (
	"fmt"
	"unsafe"
)
func main() {
	var a int8 = 120
	fmt.Printf("%T\n", a)
	fmt.Println(unsafe.Sizeof(a))
}

int 不同长度直接的转换

package main
import (
	"fmt"
)
func main() {
	var num1 int8
	num1 = 127
	num2 := int32(num1)
	fmt.Printf("值:%v 类型%T", num2, num2) //值:127 类型 int32
}

数字字面量语法（Number literals syntax)

Go1.13 版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮
点数的格式定义数字，例如：
v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。 v := 0o377，代表八进制的
377，相当于十进制的 255。 v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25。 而
且还允许我们用 _ 来分隔数字，比如说：
v := 123_456 等于 123456。
我们可以借助 fmt 函数来将一个整数以不同进制形式展示。

package main
import "fmt"
func main(){
	// 十进制
	var a int
	a = 10
	fmt.Printf("%d \n", a) // 10
	fmt.Printf("%b \n", a) // 1010 占位符%b 表示二进制
	// 八进制 以 0 开头
	var b int
	b = 077
	fmt.Printf("%o \n", b) // 77
	// 十六进制 以 0x 开头
	var c int
	c = 0xff
	fmt.Printf("%x \n", c) // ff
	fmt.Printf("%X \n", c) // FF
	fmt.Printf("%d \n", c) // 255
}

2、浮点型

Go 语言支持两种浮点型数：float32 和 float64。

这两种浮点型数据格式遵循 IEEE 754 标准：
float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。float64 的
浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。

package main
import (
	"fmt"
	"math"
)
func main() {
	fmt.Printf("%f\n", math.Pi) //默认保留 6 位小数
	fmt.Printf("%.2f\n", math.Pi) //保留 2 位小数
}

Go 语言中浮点数默认是 float64

3、复数

complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

Golang 中 中 float 精度丢失问题

几乎所有的编程语言都有精度丢失这个问题，这是典型的二进制浮点数精度损失问题，在定
长条件下，二进制小数和十进制小数互转可能有精度丢失。

d := 1129.6
fmt.Println((d * 100)) //输出：112959.99999999999

var d float64 = 1129.6
fmt.Println((d * 100)) //输出：112959.99999999999
m1 := 8.2
m2 := 3.8
fmt.Println(m1 - m2) // 期望是 4.4，结果打印出了 4.399999999999999

使用第三方包来解决精度损失问题：
https://github.com/shopspring/decimal

Golang 科学计数法

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)

4、布尔值

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。

注意：

1. 布尔类型变量的默认值为false。
2. Go 语言中不允许将整型强制转换为布尔型.
3. 布尔型无法参与数值运算，也无法与其他类型进行转换。

package main
import (
	"fmt"
	"unsafe"
)
func main() {
	var b = true
	fmt.Println(b, "占用字节：", unsafe.Sizeof(b))
}

5、字符串

Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样。 Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容，可以在Go语言的源码中直接添加非ASCII码字符，例如：

s1 := "hello"
s2 := "你好"

字符串转义符

Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表所示。

转义符	含义
\r	回车符（返回行首）
\n	换行符（直接跳到下一行的同列位置）
\t	制表符
\'	单引号
\"	双引号
\\	反斜杠

多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符：和js ES6 用法一样

s1 := `第一行
第二行
第三行
`
fmt.Println(s1)

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

字符串的常用操作

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

例子：

package main

import (
	"fmt" 
	"strings"
)
func main()  {
	//len() str 长度
	var str = "hello kaka"
	fmt.Println(len(str)) //10

	// 拼接字符串
	var str1 = "您好" 
	var str2 =	"go"
	fmt.Println(str1 + str2) //您好go

	var str3 = fmt.Sprintf("%v %v",str1, str2) //您好 go
	fmt.Println(str3)

	//.Split 分割字符串
	var str4 = "123-456-789"
	var arr = strings.Split(str4, "-")
	fmt.Println(arr) //[123 456 789]

	//判断是否包含字符串
	var str5 = "this is golang"
	var flag = strings.Contains(str5, "golang")
	fmt.Println(flag)  //true

	//判断首字符尾字母是否包含指定字符
	var str6 = "this is golang"
	var flag2 = strings.HasPrefix(str6, "this")
	fmt.Println(flag2)  //true
	var str7 = "this is golang"
	var flag3 = strings.HasSuffix(str7, "go")
	fmt.Println(flag3) //false

	//判断字符串出现的位置	
	var str8 = "this is golang"
	var index1 = strings.Index(str8, "is") //第一个is的index
	fmt.Println(index1)  //2
	var str9 = "this is golang"
	var index2 = strings.LastIndex(str9, "is") //最后一个is的index
	fmt.Println(index2)  //5

	//jion 拼接字符串
	var str10 = "123-456-789"
	var arr2 = strings.Split(str10, "-")
	var str12 = strings.Join(arr2, "*")
	fmt.Println(str12) //123*456*789
}

6、byte 和 和 rune 类型

组成每个字符串的元素叫做“字符”，属于int类型，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来，如：

var a := '中'
var b := 'x'

Go 语言的字符有以下两种：

1. uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
2. rune类型，代表一个 UTF-8字符。

1、byte 等同于Uint8，常用来处理ascii字符

2、rune 等同于int32,常用来处理unicode或utf-8字符

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。

// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.

//int32的别名，几乎在所有方面等同于int32
//它用来区分字符值和整数值

type rune = int32

GO默认是utf-8

6.1、go查看数据类型

package main

import (
	"fmt"
	"reflect"
)
func main()  {
    v1 := 'a'
	v2 := '中'
	v3 := "中国"
	//第一种方法
    fmt.Printf("v1 type:%T\n", v1)  //v1 type: int32 （字符的码值是整数型）
	fmt.Printf("v2 type:%T\n", v2)  //v2 type: int32
	fmt.Printf("v3 type:%T\n", v3)  //v3 type: string
	
    //第二种方法，结果一样
	fmt.Println("v1 type:", reflect.TypeOf(v1))
	fmt.Println("v2 type:", reflect.TypeOf(v2))
	fmt.Println("v3 type:", reflect.TypeOf(v3))
}

6.2、查看字符的码值

package main

import (
	"fmt"
	// "reflect"
)
func main()  {
    v1 := 'a'
	v2 := '中'
	v3 := "中国"
	v4 := "abc"

    //当我们直接输出 byte（字符）的时候输出的是这个字符对应的码值
	fmt.Println(v1) //97 这里是ascii的值
	fmt.Println(v2) // 20013 这里是utf-8对应的值
	fmt.Println(v3) // 中国
	fmt.Println(v4) //abc  
    
    //如果我们要输出这个字符，需要格式化输出，%c 相应 Unicode 码点所表示的字符
	fmt.Printf("%c\n", v1)  //a
	fmt.Printf("%c\n", v2)  //中
	fmt.Printf("%c\n", 100) //100
}

6.3 查看字符的长度

// 中文3个字节，英文1个字节
a := "m"
fmt.Println(len(a)) //1
b := "张"
fmt.Println(len(b)) //3

得到str的字符串长度

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {

    var str = "hello 你好"

    //golang中string底层是通过byte数组实现的，座椅直接求len 实际是在按字节长度计算  所以一个汉字占3个字节算了3个长度
    fmt.Println("len(str):", len(str))
    
    //以下两种都可以得到str的字符串长度
    
    //golang中的unicode/utf8包提供了用utf-8获取长度的方法
    fmt.Println("RuneCountInString:", utf8.RuneCountInString(str))  //RuneCountInString:8

    //通过rune类型处理unicode字符
    fmt.Println("rune:", len([]rune(str)))  // rune:8
}

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

package main

import "fmt"
func main() {
	s := "hello 张三"
	for i := 0; i < len(s); i++ { //byte  len(s) == 12
	fmt.Printf("%v(%c) ", s[i], s[i])
	}
	fmt.Println()
	for _, r := range s { //rune
	fmt.Printf("%v(%c) ", r, r)
	}
	fmt.Println()
}

输出：

104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 229(å) 188(¼) 160( ) 228(ä) 184(¸) 137()
104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 24352(张) 19977(三)

因为 UTF8 编码下一个中文汉字由 3 个字节组成，所以我们不能简单的按照字节去遍历一个
包含中文的字符串，否则就会出现上面输出中第一行的结果。
字符串底层是一个 byte 数组，所以可以和[]byte 类型相互转换。字符串是不能修改的 字符
串是由 byte 字节组成，所以字符串的长度是 byte 字节的长度。 rune 类型用来表示 utf8 字
符，一个 rune 字符由一个或多个 byte 组成。

7 、 修改字符串

要修改字符串，需要先将其转换成[]rune 或[]byte，完成后再转换为 string。无论哪种转换，
都会重新分配内存，并复制字节数组。

字符串不能通过index的方式直接修改。

//感觉很麻烦，改来改去的，不如python方便
func changeString() {
	s1 := "big"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))
	
	s2 := "白萝卜"
	runeS2 := []rune(s2)
	runeS2[0] = '红'
	fmt.Println(string(runeS2))
}