Go注释和变量

注释

1.单行注释

package main

import "fmt"
//单行注释
/*
 多行注释
*/
func main(){
    fmt.Println("hello world")
}

变量

1.变量的定义

go语言是静态类型语言，就是所有的类型我们需要明确的去定义。

在GO语言中，声明一个变量是使用var关键字：

var [变量名] [类型]
var name string = "字符串"

• 第一个var是声明变量的关键字，是固定写法。
• 第二个name，就是变量的名字。
• 第三个type，就是用来代表变量的类型

我们有时候会批量定义变量，如果每次都单独定义比较麻烦，go语言支持批量定义变量

var(
    name string
    age int
)

var形式的声明语句往往是用于需要显示指定变量类型地方，或者因为变量稍后被重新赋值而初始值无关紧要的地方。

当一个变量被声明之后，如果没有显示的赋值，编译器自动赋予该类型的默认值。

• 整形和浮点型的默认值为0和0.0
• 字符串的默认值为空字符串
• 布尔类型默认值为false
• 切片 、函数、指针变量的默认值为nil

2.变量的初始话

变量初始化的标准格式

var 变量名 类型 = 值(表达式)

例子：

var name string = "字符串"
var age int = 18
fmt.Printfln("name:%s,age:%d",name,age);

这里的name和age就是变量名，name的类型为string，age的类型为int，他们的值分别为 字符串 和18

短便量声明并初始化

name := "字符串"
age := 19
fmt.Printfln("name:%s,age:%d",name,age);

fmt.Printf("%T,%T",name,age); //%T 代表答应变量的类型

这是GO语言的推导声明式写法，编译器会自动根据右值类型推断出左值的对应类型。

它可以自动的推导出一些类型，但是使用也是有限的：

• 定义变量，同时显式初始化
• 不能提供数据类型
• 只能在函数内部使用，不能随便到处定义

因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化。

打印内存地址

name := "字符串"

fmt.Printf("%p",&name) //取内存地址 &变量名 
ftm.Println(&name)

3.变量的交换

var a int = 100
var b int = 200
a,b = b,a  //变量交换 b赋值给a  a赋值给b
fmt.Println(a,b);

4.匿名变量

匿名变量的特点就是一个**“”**,””本身就是一个特殊的标识符，被称为空白标识符，它可以像其他标识符那样用于变量的声明或赋值(任何类型都可以赋值给它)，但任何赋值给这个标识符的值都将被抛弃。因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算，使用匿名变量时，只需要在这个变量声明的地方使用 _ 替代即可。例如：

package main

import(
    "fmt"
)

func test()(int,int){
    return 100,200
}

func main(){
    a,_ = test()
    _,b = test()
    fmt.Println(a,b)
}

在编码的过程中，可能会遇到没有名称的变量、类型或犯法，虽然这不是必须的 ，到那时有时候这样可以极大的增强代码的灵活性，这些变量被称为匿名变量。

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

5.变量的作用域

一个变量(常量、类型或函数)在程序中都有一定的作用范围，称之为作用域。

了解变量的作用域对与我们学习go语言时比较重要的，因为go语言在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误，如果不能理解变量的作用域，就有可能带来一些不明所以的编译错误。

局部变量

在函数体内声明的变量称之为局部变量，他们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。

package main

import (
	"fmt"
)
func main(){
    //声明局部变量 a和b 并赋值
    var a int = 3
    var b int = 5
    
    c := a+b
    fmt.Println("a:%d,b:%d,c:%d",a,b,c)
}

全局变量

在函数体外声明的变量称之为全局变量，全局变量只需要在源文件中定义，就可以在源文件中使用，当然，不包含这个全局变量的源文件需要使用import关键字引入全局变量所在的源文件才能使用这个全局变量。

全局变量的声明必须以var关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。

package main

import (
	"fmt"
)

//声明全局变量
var v int

func main(){
    //声明局部变量 a和b 并赋值
    var a int = 3
    var b int = 5
    
    c := a+b
    fmt.Println("a:%d,b:%d,c:%d",a,b,c)
}

Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。

package main

import (
	"fmt"
)

//声明全局变量
var v int = 4

func main(){
    //声明局部变量 v 并赋值
    var v int = 3
    
    fmt.Println(v)  //打印的是 3
}

常量

常量是一个简单值的标识符，在程序运行时，不会被修改的值。

常量中的数据类型只可以是布尔型、数字型(整型、浮点型和复数)和字符串型。

const identifier [type] = value

type在go中可以省略，因为编译器可以根据变量的值来推断其类型

• 显示类型定义：const b string = "str"
• 隐式类型定义：const b = "str"

const age = 18 //默认的类型为 int

常量默认使用上一个常量的值

const(
    d = 100   //d 100
    e         //e 100 
)

常量iota

iota,特殊常量，可认为是一个可以被编辑器修改的常量，iota是go语言的常量计数器。

iota在const关键字出现时将被重置为0(const内部的第一行之前)，const中没新增一行常量声明将iota计数一次(iota可以理解为const语句块中的行索引)。

iota可以i被用作枚举值：

const(
    a = iota  //a 0
    b = iota  //b 1
    c = iota  //c 2
)

const(
    a = iota  //a 0
    b         //b 1
    c         //c 2
)
//由于d 被赋值了 所以iota 从d不生效
const(
    a = iota  //a 0
    b         //b 1
    c         //c 2
    d = 100   //d 100
    e         //e 100 
)

//由于f又被重新赋值为iota 重新累加
const(
    a = iota  //a 0
    b         //b 1
    c         //c 2
    d = 100   //d 100
    e         //e 100 
    f = iota  //f 5 
    g         //g 6
)