基础类型

1.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

1.2 变量

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

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

1.2.1 变量声明

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

 var v1 int //变量声明了之后 必须要使用---结尾就算加上“;”,ide也会自动去除
    var v2 int

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

    var (
        v5 int
        v6 int
    )

1.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

1.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    //多重赋值

1.2.4 匿名变量(匿名函数变量配合函数返回值使用才有优势)

_(下划线)是个特殊的变量名,任何赋予它的值都会被丢弃:

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

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

_, str := test()

注意:当某个函数返回值有多个时,而调用者只需要使用某一个返回值时,则配合匿名变量“_”将不需要的变量值丢弃掉!

1.3 常量

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

1.3.1 字面常量(常量值)

所谓字面常量(literal),是指程序中硬编码的常量,如:

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

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

1.3.3多个变量同时声明和赋值 “var( )”和“const()”形式可以同时声明多个变量,且,该声明形式中,无论是普通变量还是常量都可直接赋值(符号是“=”),且能自动识别变量类型------非var()格式时,普通变量必须使用“:=”赋值才能自动识别变量类型,而常量才可以直接使用“=”识别类型。

1.3.4 iota枚举(iota是常量自动生成器,且每隔一行累加1,给常量赋值使用)

常量声明可以使用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
    )

1.4 基础数据类型

1.4.1 分类

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

1.4.2 布尔类型

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

//布尔类型不能接受其他类型的赋值,不支持自动或强制的类型转换,布尔类型不能和int类型互转!
var b bool
b = 1 // err, 编译错误
b = bool(1) // err, 编译错误

1.4.3 整型

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

1.4.4 浮点型

    var f1 float32
    f1 = 12
    f2 := 12.0 // 如果不加小数点, fvalue2会被推导为整型而不是浮点型,float64

1.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码赋值----大小写因为字符ascii码值相差32
    ch3 = '\n' //转义字符
    fmt.Printf("ch1 = %c, ch2 = %c, %c", ch1, ch2, ch3)
}

1.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测试
    */

字符和字符串的区别

1.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))

1.5 fmt包的格式化输出输入

1.5.1 格式说明

## 1.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

1.5.3 输人

    var v int
    fmt.Println("请输入一个整型:")
    fmt.Scanf("%d", &v)//&符号标识取地址---不能忘了带上该符号
    //fmt.Scan(&v)  //形式更简单一些,会自动匹配格式
    fmt.Println("v = ", v)

1.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)

1.7 类型别名(即给一个名字起一个别名)

 type bigint int64 //给int64类型起一个别名为:bigint
    var x bigint = 100 //等价于 var x int64
	//同时定义多个别名
    type (
        myint int    //int改名为myint
        mystr string //string改名为mystr
    )