GoLang基础—变量、数据类型、常量 | 类型

变量指定了某存储单元的名称，该存储单元会存储特定类型的值。在go中，有多种语法用于声明变量

2.1 声明单个变量

var name type

package main
import "fmt"
func main(){
    var age int // 变量声明
    fmt.Println("my age is",age)
}
// my age is 0

ageint

Goage

变量名 = 值

Go是强类型语言，因此不允许某一类型的变量赋值为其他类型，否则会报错

2.2 声明变量并初始化

声明变量的同时可以给定初始值

var age int = 18

var age int age = 18

2.3 类型推断

如果变量有初始化，那么Go能够自动推断具有初始值的变量的类型。因此初始化时，可以省略语法中的数据类型

var age = 18

2.4 声明多个变量并初始化

1、声明相同类型变量：

通过一条语句声明多个变量

var name1,name2 type = value1,value2

同样可以省略类型

var name1,name2 = value1,value2

同样，不初始化，那么必须声明类型，并且赋值该类型的零值

2、声明不同类型变量

语法：

var {
    name1 = "tank"
    age = 18
    height int
}

2.5 简短声明

:=

name :=value

如：

package main
import "fmt"
func main(){
    name,age := "tank",19
    fmt.Print("my name is ",name," and my age is ",age)
}
// my name is tank and my age is 19

注意：

:=

2、变量也可以是在运行时进行赋值的，即变量的值，可以是一个表达式的执行结果

3.1 bool

truefalse

3.2 数字类型

3.2.1 有符号整形

3.2.2 无符号整形

3.2.3 浮点型

float32：32位浮点数

float64：64位浮点数（默认类型）

3.2.4 复数类型

complex64：实部和虚部都是float32类型的复数

complex128：实部和虚部都是64位的复数类型

内建complex用于创建一个包含实部和虚部的复数

complex的定义：

func complex(r,i)

1、两个参数分别是实部和虚部，返回值是一个复数类型

2、实部和虚部，应该是相同类型

c := 6 + 7i

3.2.5 byte和rune

byte是uint8的别名

rune是int32的别名

3.3 string

字符串类型

在go中，字符串是字节的集合

可以简单理解为：很多字符组成的字符串

""

+

3.4 类型转换

Go中不允许不同类型之间的操作

float64int

type(value)

package main

import "fmt"

func main()  {
    a := 18
    b := 180.5
    c := a + int(b)
    d := float64(a) +b
    fmt.Print("c:",c)
    fmt.Print("  d:",d)
}
//c:198  d:198.5

3.5 格式说明符

%T  // 打印类型
%d  // 打印字节大小  需要导入unsafe包，其中的Sizeof函数接收变量并返回它的字节大小

package main

import (
    "fmt"
    "unsafe"
)

func main()  {
    a := 18
    b := "sb"
    fmt.Println("value of a is ",a," and b is ", b)
    fmt.Printf("type of a is %T,size of a is %d",a,unsafe.Sizeof(a))
    fmt.Printf("\ntype of b is %T,size of b is %d",b,unsafe.Sizeof(b))
}
/*
value of a is  18  and b is  sb
type of a is int,size of a is 8
type of b is string,size of b is 16
*/

4.1 常量的值

5-89I love Go

// 变量被赋值为常量
var a int = 18
var name string = 'tank'

const

package main
func main(){
    const a int = 18
    a = 81  // 此时将会报错，因为a被定义为了常量，值是固定的，不能修改
}

3、Go是编译型语言，常量的值会在编译的时候确定，所以不能将函数的返回值赋值给常量

package main
import (
    "fmt"
    "math"
)
func main(){
    fmt.Println("Hello,boys")
    var a = math.Sqrt(4)
    const b = math.Sqrt(4)  // 将会报错
}

4.2 常量的类型

1、定义常量的两种方式：

const a = 9  //不声明数据类型，那么它可以关联的默认数据类型是所有的数字类型，在赋值时，才会确定
const b float32 = 10  //声明数据类型，那么这个常量就只能是该类型的常量

package main

import (
    "fmt"
)
func main(){
    const a = 9
    const b float32 = 10
    var c complex64 = a
    //var d complex128 = b  //报错，常量b类型是float32,不能赋值给类型为complex128的变量d
    var e complex128 = c  //报错，变量c的类型是complex64,不能赋值给类型为complex128的变量
    fmt.Printf("a 的类型：%T",a)
    fmt.Printf("\nb 的类型：%T",b)
    fmt.Printf("\nc 的类型：%T",c)
    //fmt.Printf("\nd 的类型：%T",d)
    fmt.Printf("\ne 的类型：%T",e)
}

2、按数据类型分析常量

数字常量

1、不声明常量类型时，可以关联到所有的数字数据而类型

2、无类型常量的默认关联类型在语法中才能确定，但是不超过大类型，如数字不能关联到字符串

3、数字常量可以在表达式中进行自由混合和搭配，只有当他们被分配给变量或者需要类型的代码中才会需要类型

package main
import (
    "fmt"
)
func main(){
    const a = 18
    var b int16 = a
    var c float32 = a
    var d complex64 = complex(a,6.5) // 数字常量6.5 在此语法中关联默认类型float32
    var e complex128 = complex(float64(c),6) // 数字常量6 在此语法中关联默认类型float64
    fmt.Println(a,b,c,d,e)
    fmt.Printf("%T,%T,%T,%T,%T,%T",a,b,c,d,e,6.0)  // 浮点数常量默认关联类型float64
}
/*
18 18 18 (18+6.5i) (18+6i)
int,int16,float32,complex64,complex128,float64
*/

字符串常量

1、双引号中的任何值都是Go中的字符串常量

stringMySring

stringMyString

布尔常量

truefalse

2、特点与字符串一样