Go笔记(1)-变量的详细用法

变量

（1）变量的定义

• Go语言是静态类型的语言，所有类型都需要明确的定义。
• var是声明变量的关键字 使用格式：var 变量名 变量类型
• 变量命名规范：遵循驼峰格式，首个单词小写，每个新单词的首字母大写

var name String = "WY"     //var创建String类型的变量name
name = "JB"               //修改变量值

• 使用var + (),可以将一组变量定义在一起

var(                  //定义一组变量
    age int
    name string
)

• 想要定义多个同类型变量

var a,b,c,int       //定义多个同类型变量

• 变量被声明之后，会赋值默认值

• • 数值类型的变量默认值是0，0.0
  • 字符串变量默认为空
  • 布尔型变量默认为flase
  • 切片，函数，指针变量的默认为nil

（2)变量的初始化

a 初始化标准格式

var 变量名 类型 = 值（表达式）

var name string = "sillyfox"               //变量初始化赋值
var age = 21

fmt.printf("name:%s,age:%d",name,age)       //类似C语言的打印写法

b 简短式初始化

• 这是go语言特有的语法，会根据：= 右边的值自动识别左边变量的类型
• 注意：该使用只能用在函数的内部，不可随处使用

name := "sillyfox"
age := 18
fmt.Println(name,age)      //打印值
fmt.Printf("%T,%T",name,age)            //打印变量类型

（3）内存地址的打印

var num int
num = 1000
fmt.Printf("num的值:%d，内存地址：%p\n",num,&num)

（4）变量交换

在其他语言中，通常交换变量的方式是定义一个中间变量，例如：

int a = 100;
int b = 200;
int c = 0;      //中间变量
c = a;
a = b;
b = a;          //通过中间变量c交换a,b的值

在go语言中，可以直接实现换值而不需要中间变量

var a int = 100
var b int = 200
b,a = a,b          //交换值

（5）匿名变量

在go语言中提供了一种匿名变量，使用下划线_表示。匿名变量可以被赋予任何值，但所赋的值均将被抛弃。 我们可以在需要接收值，但认为某些值没有作用的时候使用匿名变量。在go语言中，如果定义了变量而不使用，则编译器会报错，但如果使用匿名变量则可以解决这个问题。

匿名变量不占用空间，不会分配内存，匿名变量与匿名变量之间也不会因为多次声明而无法使用。

（6）变量的作用域

• go语言中也有全局变量和局部变量之分，并且全局变量与局部变量的名称相同。
• 如果同时使用局部变量和全局变量，则根据就近原则go语言会优先使用局部变量

如以下代码，打印出来的结果是局部变量age，显示结果为18

var age int = 21   //定义了一个全局变量

func main(){
    var age int = 18  //在main函数中的局部变量

    fmt.Println(age)   //打印age变量，这里的结果是18
}

• 局部变量在函数体内定义，作用域为当前所在的函数体内
• 全局变量在函数体外定义，只需要在一个源文件中定义，就可以在所有源文件中使用，不包含这个全局变量的源文件要使用时需要import该全局变量所在源文件。

（7）常量

• 常量是不会被修改的量
• 常量的定义使用const关键字

常量的定义

• 在go语言中，常量的定义分位显示定义和隐式定义
• 可以同时定义多个常量
• 在隐式定义方式中可以同时定义多个不同类型的常量
• const可以定义一个组，在组中若有一个常量未赋值，则该常量默认为上一个常量的值

const name1 string = "WY"       //显示定义
const name2  = "CH"      //隐式定义

const age1,age2,age3 int = 17,18,19    //同时显示定义多个常量
const name3,age4,result = "yue",21,true  //隐式定义同时定义多个不同类型的常量

const(
	a = 100
    b = 101
    c                //默认为101
    d                //默认为101
)

特殊常量iota

• iota是特殊的常量，是go语言的常量计数器
• iota在const关键字出现时将被重置为0，const中每新增一行常量声明将使iota计数一次

const(
	a = iota
    b = iota
    c = iota

    fmt.Println(a,b,c)  //输出结果为0，1，2
)

//新建一个const
const(
	d = iota      //iota重置为0，d = 0
    e              //e = d = 0,iota = 1
    f = "wy"       //f = "wy",iota = 2
    g              //g = f = "wy",iota = 3
    h = 100        //h = 100,iota = 4
    I              //I = h = 100,iota = 5
    J              //J = I = 100,iota = 6

    //共定义了7个变量，最后iota = 6
)

（8）布尔值

• 布尔值bool的值只有两种：true和flase
• 布尔值不赋值时默认值为flase
• 格式打印符号为%t

var Flag bool
fmt.Printf("%T,%t\n",Flag,Flag)      //打印结果为bool,flase; %T表示打印类型

（9）数字类型

整型

浮点型

其他数字类型

(9)字符型

• 字符型string, 其值用双引号包起来
• 若将string的值用单引号包括，则打印出来的类型为整形且值打印出来为Unicode编码
• format打印格式：%s

var string name = "WY"
var string new = 'A'       //该值打印输出为65，对应Unicode编码表

字符串连接

• go语言的字符串拼接使用方式与java类似，使用”+“拼接

fmt.Println("hello" + "WY")

转义字符

• 双引号： \ "
• 退格： \b
• tab: \t
• 换行： \n

(10)数据类型转换

• go语言中不存在隐式转换，必须显示转换，转换使用（）进行强制转换
• 注意:一般是将更小范围的数据类型转换为取值范围更大的数据类型。如果从大类型转换为小类型，则会发生精度丢失
• 某些数据类型无法转换，编译会报错。例如，数值类型转换为布尔类型。

a := 5.0
b := (int)a        //强制转换