4、基本数据类型

4.1、变量

4.1.1标识符与关键字

标识符和Java一样，$除外

# 必须先声明后使用
var 变量名 变量类型
var name int 
eg: var a int = 9
eg: var a int
    a = 9

package main

import "fmt"
// 也可以在外面声明
var str string

// 批量声明
var(
    a string
    b int
    c bool
    d float32
)
func main()  {
    // 声明变量
    var name string
    name = "name"
    fmt.Println(name)
}

package main

import "fmt"

// 批量声明
var(
    a string
    b int
    c bool
    d float32
)
func main()  {
    // 声明变量
    a = "name"
    fmt.Println(a)
    // 在go语言中声明的变量必须要使用，不使用编译不过去
}

func main()  {
    // 声明变量
    a = "name"
    fmt.Printf("a:%s",a) // 和c语言一样，占位符号，必须用Printf,用println不行
    // 在go语言中声明的变量必须要使用，不使用编译不过去
}

类型推导

var s = "name" // 识别为string类型
    fmt.Print(s)

短变量声明

//短变量声明,只能在函数内部使用
    s3 := 12
    fmt.Println(s3)

匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用|匿名变量(anonymous variable)。匿名变量用一个下划线表示，例如:

import "fmt"

// 匿名变量
func foo() (int, string) {
    return 10, "Q1min"
}
func main() {
    x,_ := foo()
    _,y := foo()
    fmt.Println("x=",x)
    fmt.Println("y=",y)
}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。 (在Lua等编程语言里，匿名变量也被叫做哑元变量。)

注意事项：

1. 函数外的每个语句都必须以关键字开始（var、const、func等）
2. :=不能使用在函数外。
3. _多用于占位，表示忽略值。

4.2、常量

    // 常量
    const PI = 3.1415
    // 多个常量一起声明    // 常量
    const PI = 3.1415
    // 多个常量一起声明，某一行没有赋值，默认和上一行一样
    const (
        Pi = 3.1415
        e
    )
    const (
        Pi = 3.1415
        e = 2.7182
    )

iota

iota是go语言的常量计数器，只能在常量的表达式中使用。
iota在const关键字出现时将被重置为o。const中每新增一行常是声明将使ioto计数一次(ipta可理解为const语句块中的行索引。使用iota能简化定义，在定义枚举时很有用。

const (
        a1 = iota // 0
        a2        // 1
        a3        // 2
        a4        // 3
    )

    const (
         b1 = iota // 0
         b2        // 1
         _         // 2
         b3        // 3
    )

    const (
        c1 = iota  //0
        c2 = 100   // 100
        c3 = iota  // 2
        c4        // 3
    )

    const (
        d1 ,d2 =iota+1 ,iota+2 // d1 :1 , d2 :2
        d3 ,d4 = iota +1,iota+1 // d3:2 , d4:2
    )

实站

    // 定义数量级
    const (
        _  = iota   //这里用的匿名变量，默认值 0开始
    KB = 1 << (10 * iota)  
    MB = 1 << (10 * iota)
    GB = 1 << (10 * iota)
    TB = 1 << (10 * iota)
    PB = 1 << (10 * iota)
    )

4.3、整型

整型分为以下两个大类： 按长度分为：int8、int16、int32、int64 对应的无符号整型：uint8、uint16、uint32、uint64

其中，uint8就是我们熟知的byte型，int16对应C语言中的short型，int64对应C语言中的long型。

特殊整型

注意： 在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。

注意事项 获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或 map 的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和 uint。

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

Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：

v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。 v := 0o377，代表八进制的 377，相当于十进制的 255。 v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25。

而且还允许我们用 _ 来分隔数字，比如说： v := 123_456 表示 v 的值等于 123456。

package main

import "fmt"
// 十进制
var i1 = 10
// 八紧制
var i2 = 077
// 十六进制
var i3 = 0x9A
func main() {

    // %d为十进制，%b为二进制
    fmt.Printf("%d\n",i1)

    // %o为八进制
    fmt.Printf("%o\n",i2)

    // %x为十六进制
    fmt.Printf("%x\n",i3)

    // 查看变量的类型
    fmt.Printf("%T\n",i1)
    // 声明为int8类型的变量
    i4 := int8(9)
    fmt.Printf("%T\n",i4)
    fmt.Printf("%d",i4)
}

4.4、浮点型

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

package main

import (
    "fmt"
)
// 浮点数

func main() {

    // math.MaxFloat64
    // 默认是float64类型
    f1 := 1.23456
    fmt.Printf("%f\n",f1)
    //float32
    f2 := float64(1.2454)
    // float32不能直接转给我float64
    fmt.Printf("%f",f2)
}

4.5、复数

complex64和complex128

package main

import "fmt"


func main() {
    // 复数
    var c1 complex64
    c1 = 1 + 2i
    var c2 complex128
    c2 = 2 + 3i
    fmt.Print(c1)
    fmt.Print(c2)

}

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

4.6布尔值

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

注意：

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

package main

import "fmt"

func main() {

    var bool1 bool
    fmt.Println(bool1)
    var bool2 bool = true
    fmt.Println(bool2)
    // 查看数据类型
    fmt.Printf("%T value:%v",bool1,bool1)
}

5、fmt占位符

package main

import "fmt"

// fmt占位符
func main() {

    var n = 100
    fmt.Printf("%T\n",n)
    fmt.Printf("%v\n",n)
    fmt.Printf("%b\n",n)
    fmt.Printf("%d\n",n)
    fmt.Printf("%o\n",n)
    fmt.Printf("%x\n",n)
    // 演示转义字符
    fmt.Println("hello\tjack")
    fmt.Println("hello\njack")
    fmt.Println("hello\\jack")
    fmt.Println("hello\rjack") // 当前行的最前开始覆盖，hello\rjack会输入jack
    var s = "hello"

    fmt.Printf("%s\n",s)

}

6、字符串

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

• 只能用双引号

     // 字符串必须使用双引号
      var str string = "hello wrold"
   // 字符必须使用单引号
      str1 := 'h'

  字符串转义符

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

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

6.1、多行字符串

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

    // 多行字符串
    str2 := `
多行字符
你是你
我是我
`
    fmt.Printf(str2)

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

6.2、字符串的常用操作

package main

import (
    "fmt"
    "strings"
)

func main() {

    // 字符串拼接
    name := "he\\llo"
    world := "world"
    fmt.Println(name+world)
    fmt.Printf("%s%s\n",name,world)
    // 分割字符串
    ret := strings.Split(name,"\\")
    fmt.Println(ret)
    // 包含
    fmt.Println(strings.Contains(name,"l"))
    // 前缀
    fmt.Println(strings.HasPrefix(name,"h"))
    // 后缀
    fmt.Println(strings.HasSuffix(name,"o"))

    // 判断位置
    str3 := "abdcde"
    fmt.Println(strings.Index(str3,"c"))
    fmt.Println(strings.LastIndex(str3,"d"))
    // 拼接
    fmt.Println(strings.Join(ret,"+"))
    // 长度
    fmt.Println(len(str3))
}

6.3、byte和rune类型

package main

import "fmt"
 // byte和rune
func main() {

    str3 := "abdcde"
    for _,c := range str3{

        //fmt.Println(c)
        fmt.Printf("%c",c)
    }
    // 字符串修
    s2 := "大帅比"
    // 转换为rune切片
    s3 := []rune(s2)
    s3[0] = '王'
    // 把切片转换为字符串
    fmt.Println(string(s3))
}