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（假）两个值。

注意：

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

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 语言的字符有以下两种：

uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
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))
}

posted @ 2020-07-14 00:43 slzhao 阅读(158) 评论(0) 收藏举报

刷新页面返回顶部

slzhao