1、变量声明、输出

1、Go语言定义变量

var 定义变量

// var 变量名 类型 = 表达式
var name string = "HuoYuHao"

一次定义多个变量

var identifier1, identifier2 type

package main 
import "fmt" 
func main() { 
    var username, sex stringusername = "霍雨浩" sex = "男" 
    fmt.Println(username, sex) 
}

申明变量的时候赋值

var a, b, c, d = 1, 2, 3, false

批量声明变量的时候指定类型

var ( 
    a string 
    b int 
    c bool 
)
a = "霍雨浩" 
b = 10 
c = true 
fmt.Println(a,b,c)

批量声明变量并赋值

var ( 
    a string = "霍雨浩" 
    b int = 20 
    c bool = true 
)
fmt.Println(a, b, c) 
fmt.Println(a,b,c)

变量的初始化

Go 语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被 初始化成其类型的默认值，例如： 整型和浮点型变量的默认值为 0。 字符串变量的默认值 为空字符串。 布尔型变量默认为 false。 切片、函数、指针变量的默认为 nil。

当然我们也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下：

var 变量名 类型 = 表达式

例

var name string = "HuoYuHao" 
var age int = 18
// 一次性初始化多个变量并赋值
var name, age = "HuoYuHao", 20 

类型推导方式定义变量

// 变量名 := 表达式
n := 10

**注意：**短变量只能用于声明局部变量，不能用于全局变量的声明

package main 
import ( "fmt" )
// 全局变量 m 
var m = 100 
func main() { 
    n := 10 
    m := 200 // 此处声明局部变量 m 
    fmt.Println(m, n) 
}

使用变量一次声明多个变量，并初始化变量

m1, m2, m3 := 10, 20, 30 
fmt.Println(m1, m2, m3)

匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示，例如：

func getInfo() (int, string) { 
    return 10, "霍雨浩" 
}
func main() { 
    _, name := getInfo() 
    fmt.Println(name) 
}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

注意事项：

1、函数外的每个语句都必须以关键字开始（var、const、func 等）

2、:=不能使用在函数外。

3、_多用于占位，表示忽略值。

Go 语言中的常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的

声明和变量声明非常类似，只是把 var 换成了 const，常量在定义的时候必须赋值。

1. 使用 const 定义常量

   const pi = 3.1415 
   const e = 2.7182
   

   声明了 pi 和 e 这两个常量之后，在整个程序运行期间它们的值都不能再发生变化了。

   多个常量也可以一起声明：

   const (
       pi = 3.1415 
       e = 2.7182 
   )
   

   const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如：

   const (
       n1 = 100 
       n2
       n3 
   )
   

   上面示例中，常量 n1、n2、n3 的值都是 100。

   打印 Pi 的值

   package main 
   import ( 
       "fmt" 
       "math" 
   )
   func main() { 
       const pi=math.Pi 
       fmt.Println(pi)
   }
   

2. const 常量结合 iota 的使用（了解）

   iota 是 golang 语言的常量计数器,只能在常量的表达式中使用。

   iota 在 const 关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量

   声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

   1、iota只能在常量的表达式中使用。

   fmt.Println(iota) 
   
   编译错误： undefined: iota 
   

   2、每次const出现时，都会让iota初始化为0.【自增长】

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

   3、const iota 使用_跳过某些值

   const ( 
       n1 = iota //0 
       n2 //1 
       _
       n4 //3 
   )
   

   4、iota 声明中间插队

   const ( 
       n1 = iota //0 
       n2 = 100 //100 
       n3 = iota //2 
       n4 //3 
   ) 
   const n5 = iota //0
   

   5、多个 iota 定义在一行

   const ( 
       a, b = iota + 1, iota + 2 //1,2 
       c, d //2,3 
       e, f //3,4 
   )
   

   6、Go 语言变量、常量命名规则

   1、变量名称必须由数字、字母、下划线组成。

   2、标识符开头不能是数字

   3、标识符不能是保留字和关键字。

   4、变量的名字是区分大小写的如: age 和 Age 是不同的变量。在实际的运用中,也建议,不要

   用一个单词大小写区分两个变量。

   5、标识符(变量名称)一定要见名思意 ：变量名称建议用名词，方法名称建议用动词

   6、变量命名一般采用驼峰式，当遇到特有名词（缩写或简称，如 DNS）的时候，特有名词

   根据是否私有全部大写或小写。

   7、Go 语言代码风格

   1、代码每一行结束后不用写分号（ ;）

   2、运算符左右建议各加一个空格

   var username string = "itying"
   

   3、Go 语言程序员推荐使用驼峰式命名

   当名字有几个单词组成的时优先使用大小写分隔

   4、强制的代码风格

   左括号必须紧接着语句不换行，这个特性刚开始会使开发者不习惯，但随着对 Go 语言的

   不断熟悉，就会发现风格统一让大家在阅读代码时把注意力集中到了解决问题上，而不是代

   码风格上

   5、go fmt 主要用于格式化文档，让所有人的代码风格保持一致

   PS E:\go_study\demo2> go fmt main.go
   main.go
   PS E:\go_study\demo2> 
   

2、fmt包、Print、Println、Printf

// Go 中要打印一个值需要引入 fmt 包
import "fmt"

fmt 包里面给我们提供了一些常见的打印数据的方法，比如：Print 、Println、Printf，在我 们实际开发中 Println、Printf 用的非常多。

Print 和 Println 区别：

package main

import (
	"fmt"
)
func main() {
	fmt.Print("a")
	fmt.Print("b")
	fmt.Println("a")
	fmt.Println("b")
    fmt.Print("a", "b", "c")
	fmt.Println("a", "b", "c")
}

输出：

PS E:\go_study\demo2> go run .\main.go
ababa
b
abca b c
PS E:\go_study\demo2>

• Println 会自动换行，Print 不会
• 一次输入多个值的时候 Println 中间有空格 Print 没有

Println 和 Printf 区别

package main

import (
	"fmt"
)
func main(){
    a := 10 b := 20 c := 30 
    fmt.Println("a=", a, ",b=", b, ",c=", c) //a= 10 ,b= 20 ,c= 30 
    fmt.Printf("a=%d,b=%d,c=%d", a, b, c) //a=10,b=20,c=30
}

• Printf 是格式化输出，在很多场景下比 Println 更方便
• %d 是占位符，表示数字的十进制表示。Printf 中的占位符与后面的数字变量一一对应

占位符

一般的：

%v 默认格式的值
	打印结构时，加号 (%+v) 添加字段名称
%#v 值的 Go 语法表示
%T 值类型的 Go 语法表示
%% 字面百分号；不消耗任何价值

布尔值：

%t 真或假这个词

整数：

%b 基数 2
%c 对应的Unicode码位所代表的字符
%d 基数 10
%o 基数 8
%O 以 8 为基数，带 0o 前缀
%q 使用 Go 语法安全转义的单引号字符文字。
%x 以 16 为基数，af 小写
%X 以 16 为基数，AF 使用大写字母
%U Unicode 格式：U+1234；与“U+%04X”相同

浮点和复数成分：

%b 指数为 2 的幂的无十进制科学记数法，
	以 strconv.FormatFloat 与 'b' 格式的方式，
	例如-123456p-78
%e 科学记数法，例如 -1.234456e+78
%E 科学记数法，例如 -1.234456E+78
%f 小数点但没有指数，例如 123.456
%f 的同义词
%g %e 用于大指数，否则为 %f。下面讨论精度。
%G %E 大指数，%F 否则
%x 十六进制表示法（具有两个指数的十进制幂），例如 -0x1.23abcp+20
%X 大写十六进制表示法，例如 -0X1.23ABCP+20

字符串和字节片（与这些动词同等对待）：

%s 字符串或切片的未解释字节
%q 使用 Go 语法安全转义的双引号字符串
%x base 16，小写，每字节两个字符
%X base 16，大写，每字节两个字符

更多的占位符参考：http://docscn.studygolang.com/pkg/fmt/

3、Go 语言中的注释

多行注释

/* 
这是一个注释 
*/

单行注释

//这是一个注释

f 小数点但没有指数，例如 123.456
%f 的同义词
%g %e 用于大指数，否则为 %f。下面讨论精度。
%G %E 大指数，%F 否则
%x 十六进制表示法（具有两个指数的十进制幂），例如 -0x1.23abcp+20
%X 大写十六进制表示法，例如 -0X1.23ABCP+20

字符串和字节片（与这些动词同等对待）：

%s 字符串或切片的未解释字节
%q 使用 Go 语法安全转义的双引号字符串
%x base 16，小写，每字节两个字符
%X base 16，大写，每字节两个字符

更多的占位符参考：http://docscn.studygolang.com/pkg/fmt/

## 3、Go 语言中的注释

多行注释

```go
/* 
这是一个注释 
*/

单行注释

//这是一个注释