go语言入门（2）数据类型

1，命名

　　Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。大写字母和小写字母是不同的：heapSort和Heapsort是两个不同的名字。

Go语言中类似if和switch的关键字有25个(均为小写)。关键字不能用于自定义名字，只能在特定语法结构中使用。

break       default        func         interface        select

case        defer           go            map               struct

chan        else            goto           package          switch

const        fallthrough     if             range            type

continue     for              import        return            var

此外，还有大约30多个预定义的名字，比如int和true等，主要对应内建的常量、类型和函数。

内建常量:

    true false iota nil

内建类型:

        int int8 int16 int32 int64

        uint uint8 uint16 uint32 uint64 uintptr

        float32 float64 complex128 complex64

        bool byte rune string error

内建函数:

        make len cap new append copy close delete

        complex real imag

        panic recover

2，变量

变量是几乎所有编程语言中最基本的组成元素，变量是程序运行期间可以改变的量。

变量相当于是对一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。

1）变量声明

Go语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明， Go语言引入了关键字var，而类型信息放在变量名之后，示例如下：

    var v1 int

    var v2 int

    //一次定义多个变量

    var v3, v4 int 

    var (

        v5 int

        v6 int

    )

2）变量初始化

对于声明变量时需要进行初始化的场景， var关键字可以保留，但不再是必要的元素，如下所示：

    var v1 int =    // 方式1

    var v2 =        // 方式2，编译器自动推导出v2的类型

    v3 :=           // 方式3，编译器自动推导出v3的类型

    fmt.Println("v3 type is ", reflect.TypeOf(v3)) //v3 type is  int

    //出现在 := 左侧的变量不应该是已经被声明过，:=定义时必须初始化

    var v4 int

    v4 :=  //err

3）变量赋值

　　var v1 int

    v1 = 

    var v2, v3, v4 int

    v2, v3, v4 = , ,     //多重赋值

    i :=

    j :=

    i, j = j, i    //多重赋值

4）匿名变量

_, i, _, j := , , , 

func test() (int, string) {

    return , "hi"

}

_, str := test()

3，常量

　　在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。

1）字面常量(常量值)

所谓字面常量（literal），是指程序中硬编码的常量，如：

3.1415  // 浮点类型的常量

3.2+12i // 复数类型的常量

true  // 布尔类型的常量

"foo" // 字符串常量

2）常量定义

const Pi float64 = 3.14

const zero = 0.0 // 浮点常量, 自动推导类型

const ( // 常量组

        size int64 =

        eof        = -     // 整型常量, 自动推导类型

)

 const u, v float32 = ,  // u = 0.0, v = 3.0，常量的多重赋值

 const a, b, c = , , "foo"

    // a = 3, b = 4, c = "foo"    //err, 常量不能修改

3）iota枚举

常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。

在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。

const (

        x = iota // x == 0

        y = iota // y == 1

        z = iota // z == 2

        w  // 这里隐式地说w = iota，因此w == 3。其实上面y和z可同样不用"= iota"

    )

    const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0

    const (

        h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同

    )

    const (

        a       = iota //a=0

        b       = "B"

        c       = iota             //c=2

        d, e, f = iota, iota, iota //d=3,e=3,f=3

        g       = iota             //g = 4

    )

    const (

        x1 = iota *  // x1 == 0

        y1 = iota *  // y1 == 10

        z1 = iota *  // z1 == 20

    )

4，数据类型

类型    名称    长度    零值    说明

bool    布尔类型        false    其值不为真即为家，不可以用数字代表true或false

byte    字节型            uint8别名

rune    字符类型            专用于存储unicode编码，等价于uint32

int, uint    整型    4或8        32位或64位

int8, uint8    整型            - ~ ,  ~

int16, uint16    整型            - ~ ,  ~

int32, uint32    整型            -21亿 ~  亿,  ~  亿

int64, uint64    整型

float32    浮点型        0.0    小数位精确到7位

float64    浮点型        0.0    小数位精确到15位

complex64    复数类型

complex128    复数类型

uintptr    整型    4或8        ⾜以存储指针的uint32或uint64整数

string    字符串        ""    utf-8字符串

1）布尔类型

var v1 bool

v1 = true

v2 := ( == ) // v2也会被推导为bool类型

//布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换

var b bool

b =  // err, 编译错误

b = bool() // err, 编译错误

2）整型

var v1 int32

v1 =

v2 :=  // v1将会被自动推导为int类型

3）浮点型

    var f1 float32

    f1 =

    f2 := 12.0 // 如果不加小数点， fvalue2会被推导为整型而不是浮点型

4）字符类型

在Go语言中支持两个字符类型，一个是byte（实际上是uint8的别名），代表utf-8字符串的单个字节的值；另一个是rune，代表单个unicode字符。

    var ch1, ch2, ch3 byte

    ch1 = 'a'  //字符赋值

    ch2 =    //字符的ascii码赋值

    ch3 = '\n' //转义字符

    fmt.Printf("ch1 = %c, ch2 = %c, %c", ch1, ch2, ch3)

5）字符串

在Go语言中，字符串也是一种基本类型

package main

import "fmt"

func main()  {

    var str string                                    // 声明一个字符串变量

    str = "abc"                                       // 字符串赋值

    ch := str[]                                      // 取字符串的第一个字符

    fmt.Printf("str = %s, len = %d\n", str, len(str)) //内置的函数len()来取字符串的长度

    fmt.Printf("str[0] = %c, ch = %c\n", str[], ch)

    //`(反引号)括起的字符串为Raw字符串，即字符串在代码中的形式就是打印时的形式，它没有字符转义，换行也将原样输出。

    str2 := `hello

    world \n \r测试

　　`

    fmt.Println("str2 = ", str2)

}

5，fmt包的格式化输出输入

1）格式说明

格式    含义

%%    一个%字面量

%b    一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数

%c    字符型。可以把输入的数字按照ASCII码相应转换为对应的字符

%d    一个十进制数值(基数为10)

%e    以科学记数法e表示的浮点数或者复数值

%E    以科学记数法E表示的浮点数或者复数值

%f    以标准记数法表示的浮点数或者复数值

%g    以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出

%G    以%E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出

%o    一个以八进制表示的数字(基数为8)

%p    以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示

%q    使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字

%s    字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\'即空字符）

%t    以true或者false输出的布尔值

%T    使用Go语法输出的值的类型

%U    一个用Unicode表示法表示的整型码点，默认值为4个数字字符

%v    使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话

%x    以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示

%X    以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示

2）输出

    //整型

    a :=

    fmt.Printf("a = %b\n", a) //a = 1111

    fmt.Printf("%%\n")        //只输出一个%

    //字符

    ch := 'a'

    fmt.Printf("ch = %c, %c\n", ch, ) //a, a

    //浮点型

    f := 3.14

    fmt.Printf("f = %f, %g\n", f, f) //f = 3.140000, 3.14

    fmt.Printf("f type = %T\n", f)   //f type = float64

    //复数类型

    v := complex(3.2, )

    fmt.Printf("v = %f, %g\n", v, v) //v = (3.200000+12.000000i), (3.2+12i)

    fmt.Printf("v type = %T\n", v)   //v type = complex128

    //布尔类型

    fmt.Printf("%t, %t\n", true, false) //true, false

    //字符串

    str := "hello go"

    fmt.Printf("str = %s\n", str) //str = hello go

3）输入

    var v int

    fmt.Println("请输入一个整型：")

    fmt.Scanf("%d", &v)

    //fmt.Scan(&v)

    fmt.Println("v = ", v)

6，类型转换

Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之间。

    var ch byte =

    //var a int = ch //err

    var a int = int(ch)

7，类型别名

    type bigint int64 //int64类型改名为bigint

    var x bigint = 

    type (

        myint int    //int改名为myint

        mystr string //string改名为mystr

    )

黑马程序员

巴特西