01.类型、变量和常量

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
    • 声明范围: 全局 代码块
  • 简写方式
    • 声明方式 var =
    • 声明范围: 全局 代码块
    • 注意事项: 需要给定初始值
  • 类型推导
    • 声明方式 :=
    • 声明范围: 代码块

作用域

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

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

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 =
或者 省略类型
const =

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 (
    = 
  ...
)
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)
}

你可能感兴趣的:(01.类型、变量和常量)