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
    )

黑马程序员