GO数据类型

基本数据类型

Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。
整形
获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。
打印时可以用%d打印
八进制/十六进制
八进制以0开头，使用%o打印
十六进制以0x开头，使用%x打印
浮点型
Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。
可使用%f打印,%.2f表示只打印2位小数
布尔值
布尔型数据只有true（真）和false（假）两个值。
字符串
Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容。多个byte集合，理解为一个字符序列，用双引号来表示！

例子：s1 := "ares"

单引号与双引号区别

v1 := 'A'
v2 := "A"
fmt.Printf("类型:%T,内容:%v\n",v1,v1)  //类型:int32,内容:65
fmt.Printf("类型:%T,内容:%v\n",v2,v2)  //类型:string,内容:A

 

字符串转义符

转义符	含义
\r	回车
\n	换行符
\t	制表符
\'	单引号
\"	双引号
\	反斜杠

 

fmt.Println("\"Hello World!\"")  //"Hello World!"

fmt.Println("\"Hello \t World!\"")  //"Hello     World!"

 

多行字符串
Go语言中要定义一个多行字符串时，就必须使用反引号字符"`"
字符串常用操作

代码示例：

package main

import (
    "fmt"
    "strings"
)

//字符串操作
func main() {
    s1 := "ares"
    fmt.Println(len(s1))     //4
    //字符串拼接
    s2 := "GO"
    fmt.Println(s1 + s2)    //aresGO
    s3 := fmt.Sprintf("%s----%s", s1, s2)
    fmt.Println(s3)    //ares----GO
    //分割
    ret := strings.Split(s1, "r")
    fmt.Println(ret)    //[a es]
    //判断是否包含
    ret2 := strings.Contains(s1, "a")
    ret3 := strings.Contains(s1, "a1")
    fmt.Println(ret2, ret3)        //true false
    //判断前缀和后缀
    ret4 := strings.HasPrefix(s1, "ar")  //是不是以ar做前缀
    ret5 := strings.HasSuffix(s1, "es1") //是不是以es1做后缀
    fmt.Println(ret4, ret5)        //true false
    //判断子串出现的位置
    s4 := "applepen"
    fmt.Println(strings.Index(s4, "p"))        //1
    fmt.Println(strings.LastIndex(s4, "p"))        //5
    //join
    a1 := []string{"Python", "PHP", "JS", "Ruby", "Golang"}
    fmt.Println(a1)        //[Python PHP JS Ruby Golang]
    fmt.Println(strings.Join(a1, "-"))        //Python-PHP-JS-Ruby-Golang
}

 

byte和rune类型
组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来，如：var a := '中'
Go 语言的字符有以下两种： 1. uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。 2. rune类型，代表一个 UTF-8字符。rune类型实际是一个int32。
字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。

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

类型转换
Go语言中只有强制类型转换，没有隐式类型转换。 基本语法：T(表达式)
T表示要转换的类型，兼容类型才可以转换！

//变量需要手工转型
var w1 int8
w1 = 10
var w2 int16
w2 = int16(w1) //先将w1转为int16类型再赋值给w2
fmt.Printf("w1类型：%T,w1数值：%v，w2类型：%T,w2数值：%v\n", w1,w1,w2,w2)  //w1类型：int8,w1数值：10，w2类型：int16,w2数值：10
f1 := 3.14
var f2 int
f2 = int(f1)
fmt.Printf("f1类型：%T,f1数值：%v，f2类型：%T,f2数值：%v\n", f1,f1,f2,f2)  //f1类型：float64,f1数值：3.14，f2类型：int,f2数值：3
//常量在有需要的时候自动转
sum := f1 + 10
fmt.Printf("%T,%v",sum,sum)  //float64,13.14

代码示例：

package main

//字符
import "fmt"

func main() {
    s1 := "Golang"
    c1 := 'G'           //ASCII下占一个字节
    fmt.Println(s1, c1) //Golang 71
    s2 := "中国"
    c2 := '中'           //UTF8下中文字符占3字节
    fmt.Println(s2, c2) //中国 20013
    s3 := "hello青年路"
    fmt.Println(len(s3)) //14

    //遍历字符串
    for i := 0; i < len(s3); i++ {
        fmt.Printf("%c\n", s3[i])
    }
    fmt.Println()
    // for range 循环，是按照rune类型去遍历
    for _, v := range s3 {
        fmt.Printf("%c\n", v)
    }
    //打印索引
    for k, v := range s3 {
        fmt.Printf("%d%c\n", k, v)
    }
    //强制类型转换
    s5 := "big"
    //将字符串强制转换成字节数组类型
    byterArray := []byte(s5)
    fmt.Println(byterArray) //[98 105 103]
    //修改字符串
    byterArray[0] = 'p'
    fmt.Println(byterArray) //[112 105 103]
    //将字节数组强制转换成字符串类型
    s5 = string(byterArray)
    fmt.Println(s5) //pig
    //修改字符串
    s6 := "菜鸟"
    arr6 := []rune(s6)
    arr6[0] = '大'
    fmt.Println(string(arr6)) //大鸟
    //字符串反转
    a1 := "hello"
    arr := []byte(a1) // [h e l l o]
    a2 := ""          //定义空的字符串
    for i := len(arr) - 1; i >= 0; i-- {
        //i 是 4 3 2 1 0
        // arr[i] o l l e h (字符)
        a2 = a2 + string(arr[i])
    }
    fmt.Println(a2) //olleh
    //反转2
    length := len(arr)
    for i := 0; i < length/2; i++ {
        arr[i], arr[length-1-i] = arr[length-1-i], arr[i]
    }
    fmt.Println(string(arr)) //olleh
}