go语言自动化运维【03】

go的类型和变量

1. go语言类型

布尔值 bool: 取值 true,false
  注意：不可以用0/1来代表true 或者 false

整型 int/uint 
  根据平台可能为32/64位

8位整型 in8/uint8 有符号整型/无符号整型
  长度：1字节
  取值范围：-128~127/0-255

字节型：byte(unit别名)

浮点型：float32/float64

其他值类型：
  array,struct,string

引用类型:
   slice,map,chan

接口类型: inteface

函数类型: func
类型零值
  声明为某种类型的默认值。
var a int  此时a是0

func main() {
  var a int
  fmt.Println(a)
}

2. 单个变量的声明和赋值

go语言是类型安全，不能隐式转换，强制类型转换

var <变量名称> <变量类型> #声明格式
<变量名称> = <表达式> #赋值格式
var <变量名称> [变量类型] = <表达式> #声明时同时赋值
变量声明的三种方式：
（1）传统定义
var a int  //先定义变量
a = 1 //再赋值
上面两步可以写成一步
var a int = 1
（2）类型推断式定义，由系统自动判断类型
var a = 1 
（3）简写定义

a := 1 // 简写

func main() {

    // bool
    // int
    // uint
    // byte
    // float32
    // float64
    var a int
    fmt.Println(a)
    var a int = 1
    fmt.Println(a)
    var b int
    b = 1
    fmt.Println(b)

    var c = "123"
    fmt.Println(c)

}

3. 多个变量的声明与赋值

全局变量的声明可以使用var()的方式进行简写
全局变量的声明不可以省略var，但可以使用并行方式
局部变量不可以使用var()的方式简写，只能使用并行方式
所有变量都可以使用类型推断

 var (
   aaa = 'hello'
   sss,bbb = 1,2
 )

并行方式
 var a,b,c,d int
 a,b,c,d = 1,2,3,4

 var e,f,g,h int = 1,2,3,4 
 var e,f,g,h  = 1,2,3,4 #省略变量类型，由系统推断
 i,m,n,o := 1,2,3,4 


 _ 空白符号，表示对赋值的忽略
 比如： a,_,c,d := 1,2,3,4   #表示忽略2的赋值
 常应用在函数的返回值上面。

例子：

package main

import "fmt"

func main() {
    // float32
    // float64
    var (
        aaa      = "hello"
        sss, bbb = 1, 2
    )
    var a, b, c, d int
    a, b, c, d = 1, 2, 3, 4

    var e, f, g, h int = 1, 2, 3, 4

    i, m, n, o := 1, 2, 3, 4

    aa, _, cc, dd := 1, 2, 3, 4
    fmt.Println(aaa, bbb, sss, a, b, c, d, e, f, g, h, i, m, n, o)
    fmt.Println(aa, cc, dd)
}

4. 变量的类型转换

go 中不存在隐式转换，所有类型转换必须显式声明

转换只能发生在两种互相兼容的类型之间。

  类型转换的格式：
    <ValueA> [:]= <TypeOfValueA>(ValueB)

    <ValueA> := int(ValueB)

比如：

var a float32 = 100.1
b := int(a)

补充说明： type newint int ,这里newint并不能说是int的别名，而只是底层数据结构相同，

在这里称为自定义类型，在进行类型转换时仍旧需要进行显示转换。

但byte和runne确确实实为uint8和int32的别名，可以互相进行转换。

课堂作业： 运行下面代码，看看会发生什么，并思考为什么？

func main() {
var a int = 65
b := string(a)
fmt.Println(b)
}