2020-01-20 20:53 已编辑门头沟学院产品经理

关注

1、go语言数据类型

内容参考雨痕的《Go语言学习笔记》
Go菜鸟教程

数据类型

1、变量

Go是静态类型语言，变量总是有固定的数据类型。我们只能修改变量值，不能改变类型。

定义变量：

第一种方式：var variable_name type

如 var name string
var age int

第二种方式：var name = "zhangsan"

var age = 25
当然，也可以一次定义多个变量
如var x,y int
var a,b,c = 1,"ab ","cd"
var (
x,y int
a,b,c = 10,"ab","cd"
)

第三种方式(简短模式)：name := "lisi"

func function_name{
    x:=100
    a,b,c := 1,"ab","cd"
}

简短模式的限制：
定义变量，同时显式初始化
不能提供数据类型
只能用在函数内部

错误情况

var x = 100
func main(){
    println(&x,x)   //  0x地址1    100
    x:="abc"      // 重新定义和初始化同名局部变量
    println(&x,x)   //  0x地址2     abc  
}

简短模式并不总是重新定义变量，也可能是部分退化的赋值操作

func main(){
    x := 100
    println(&x,x)  // 0x地址1    100
    x,y := 200,"abc"
    println(&x,x)  // 0x地址1    200
}

退化赋值的前提是：最少有一个新变量被定义，且必须是同一作用域
简短定义在函数多返回值，以及if/for/switch语句中定义局部变量非常方便

// 在处理函数错误返回值时，退化赋值允许我们重复使用err变量
package  main
import (
    "log"
    "os"
)
func main(){
    f,err = os.Open("/dev/random")
    
    buf := make([]byte,1024)
    n,err := f.Read(buf)  // err退化赋值，n新定义
}

多变量赋值

在进行多变量赋值操作时，首先计算出所有右值，再依次完成赋值操作

func main(){
    x,y := 1,2
    x,y = y+3,x+1
    println(x,y) // 5  2
}

赋值操作，必须保证左右值类型相同

未使用错误

编译器将未使用的局部变量当做错误，全部变量没问题

2、命名

命名建议

局部变量优先使用简短命名
使用驼峰拼写格式
首字母大小写决定了其作用域，大写可被包外引用，小写只能包内使用

空标识符

下划线 _ 作为空标志符。通常作为忽略占位符使用，可作表达式左值，无法读取内容

import "strconv"
func main(){
    x,_ := strconv.Atoi("12")   // 忽略Atoi的err返回值
    println(x)
}

_用来临时规避编译器对未使用变量和导入包的错误检查，它是预置成员，不能重新定义

func main(){
    _ := 123   // err no new variables on left side of :=
    println(_)  // err  cannot use _ as value
}

3、常量

常量表示运行时不变的值，通常是一些字面量。常量值必须是编译期可确定的字符、字符串、数字或布尔值。可以指定常量类型，或者由编译器通过初始化值推断

const  x,y int = 123,0x22
const s = "hello world"
const c = '我'

const (
    i,f = 1,0.1
    a = true
)

在函数中定义常量，未使用的常量不会引发编译错误

func main(){
    const x = 123
    {
        const x = "abc"
    }
}

如果显式指定类型，必须确保常量左右值类型一致，需要时可做显式转换。右值不能超出常量类型取值范围，否则会引发溢出错误

const (
    x,y int = 99,-9***yte = byte(x)
    c = uint8(y)  // err constant -999 overflows uint8
)

常量值也可以是某些编译器能计算出结果的表达式，如unsage.Sizeof、len、cap等

import "unsafe"

const (
    a = unsafe.Sizeof(uintptr(0))
    b = len("hello,world")
)

在常量组中如不指定类型和初始化值，则与上一行非空常量右值相同

import "fmt"
func main(){
    const (
        x  uint16 = 120
        y    // 120
        a = "abc"
        b    // "abc"
    )
}

枚举

Go没有明确意义上的枚举，借助iota实现一组自增常量值来实现枚举类型

const (
    x = iota   // 0
    y   // 1
    z   // 2
)

const (
    _ = iota  // 0
    a = 1 << (10*iota)  // 1 << (10*1)
    b   // 1 << (10*2)
    c   //  1 << (10*3)

)

自增作用范围为常量组。可在多常量定义中使用多个iota，各自单独计数，只须保证组中每行常量的列数量相同即可（列数量不同会报错）。

const (
     _,_ = iota,iota*10
    a,b
    c,d
    f   // 会报错，列数量必须一致
)

如果中断iota自增，则需要显式恢复，后序自增值按行序递增

const (
    _ = iota
    a              // 1
    b = 10
    b2            //10
    c = iota    // 4
    d              // 5
)

自增默认为int，可显式指定类型

const (
    a   =  iota    // int
    b   float32  =  iota   // float32
    c      // float32
    d = iota  //  int
 )

在实际编码中，建议用自定义类型实现用途明确的枚举类型？但这并不能将取值范围限定在预定义的枚举值内

常量和变量的区别

变量在运行期分配内存，常量通常会被编译器在预处理阶段直接展开，作为指令数据使用
通过go tool objdump -s

无类型声明的常量会直接展开，显式指定常量类型，编译器会做强类型检查

const x = 100
const y byte = x

const a int = 100
const b byte = a  // 错误 cannot use a (type int) as type byte in const initializer

4、基本类型

bool 长度 1 默认值fasle
byte 长度 1 默认值 0
int uint 长度 4/8 默认值 0 在32位是4，64位是8字节
int8 uint8 长度 1 默认值 0 -128~127 0~255
int16 uint16 长度2 默认值0
int32 uint32 长度4 默认值0
int64 uint64 长度8 默认值0

float32 长度4 默认值0.0
float64 长度8 默认值0.0

complex64 长度8
complex128 长度 16

rune 长度4 默认值0 Unicode Code Point，int32

uintptr 长度 4/8 默认值0

string 默认值 ""
array
struct
function
interface
map 引用类型
slice 引用类型
channel 引用类型

别名
byte uint8
rune int32