go的基本类型

• 布尔型 bool
  • 长度 1字节
  • 取值 true false
  • 不能使用数字取代
• 整型 int/uint
  • 根据运行平台可能为32/64位
• 8位整型（byte） int8/uint8
  • 长度 1字节
  • 取值范围 -127 ~ 127 / 0~255
• 16位整型 int16/uint16
  • 长度 2字节
  • 取值范围 -32768 ~ 32768 / 0 ~ 65535
• 32位整型（rune） int32/uint32
  • 长度 4字节
  • 取值范围 -2^32 ~ 2^32
• 64位整型 int64/uint 64
  • 取值范围 -2^64 ~ 2^64
• 浮点型 floot32/floot64
  • 长度 4/8字节
  • 小数位 精确到7/15位
• 复数类型 complex64/complex128
  • 长度8/64字节
• 保存指针的32/64位的整数型 uintptr

go的值类型

• string
• array
• struct

go的引用类型

• slice
• map
• chan

go的接口类型

• interface

go的函数类型

• func

go基本类型的声明规则

• 基本方式
  • 声明方式 var <name> <type>
  • 声明范围: 全局 代码块
• 简写方式
  • 声明方式 var <name> = <value>
  • 声明范围: 全局 代码块
  • 注意事项: 需要给定初始值
• 类型推导
  • 声明方式 <name>:=<value>
  • 声明范围: 代码块

作用域

• 全局变量作用域：函数内部可修改，会影响其他函数，所有代码块都可以使用
• 局部变量作用域：只在函数内部使用，也可用于闭包函数

全局变量的声明、赋值和使用

package main

import "fmt"

var i int

func main() {
  i = 10
  fmt.Println(i)
}

全局变量会被修改

package main

import "fmt"

var i int

func main() {
  i = 10
  var f func() = test
  f()
  fmt.Println(i)
}

func test() {
    i = 100
    fmt.Println(i)
}

输出 100 100

使用其他声明方式声明变量

package main

import "fmt"

var n = 10
func main() {
  fn:=test
  fn()
  var b = false
  fmt.Println(n,b)
}

func test() {
    var i = 100
    fmt.Println(i)
}

输出 100 10 false

常量

常量定义

const <name> <type> = <value>
或者 省略类型
const <name> = <value>

package main

import "fmt"

const PI float64 = 3.1415926
func main() {
    // 声明多个
    const N,S = 1,"str"
    fmt.Println(PI,N,S)
    test()
    // 代码块内声明
    {
        const SIZE_T = 1
        fmt.Println(SIZE_T)
    }
}

// 函数内部声明
func test() {
    // 简写方式
    const BUF_SIZE = 1024
    fmt.Println(BUF_SIZE)
}

输出 3.1415926 1 str 1024 1

常量组

声明方式

const (
  <name> <type> = <value>
  ...
)

package main

import "fmt"

func main()  {
    const (
        a int = 10
        b   // 不提供类型和初始化值，那么视为和上一常量相同
        c = 20
        d
    )
    fmt.Println(a,b,c,d)
}

输出 10 10 20 20

iota

在常量组中, iota 每次自增 初始值为0

package main

import "fmt"

func main()  {
    // 枚举
    const (
        Sunday = iota // 0
        Monday // 1
        Tuesday // 2
        Wednesday // 3
        Thursday // 4
        Friday // 5
        Saturday //6
    )
    fmt.Println(Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday)
    // iota 每次自增 初始值为0
    const (
        _ = iota
        KB int64 = 1 << (10 * iota)
        MB          // iota = 2
        GB
        TB
    )
    fmt.Println(KB,MB,GB,TB)
}

输出 0 1 2 3 4 5 6
1024 1048576 1073741824 1099511627776

类型转换

• go语言不支持隐式转换 （从低位转向高位也不行）

例如
var i int = 1
i = 1.2 // error

• 支持显式转换 可以从高位转向低位

例如

package main

import "fmt"

func main()  {
    var f float64 = 1.2
    var i byte = byte(f)
    fmt.Println(i)
}