go语言基础-Print打印、变量常量定义规范

package main

import "fmt"

/*
都可以用于输出内容：
Print：输出内容不换行，如果同一行输出多个值则直接输出，中间没有空格隔开
Println：输出内容并换行（内容输出后换行），如果同一行输出多个值则多个值中间以空格隔开
Printf：和Print类似，不换行不可以同一行输出多个值但可以格式化输出，使用的较多(比如使用不同的占位符做对应变量的不同内容输出，
如：以二进制、十进制等格式输出变量的值或直接输出变量的值或输出变量值的数据类型等)

go语言中定义了变量以及import了包必须要使用，否则运行会报错，如果vscode安装了go语言的插件，那么在保存时会自动将没使用的import包删除，变量不会自动删除
如果缺失包，保存时vscode会将对应的包import
go语言中每行代码写完可以不写 ; 也不建议写 ;

go fmt main.go  格式化go代码  main.go 是代码文件，采用vscode开发且安装go语言插件后，在保存代码时就会自动格式化，因此不需要执行命令格式化
go run main.go  运行go代码  main.go 是代码文件
*/
func main() {
	//输出值末尾换行
	fmt.Println("abc")
	fmt.Println("def")

	//输出值不换行
	fmt.Print("abc")
	fmt.Print("def")

	fmt.Println("111")
	//同一行输出多个值，以空格隔开，末尾换行
	fmt.Println("abc", "def")
	//同一行输出多个值直接拼接，没有空格隔开，使用\n换行
	fmt.Print("abc", "def\n")

	fmt.Println("222")
	//输出值不换行，且不能输出多个值，使用\n换行
	fmt.Printf("abc")
	fmt.Printf("def\n")

	fmt.Println("333")
	var a = "A"
	var b = "B"
	var c = "C"
	//同一行输出变量的值，没有空格隔开，\n表示换行
	fmt.Print("a =", a, "b =", b, "c =", c, "\n")
	fmt.Println("444")
	//同一行输出变量的值，以空格隔开
	fmt.Println("a =", a, "b =", b, "c =", c)
	//同一行输出变量对应的信息，以 %v 占位符表示替换为变量的值，\n表示换行
	fmt.Printf("a=%v,b=%v,c=%v\n", a, b, c)
	//同一行输出变量对应的信息，以 %T 占位符表示替换为变量的类型
	fmt.Printf("a=%T,b=%T,c=%T", a, b, c)

	/****************变量定义******************/

	//变量名：只能是字母、数字、下划线且不能以数字开头不能以关键字、保留字作为变量名
	//变量初始化，不初始化值则变量值为空
	//同一作用域内不能定义同名称的变量
	//变量名称区分大小写(o1和O1是不同的变量)
	//变量名称按照驼峰命名，一般私有变量小驼峰、全局变量大驼峰、特有名词可以直接用这个名称作为变量名称，比如DNS可以不用驼峰命名直接使用 DNS 作为变量名不论是否私有变量都可以

	o1, O1 := 100000, "11111111"
	fmt.Println(o1, O1)

	var _1 = 1
	fmt.Println(_1)

	/*
		//数字开头的变量名会报错
		var 1_ = 2;
		fmt.Println(1_);
	*/
	//var 变量名 变量类型
	var username1 string
	//赋值，赋值时需要值和变量类型对应
	username1 = "张某"

	//var 变量名 变量类型 = "变量值"
	var username2 string = "李某"

	//var 变量名 = "变量值"；没有定义变量类型会根据变量值的类型推导变量类型
	var username3 = "王某"

	var userName4 = "赵某"

	fmt.Println(username1, username2, username3, userName4)

	//一次定义多个变量，var 变量名1,变量名2... 变量类型   这样定义的多个变量的变量类型是一样的
	var user1, user2, user3 string
	user1 = "xx"
	user2 = "yy"
	user3 = "zz"

	fmt.Println(user1, user2, user3)

	//一次定义多个变量设置为string类型并赋值
	var rr, vv, bb string = "aa", "bb", "cc"

	fmt.Println(rr, vv, bb)
	/*一次定义多个变量，括号中每行定义一个变量及变量的类型，这样定义的多个变量的变量类型可以不一样
	var(
	    变量名1 变量类型
		变量名2 变量类型
		....
	)*/
	var (
		user4 int
		user5 string
		user6 string
	)
	user4 = 3
	user5 = "aa"
	user6 = "bb"
	fmt.Println(user4, user5, user6)

	/*一次定义多个变量，括号中每行定义一个变量及变量的类型和变量值，这样定义的多个变量的变量类型可以不一样
	var(
	    变量名1 变量类型 = 变量值
		变量名2 变量类型 = 变量值
		....
	)*/
	var (
		age1 string = "www"
		age2 int    = 111
		age3 string = "xxx"
	)

	fmt.Println(age1, age2, age3)

	//一次性定义多个变量并赋值，没有定义数据类型根据对应值推导变量数据类型
	var xx, yy, zz = "aa", 2, "cc"

	fmt.Println(xx, yy, zz)

	/*一次定义多个变量，括号中每行定义一个变量及变量值，这样定义的多个变量的变量类型可以不一样，没有定义变量类型会根据变量值的类型推导变量类型
	var(
	    变量名1 = 变量值
		变量名2 = 变量值
		....
	)*/
	var (
		age4 = "ccc"
		age5 = 222
		age6 = "vvv"
	)

	fmt.Println(age4, age5, age6)

	//短变量声明法定义变量，格式： 变量名 := 变量值；这种方式只能声明局部变量（比如方法内的变量），不能声明全局变量

	dd := 1
	ff, gg := "dfg", 2

	fmt.Println(dd, ff, gg)

	//调用方法并接受返回值
	var kk, ll = test()

	fmt.Println(kk, ll)

	//调用方法并接受返回值，方法有多少个返回值则必须有多少个变量接受，如果不想要其中的返回值，则可以采用 _ 即匿名变量的形式接受
	//匿名变量不占用命名空间，不会分配内存，因此匿名变量之间不存在重复声明的情况
	var jj, _ = test()
	fmt.Println(jj)

	var lm, _ = test()
	fmt.Println(lm)

	/****************常量定义******************/
	//常量：不可以重复赋值且必须在定义常量时就赋值可以不使用；变量可以重复赋值可以不在定义变量时赋值但必须要使用否则会报错
	//格式： const 常量名 = 常量值；批量定义常量的方式基本和变量一样只是var 换成 const且必须赋值

	const a1 = "aa"

	const a2, a3 string = "a2", "a3"

	const a4, a5 = "a4", 5

	const (
		a6 string = "a6"
		a7 int    = 7
	)

	const (
		a8 = "a8"
		a9 = 9
	)

	//这种方式定义常量必须每个常量赋值，不能像下面的方式对某些常量可以不赋值，所以这里是错误的
	//const b1, b2 = 100

	//批量定义常量，如果常量没有赋值则没有赋值的常量值和其上面最近的一个赋值的常量的值一样
	const (
		b1 = "b1"
		b2 = "b2"
		b3
		b4 = "b4"
		b5
	)

	fmt.Println(a1)

	fmt.Println(a2, a3)

	fmt.Println(a4, a5)

	fmt.Println(a6, a7)

	fmt.Println(a8, a9)

	fmt.Println(b1, b2, b3, b4, b5)

	//常量的值可以赋值为 iota ，iota表示0同时还具有计数功能，从0开始计数也就是赋值为 iota 的常量值为0（如：c1），但const中批量定义常量时且不对常量赋值的情况下
	//则这个没有赋值常量的值和其上面最近的一个赋值的常量的值一样（如：c8也是9），如果最近的这个常量值是 iota ，那么当前没有赋值的常量值包括赋值为 iota 的这个常量值就是在const批量定义常量时所处的索引号
	//（如：c4是const中定义的第3个常量，则索引就是2，那么c4的值就是2，c5的值就是3，c6的值就是4；c7和c8是9；c9是7，c10是8）,其中 _ 用于跳过当前值，也就是说c11是10而不是9，因为9被 _ 跳过了
	const c1 = iota

	const (
		c2 = 2
		c3 = 3
		c4 = iota
		c5 = iota
		c6
		c7 = 9
		c8
		c9 = iota
		c10
		_
		c11
	)

	fmt.Println(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)
}

/*
定义方法，且方法有两个返回值，一个string类型一个int类型
*/
func test() (string, int) {
	return "zzzz", 111
}