Go的基础类型

1. 命名

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

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

扩展（补充）：

　　Python中的关键字

　　在python中若想查询python中有哪些关键字可以先导入keyword模块

import keyword
print(keyword.kwlist)

>>>>
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 
'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass',
'raise', 'return', 'try', 'while', 'with', 'yield']

2.变量

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

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

2.1 变量声明

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

 var v1 int
    var v2 int

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

    var (
        v5 int
        v6 int
    )

Python中不需要提前声明变量，用的时候直接可以拿过去用。

2.2 变量初始化

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

package main

import "fmt"   //导入包含，必须要使用

func main(){
    // 变量，程序运行期间可以改变的两

    // 1声明变量  var 变量名  类型
    // 2只是声明没有初始化的变量，默认值为0
    // 3同一个{}里，声明的变量名是唯一的
    var a int
    fmt.Println(a)

    // 4同时可以声明多个变量
    //var b,c int
    //fmt.Println(b,c)

    a = 10 //变量的赋值
    fmt.Println(a)

    // 变量的初始化，声明变量时，同时赋值
    var b int = 10   //初始化， 声明和赋值同时进行
    b = 20   //赋值  先声明，后赋值
    fmt.Println(b)

    // 自动推导类型，必须初始化，通过初始化的值确定类型
    c := 30
    // %T 打印变量所属的类型
    fmt.Printf("c type is %T\n", c)

自动推导类型：

package main

import "fmt"

func main(){
    // 赋值，赋值前，必须先声明变量
    var a int
    a = 10   // 赋值可以使用n次
    fmt.Println("a = ", a)

    // :=, 自动推导类型，先声明变量b，再给b赋值给20
    // 自动推导，同一个变量名只能使用一次，用于初始化
    b := 20
    fmt.Println("b = ",b)

    // b := 30 //前面已经有变量b,不能再建一个变量b
}

补充：printf和println的区别

package main

import "fmt"

func main(){
    a := 10
    // 一段一段处理，自动加换行
    fmt.Println("a = ", a)

    // 格式化输出，把a的内容放在%d的位置
    fmt.Printf("a = %d\n", a)

    b, c := 20, 30
    fmt.Println("a = ",a, ", b = ", b, ", c =", c )
    fmt.Printf("a = %d, b = %d, c = %d\n", a,b,c)
}

多重赋值以及匿名变量

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

package main

import "fmt"


//go函数可以返回多个值
func test()(a,b,c int){
    return 1,2,3
}


func main(){
    // a := 10
    // b := 20
    // c := 30
    a, b := 10, 20

    //交换两个变量的值
    var tmp int
    tmp = a
    a = b
    b = tmp

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

    i,j := 30,40
    i,j = j,i
    fmt.Printf("i = %d,j = %d\n", i,j)

    // _匿名变量，丢弃数据不处理,匿名变量配合返回值使用，才有优势
    tmp,_ = i,j
    fmt.Println("tmp = ",tmp)


    var c,d,e int
    c,d,e = test()
    fmt.Printf("c = %d, d = %d, e = %d\n",c,d,e)

    _,d,_ = test()
    fmt.Println("d = ", d)
    }

3.常量

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

3.1 字面常量(常量值)

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

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

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, 常量不能修改

多个变量或常量定义实例：

package main

import "fmt"

func main(){
    // 不同类型变量的声明（定义）
    //var a int
    //var b float64

    var (
        a int
        b float64
    )

    a = 10
    b = 3.14
    fmt.Println("a=", a)
    fmt.Println("b=", b)

    //const i int = 10
    //const j float64 = 3.14

    const (
        i int = 10
        j float64 = 3.14
    )

    fmt.Println("i = ", i)
    fmt.Println("j = ", j)
}

3.3 iota枚举

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

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