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)  //Println有自动换行功能

    // 4同时可以声明多个变量

    //var b,c int

    //fmt.Println(b,c)

    a =  //变量的赋值

    fmt.Println(a)

    // 变量的初始化，声明变量时，同时赋值

    var b int =    //初始化， 声明和赋值同时进行

    b =    //赋值  先声明，后赋值

    fmt.Println(b)

    // 自动推导类型，必须初始化，通过初始化的值确定类型

    c :=

    // %T 打印变量所属的类型

    fmt.Printf("c type is %T\n", c)

自动推导类型：

package main

import "fmt"

func main(){

    // 赋值，赋值前，必须先声明变量

    var a int

    a =    // 赋值可以使用n次

    fmt.Println("a = ", a)

    // :=, 自动推导类型，先声明变量b，再给b赋值给20

    // 自动推导，同一个变量名只能使用一次，用于初始化

    b :=

    fmt.Println("b = ",b)

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

}

补充：printf和println的区别

package main

import "fmt"

func main(){

    a :=

    // 一段一段处理，自动加换行

    fmt.Println("a = ", a)

    // 格式化输出，把a的内容放在%d的位置

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

    b, c := ,

    fmt.Println("a = ",a, ", b = ", b, ", c =", c )

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

}

多重赋值以及匿名变量

_（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃（Python中也有此方法）

package main

import "fmt"

//go函数可以返回多个值

func test()(a,b,c int){

    return ,,

}

func main(){

    // a := 10

    // b := 20

    // c := 30

    a, b := , 

    //交换两个变量的值

    var tmp int

    tmp = a

    a = b

    b = tmp

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

    i,j := ,

    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），是指程序中硬编码的常量，如：

3.1415  // 浮点类型的常量

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

true  // 布尔类型的常量

"foo" // 字符串常量

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

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

package main

import "fmt"

func main(){

    // 不同类型变量的声明（定义）

    //var a int

    //var b float64

    var (

        a int

        b float64

    )

    a =

    b = 3.14

    fmt.Println("a=", a)

    fmt.Println("b=", b)

    //const i int = 10

    //const j float64 = 3.14

    const (

        i int =

        j float64 = 3.14

    )

    fmt.Println("i = ", i)

    fmt.Println("j = ", j)

}

3.3 iota枚举

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

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

package main

import "fmt"

func main(){

    // 1.iota常量生成器，每一行自动加 1

    // 2.iota给常量赋值使用

    const(

        a = iota  //

        b = iota  //

        c = iota  //

    )

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

    //3.iota遇到const重置为0

    const d = iota

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

    //4.可以只写一个iota

    const(

        e = iota

        f

        g

    )

    fmt.Printf("e = %d, f = %d, g = %d\n ",e,f,g)

    //5.如果是同一行，值都一样

    const (

        h = iota

        i, j, k = iota,iota,iota

        m = iota

    )

    fmt.Printf("h = %d, i = %d, j = %d, k = %d, m = %d",h,i,j,k,m)

　　

}

a = , b = , c =

d =

e = , f = , g =

h = , i = , j = , k = , m =

Process finished with exit code

几个常见的`iota`示例

使用“_”跳过某些值

const (

    n1 = iota  //

    n2            //

    _

    n4           //

)

iota声明中间插队

const (

    n1 = iota //

    n2 =   //

    n3 = iota //

    n4        //

)
const n5 = iota //

定义数量级

这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。

const (

    _  = iota

    KB =  << ( * iota)

    MB =  << ( * iota)

    GB =  << ( * iota)

    TB =  << ( * iota)

    PB =  << ( * iota)

)

4、基础数据类型

4.1 分类

Go语言内置以下这些基础类型：

类型	名称	长度	零值	说明
bool	布尔类型	1	false	其值不为真即为家，不可以用数字代表true或false
byte	字节型	1	0	uint8别名
rune	字符类型	4	0	专用于存储unicode编码，等价于uint32
int, uint	整型	4或8	0	32位或64位
int8, uint8	整型	1	0	-128 ~ 127, 0 ~ 255
int16, uint16	整型	2	0	-32768 ~ 32767, 0 ~ 65535
int32, uint32	整型	4	0	-21亿 ~ 21 亿, 0 ~ 42 亿
int64, uint64	整型	8	0
float32	浮点型	4	0.0	小数位精确到7位
float64	浮点型	8	0.0	小数位精确到15位
complex64	复数类型	8
complex128	复数类型	16
uintptr	整型指针	4或8		⾜以存储指针的uint32或uint64整数
string	字符串		""	utf-8字符串

4.2 布尔类型

true 对应1

false 对应0

package main

import "fmt"

func main(){

    //1 声明变量，没有初始化，零值（初始化值）为False

    var a bool

    fmt.Println("a = ", a)

    a = true

    fmt.Println("a = ", a )

    // 自动推导类型

    var b = false

    fmt.Println("b = ",b)

    c := false

    fmt.Println("c = ",c)

}

4.3 整型

uint8:无符号8为整型(0—255)

uint16:无符号16位整型(0—65535)

uint32:无符号32位整型(0—4294967295)

uint64:无符号64位整型(0到18446744073709551615)

int8:有符号整型(-128—127)

int16:有符号16位整型(-32768—32767)

int32:有符号32位整型(-2147483648—2147483647)

int64:有符号64位整型

byte:类似uint8,常用于ASCII码字符，美国标准信息交换码，128个最基本的字符，大小写字母，阿拉伯数字，英文标点符号，常用的其他符号。

rune:类似int32

uint:32或64位

int与uint一样大小

uintptr:无符号整型，用于存放一个指针

package main

import "fmt"

func main(){

    var v1  int32

    v1 =

    v2 :=

    fmt.Println("v1 = ", v1, " ,v2 = ", v2)

}

4.4 浮点型

float32

float64

package main

import "fmt"

func main(){

    // 声明变量

    var f1 float32

    f1 = 3.14

    fmt.Println("f1=", f1)

    //自动推导类型

    f2 := 3.14

    fmt.Printf("f2 type is %T\n", f2)

    // float 64比32存储的更准确

}

4.5 字符类型

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

package main

import "fmt"

func main(){

    var ch byte  // 声明字符类型

    ch =

    // fmt.Println("ch = ", ch)

    // 格式化输出，%c以字符方式打印，%d以整型方式打印

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

    ch = 'a' //字符，单引号

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

    //大写转小写，小写转大写  小写比大写大32

    fmt.Printf("大写： %d,  小写： %d\n", 'A', 'a')   // 大写：65, 小写：97

    fmt.Printf("大写转小写 %c\n", 'A'+)    // 大写转小写：a

    fmt.Printf("小写转大写： %c\n", 'a'-)  // 小写转大写：A

}

4.6字符串类型

go语言中要定义一个多行字符串时，就必须使用反引号字符。

s1 := `第一行

    　　第二行

    　　第三行`

fmt.Println(s1)

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

字符串的常用操作

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

package main

import "fmt"

func main(){

    var str1 string //声明变量

    str1 = "abc"

    fmt.Println("str1 = ", str1)  // str1 = abc

    // 自动推导类型

    str2 := "mike"

    fmt.Printf("str2类型是 %T\n", str2)  // str2类型是 string

    // 内建函数，len()可以测试字符串的长度，有多少个字符，这个和python中的len()用法类似

    fmt.Println("len(str2)=", len(str2))  // len(str2)=4

}

4.7字符和字符串的区别

字符一般都用单引号表示，且只有一个字符，转义字符除外（如‘\n’）

字符串一般有用双引号表示，由一个字符或多个字符所组成，字符串都隐藏一个结束符‘\0’

package main

import "fmt"

func main(){

    var ch byte

    var str string

    //字符

    //1单引号

    //2字符往往都只有一个字符，转义字符除外'\n'

    ch = 'a'

    fmt.Println("ch = ", ch)

    //字符串

    //1双引号

    //2字符串由一个或多个字符组成

    //3字符串都是隐藏一个结束符,'\0'

    str = "a" // 由'a'和 '\0'组成一个字符串

    fmt.Println("str=", str)

    str = "hello go"

    //只想操作字符串的某个字符，从0开始操作,和python中的索引类似

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

}

4.8 复数类型

complex64: 32位实数和虚数

complex128:64位实数和虚数

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

package main

import "fmt"

func main(){

    var t complex128  //声明

    t = 2.1 + .14i  // 赋值

    fmt.Println("t = ", t)

    //自动推导类型

    t2 := 3.2 +.2i

    fmt.Printf("t2 type is %T\n", t2)

    //通过内建函数，取实部和虚部

    fmt.Println("real(t2) = ", real(t2), "imag(t2) = ", imag(t2))

}

在python中，用j或者J来表示虚部。

a = 3.13 + 2.23j

a.read    # 获取复数的实部

a.imag  # 获取复数的虚部

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

5.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‘结尾，这个'\0'即空字符）
%t	以true或者false输出的布尔值
%T	使用Go语法输出的值的类型
%U	一个用Unicode表示法表示的整型码点，默认值为4个数字字符
%v	使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话
%x	以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示
%X	以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示

5.2 格式化输出

package main

import "fmt"

func main(){

    a :=

    b := "abc"

    c := 'a'   // 字符类型是int32

    d := 3.14

    // %T操作变量所属类型

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

    // %d整型号格式

    // %s 字符串格式

    // %c 字符格式

    // %f 浮点型格式

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

    //%v自动匹配格式输出

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

}

5.3输出

package main

import "fmt"

func main(){

    var a int

    var b int

    fmt.Print("请输入变量a:")

    fmt.Scanf("%d", &a)  // 别忘了&

    fmt.Print("请输入变量b:")

    fmt.Scan(&b)

    fmt.Println("a = ", a)

    fmt.Println("b = ", b)

}

补充：在python中直接使用input,和python相比，go中的输入就略显的有些麻烦了

a = input("请输入变量a:")

print(a)

5.4 类型转换

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

package main

import "fmt"

func main(){

    // 不能转换类型，叫不兼容类型

    var flag bool

    flag = true

    fmt.Printf("flag = %t\n", flag)

    // bool 类型不能转换为int

    // fmt.Printf("flag = %d \n", int(flag))

    // 0就是假，非0就是真

    // 整型也不能转bool

    // flag = bool(1)

    var ch byte

    ch = 'a'  // 字符类型本质上是整型

    var t int

    t = int(ch) // 类型转换，把ch的值取出来后，转成int 在赋值给t

    fmt.Println("t = ", t)

}

5.5类型别名

package main

import "fmt"

func main(){

    // 给int64 起一个别名叫bigint

    type bigint int64

    var a bigint  // 等价于var a int64

    fmt.Printf("a type is %T\n", a)

    type(

        long int64

        char byte

    )

    var b long =

    var ch char = 'a'

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

}

6、byte和rune类型

组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。字符用单引号（’）包裹起来，如：

var a := '中'

var b := 'x'

Go 语言的字符有以下两种：

uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。

修改字符串

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

func changeString() {

    s1 := "big"

    // 强制类型转换

    byteS1 := []byte(s1)

    byteS1[] = 'p'

    fmt.Println(string(byteS1))

    s2 := "白萝卜"

    runeS2 := []rune(s2)

    runeS2[] = '红'

    fmt.Println(string(runeS2))

}

7、类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

强制类型转换的基本语法如下：

T(表达式)

其中，T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.

比如计算直角三角形的斜边长时使用math包的Sqrt()函数，该函数接收的是float64类型的参数，而变量a和b都是int类型的，这个时候就需要将a和b强制类型转换为float64类型。

func sqrtDemo() {

    var a, b = ,

    var c int

    // math.Sqrt()接收的参数是float64类型，需要强制转换

    c = int(math.Sqrt(float64(a*a + b*b)))

    fmt.Println(c)

}

8、练习

编写代码统计出字符串"hello西安古城"中汉字的数量。

package main

import "fmt"

func main() {

    var str string = "hello西安古城"
　  var d int
　　for _, v := range str{
　　　　if len(v) >= 3{
　　　　　　d += 1
　　}
}

    fmt.Printf("汉字总计数量：%d", d)

}