go语言20小时从入门到精通（2、 基础类型）

##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.2 变量 变量是几乎全部编程语言中最基本的组成元素，变量是程序运行期间能够改变的量。

从根本上说，变量至关因而对一块数据存储空间的命名，程序能够经过定义一个变量来申请一块数据存储空间，以后能够经过引用变量名来使用这块存储空间。

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

var v1 int     var v2 int

//一次定义多个变量     var v3, v4 int

var (         v5 int         v6 int     )

###2.2.2 变量初始化 对于声明变量时须要进行初始化的场景， var关键字能够保留，但再也不是必要的元素，以下所示：

var v1 int = 10 // 方式1     var v2 = 10 // 方式2，编译器自动推导出v2的类型     v3 := 10 // 方式3，编译器自动推导出v3的类型     fmt.Println("v3 type is ", reflect.TypeOf(v3)) //v3 type is int

//出如今 := 左侧的变量不该该是已经被声明过，:=定义时必须初始化     var v4 int     v4 := 2 //err

###2.2.3 变量赋值

var v1 int     v1 = 123

var v2, v3, v4 int     v2, v3, v4 = 1, 2, 3    //多重赋值

i := 10     j := 20     i, j = j, i    //多重赋值

###2.2.4 匿名变量 _（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃：

_, i, _, j := 1, 2, 3, 4

func test() (int, string) {
    return 250, "sa"
}

_, str := test()
复制代码

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

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

123
3.1415  // 浮点类型的常量
3.2+12i // 复数类型的常量
true  // 布尔类型的常量
"foo" // 字符串常量
复制代码

###2.3.2 常量定义     const Pi float64 = 3.14     const zero = 0.0 // 浮点常量, 自动推导类型

const ( // 常量组         size int64 = 1024         eof = -1 // 整型常量, 自动推导类型     )     const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值     const a, b, c = 3, 4, "foo"     // a = 3, b = 4, c = "foo"    //err, 常量不能修改

###2.3.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 * 10 // x1 == 0         y1 = iota * 10 // y1 == 10         z1 = iota * 10 // z1 == 20     )

##2.4 基础数据类型 ###2.4.1 分类 Go语言内置如下这些基础类型：

###2.4.2 布尔类型

var v1 bool
v1 = true
v2 := (1 == 2) // v2也会被推导为bool类型

//布尔类型不能接受其余类型的赋值，不支持自动或强制的类型转换
var b bool
b = 1 // err, 编译错误
b = bool(1) // err, 编译错误
复制代码

###2.4.3 整型     var v1 int32     v1 = 123     v2 := 64 // v1将会被自动推导为int类型

###2.4.4 浮点型     var f1 float32     f1 = 12     f2 := 12.0 // 若是不加小数点， fvalue2会被推导为整型而不是浮点型，float64

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

package main

import (
    "fmt"
)

func main() {
    var ch1, ch2, ch3 byte
    ch1 = 'a'  //字符赋值
    ch2 = 97   //字符的ascii码赋值
    ch3 = '\n' //转义字符
    fmt.Printf("ch1 = %c, ch2 = %c, %c", ch1, ch2, ch3)
}
复制代码

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

    var str string                                    // 声明一个字符串变量
    str = "abc"                                       // 字符串赋值
    ch := str[0]                                      // 取字符串的第一个字符
    fmt.Printf("str = %s, len = %d\n", str, len(str)) //内置的函数len()来取字符串的长度
    fmt.Printf("str[0] = %c, ch = %c\n", str[0], ch)

    //`(反引号)括起的字符串为Raw字符串，即字符串在代码中的形式就是打印时的形式，它没有字符转义，换行也将原样输出。
    str2 := `hello
    mike \n \r测试
    `
    fmt.Println("str2 = ", str2)
    /*
        str2 =  hello
              mike \n \r测试
    */
复制代码

###2.4.7 复数类型 复数实际上由两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）。

var v1 complex64 // 由2个float32构成的复数类型     v1 = 3.2 + 12i     v2 := 3.2 + 12i // v2是complex128类型     v3 := complex(3.2, 12) // v3结果同v2

fmt.Println(v1, v2, v3)     //内置函数real(v1)得到该复数的实部     //经过imag(v1)得到该复数的虚部     fmt.Println(real(v1), imag(v1))

##2.5 fmt包的格式化输出输入 ###2.5.1 格式说明

###2.5.2 输出     //整型     a := 15     fmt.Printf("a = %b\n", a) //a = 1111     fmt.Printf("%%\n") //只输出一个%

//字符     ch := 'a'     fmt.Printf("ch = %c, %c\n", ch, 97) //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, 12)     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

###2.5.3 输人     var v int     fmt.Println("请输入一个整型：")     fmt.Scanf("%d", &v)     //fmt.Scan(&v)     fmt.Println("v = ", v)

##2.6 类型转换 Go语言中不容许隐式转换，全部类型转换必须显式声明，并且转换只能发生在两种相互兼容的类型之间。

var ch byte = 97     //var a int = ch //err, cannot use ch (type byte) as type int in assignment     var a int = int(ch)

##2.7 类型别名

type bigint int64 //int64类型更名为bigint     var x bigint = 100

type (         myint int //int更名为myint         mystr string //string更名为mystr     )