go的变量、常量、类型别名

go语言的基本类型如下：





类型变量 实例代码：

package main
import "fmt"

/*所有变量都可使用类型推断
  全局变量必须使用var可以var(),可并行，可推断
  局部变量不可使用var(),只可并行,可推断
*/
func main() {
    //bool布尔型--先声明后赋值
    var a bool
    fmt.Println(a)
    a = true
    fmt.Println(a)
    //int8/uint8--声明并赋值
    var b int8 = -128
    var b1 uint8 = 255
    fmt.Println(b)
    fmt.Println(b1)

    //byte(uint8别名)类型--系统推测类型方式
    var c1 = 255
    var c2 byte = 255
    fmt.Println(c1)
    fmt.Println(c2)
    //int16/uint16--最简单赋值声明方式
    d1 := -32768
    d2 := 65535
    fmt.Println(d1)
    fmt.Println(d2)
    //int32(rune)/uint32--var并行
    var e1, e2 int32 = -2147483648, 2147483647
    var e3, e4 uint32 = 0, 4294967295
    fmt.Println(e1, e2, e3, e4)

    //int64/uint64--var()
    var (
        f1     int64  = -46744073709551616
        f2, f3 uint64 = 18446744073709551615, 184467443709551615
    )

    fmt.Println(f1, f2, f3)

    //浮点型float32/float64--同类型显示转换
    var g1 float32 = 1.1
    var g2 = int8(g1)
    var g3 = uint8(g1)
    var g4 int16 = int16(g1)
    g5 := uint16(g1)
    //  var g6 bool = int8(g1)
    fmt.Println(g1, g2, g3, g4, g5)

    //string类型
    var h1 string = "myString"
    fmt.Println(h1)

}

输出如下：

false
true
-128
255
255
255
-32768
65535
-2147483648 2147483647 0 4294967295
-46744073709551616 18446744073709551615 184467443709551615
1.1 1 1 1 1
myString

类型别名：

package main

import "fmt"

/*
类型别名
*/
func main() {
    //bool布尔型--先声明后赋值
    var a []int8
    fmt.Println(a)
    var b [3]int8
    fmt.Println(b)

    var c byte = 127
    fmt.Println(c)

    var d rune = 2147483647
    fmt.Println(d)

    var e 文本 = "myString"
    fmt.Println(e)

}

//byte uint8别名
//rune int32别名
//在本例type中实际做了转换
type (
    byte int8
    rune uint32
    文本   string
)

输出如下：

[]
[0 0 0]
127
2147483647
myString

数字转文本格式、数字转字符串类型的十进制

package main

import "fmt"

import "strconv"

func main() {

    var a int = 65
    //将数据转为文本格式，是用65表示的文本A
    b := string(a)

    fmt.Println(b)

    //数字-->>字符串，返回数字 i 所表示的字符串类型的十进制数。
    c := strconv.Itoa(a)
    fmt.Println(c)
    c = "myString"
    fmt.Println(c)
}

输出如下：

A
65
myString

常量：

package main

import "fmt"

func main() {

    fmt.Println(a, b, c, d, e, f, g, h, i, j, k, m, n)

    fmt.Println(aa, bb, cc, dd, ee, ff, gg, hh)

}

const a int = 1
const b, c, k = 'a', 'A', "hhehe"
const (
    d = 1
    e = d + 1
    f
    g, h = 2, 3
    //l gh是2个是无法输出的
    m, n
    i = "aaa"
    j = len(i)
)

const (
    aa = "ggg"
    bb = iota
    cc
    dd = iota
)

const (
    ee = iota
    ff
    gg = "aaa"
    hh
)

输出如下：

1 97 65 1 2 2 2 3 aaa 3 hhehe 2 3
ggg 1 2 3 0 1 aaa aaa

运算符：

package main

import "fmt"

/*
a-- a++是作为一个运算符，不是一个表达式
而且-- ++只能在后边

*/
func main() {
    a := 3
    a--
    fmt.Println(a)
    //指向a的p指针
    var p *int = &a
    fmt.Println(*p)
}

输出如下：

2
2