golang 基本数据类型

整型

类型	描述
uint8	无符号 8位整型 (0 到 255)
uint16	无符号 16位整型 (0 到 65535)
uint32	无符号 32位整型 (0 到 4294967295)
uint64	无符号 64位整型 (0 到 18446744073709551615)
int8	有符号 8位整型 (-128 到 127)
int16	有符号 16位整型 (-32768 到 32767)
int32	有符号 32位整型 (-2147483648 到 2147483647)
int64	有符号 64位整型 (-9223372036854775808 到 9223372036854775807)
uint	32位操作系统上就是uint32，64位操作系统上就是uint64,动态类型
int	32位操作系统上就是int32，64位操作系统上就是int64,动态类型
uintptr	无符号整型，用于存放一个指针

在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和 uint.

打印整型时，可以使用fmt包配合%d十进制,%o八进制,%x十六进制

默认值:0

浮点型

打印浮点数时，可以使用fmt包配合%f

package main
import (
        "fmt"
        "math"
)

func main()  {
	fmt.Printf("%f\n",math.Pi)
	fmt.Printf("%.2f\n",math.Pi)
}

默认值:0

布尔型

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

注意：

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

byte和rune

字符类型,用''单引号

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

1. byte 型,本质是个uint8类型,代表了ASCII码的一个字符。
2. rune类型,本质是int32类型,代表一个 UTF-8字符。

var a = '中'
var b = 'z'

打印的时候,byte会打印出byte对应的ASCII码

默认值:byte和rune都是0

字符串

单行字符串:" "使用双引号

var s1 string = "agsol"

多行字符串:使用反引号

反引号里写啥都直接当成字符串

var s2 string = `
				line 1
				line 2
				line 3
				`

字符串操作

方法

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

len()函数中,返回的字节的长度,所以当出现ascii以外的编码标准的时候,就可能出现长度不准的问题

unicode是字符集,utf-8是动态的编码规则

所以当出现中英文的时候,先将string转换为[]rune(string)再求len,长度就不会出错了

package main

import (
	"fmt"
	"strings"
)

func main() {
	var str string = "show me your money"
	//len
	var nameLen int = len(str)
	fmt.Println("len:",nameLen)
	//strings.Contains
	fmt.Println("strings.Contains:",strings.Contains(str,"money"))
	//strings.HasPrefix
	fmt.Println("strings.HasPrefix:",strings.HasPrefix(str,"show"))
	//strings.HasSuffix
	fmt.Println("strings.HasSuffix:",strings.HasSuffix(str,"money"))
	//strings.Index
	fmt.Println("strings.Index:",strings.Index(str,"me"))
	//strings.Count
	fmt.Println("strings.Count:",strings.Count(str,"money"))
	//strings.Split(str," ")
	var sep []string = strings.Split(str," ")
	for i:= 0;i<len(sep);i++ {
		fmt.Println(sep[i])
	}
	//strings.Replace
	fmt.Println("strings.Replace:",strings.Replace(str,"show","give",1))
}
-------------------------------------------
len: 18
strings.Contains: true
strings.HasPrefix: true
strings.HasSuffix: true
strings.Index: 5
strings.Count: 1
show
me
your
money
strings.Replace: give me your money

字符串的修改

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

func main()  {
	var s1 = "agsol"
	fmt.Printf("%c\n",s1[0])
	bytes1 := []byte(s1)
	bytes1[0] = 'b'
	fmt.Println(string(bytes1))
}
--------------------------------------
a
bgsol

默认值:""

注意

字符串是uint8数组,如果出现中文字符,且要遍历字符串的时候,要转换成rune数组再遍历,才不会出错

类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

强制类型转换的基本语法：T(表达式)

Go常量和变量之间可以支持隐式类型转换,但是不支持变量之间的隐式类型转换

//5.0是常量,所以这里不会报错
//而5.1就不可以了
var a int = 5.0
fmt.Println(a)
var d int = 5.1//报错
>>>5
//变量之间的转换会报错
var b float32 = 6.0
var c int = b//这时就会报错

字符串类型转换

strconv包

Itoa和Atoi

**int转换为字符串：**Itoa()

println("a" + strconv.Itoa(32))  // a32

string转换为int：Atoi()

i,_ := strconv.Atoi("3")
println(3 + i)   // 6

// Atoi()转换失败
i,err := strconv.Atoi("a")
if err != nil {
    println("converted failed")
}
//由于string可能无法转换为int，所以这个函数有两个返回值：第一个返回值是转换成int的值，第二个返回值判断是否转换成功。

Parse类函数

Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)

ParseInt()和ParseUint()有3个参数：

func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)

说明：

1. 1. bitSize参数表示转换为什么位的int/uint，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8。
   2. base参数表示以什么进制的方式去解析给定的字符串，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析。

Format类函数

将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16) //表示将-42转换为16进制数，转换的结果为-2a。
s := strconv.FormatUint(42, 16)

第二个参数base指定将第一个参数转换为多少进制，有效值为2<=base<=36。当指定的进制位大于10的时候，超出10的数值以a-z字母表示。例如16进制时，10-15的数字分别使用a-f表示，17进制时，10-16的数值分别使用a-g表示。

FormatFloat()参数众多：

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

fmt表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为二进制）、‘e’（-d.dddde±dd，十进制指数）、‘E’（-d.ddddE±dd，十进制指数）、‘g’（指数很大时用’e’格式，否则’f’格式）、‘G’（指数很大时用’E’格式，否则’f’格式）。

prec控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示小数点后的数字个数；对’g’、‘G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。