(1)Go变量声明、赋值和常量

 先简单了解一下控制台输出，在go中，我们使用fmt包中的函数进行在控制台中打印，一般用以下几个函数

     fmt.Print()        #不换行输出

     fmt.Printf()       #字符串格式化输出 同C语言

     fmt.Println( )     #带换行输出

     fmt.Fprintf()   fmt.Fprint()    fmt.Fprintln()   #指定输出流

 1.Go变量声明和赋值 

     var valName type    // 单个

     var (                        //多个

valName1 type

        valName2 type

       .......

     )

变量声明标准格式

Go语言的变量声明的标准格式为：

       var 变量名 变量类型

变量声明以关键字 var 开头，后置变量类型，行尾无须分号。

package main

import "fmt"

// 声明变量
// var name string
// var iB int

// 批量声明
var (
	name   string //""
	age    int    //0
	isFlag bool   //false
)
/*
*注意：
*声明了全局变量可以不使用，编译器不会报错(因为别人用这个包可能会使用)
*声明了局部变量必须使用，否则编译器报错
*
*go fmt xxx.go  命令可以格式化代码
*/

//str4 := "cuowu"  //出错

func main() {
	// 1.赋值
	name = "jadeshu"
	age = 20
	isFlag = true

	fmt.Print(name)
	fmt.Println()
	fmt.Println(isFlag)
	fmt.Printf("age:%d", age)

	// 2.变量声明并赋值
	var str string = "hehehe"
	fmt.Println(str)
	// 自动根据数值进行推导类型
	var str2 = "hahhahh"
	fmt.Println(str2)

	// 3.简单变量声明并赋值
	// 只能在局部变量进行短声明赋值 用的较多
	// 不能重复声明，且必须声明时赋值
	str3 := "heaaaa"     

	// 这个情况下可以，只要简单赋值语句里有一个变量是新声明的就可以
	// 同时还能改变原有变量的值
	str3, str4 := "1212", "sdsdsd"
	fmt.Println(str3)
	fmt.Println(str4)
	// 4.匿名变量 用一个下划线表示
	// 当忽略某个值时就用它
	// 它不会占用内存，也不存在重复声明
	// GO语言中函数可以返回多个值，这时候很有用
	a, _ := ret() // 忽略返回的y值
	fmt.Println(a)
}

func ret() (x,y int) {
	return 10,-1
}

输出结果：

 2.Go常量和iota

   const   valName=xxx    // 单个

     const   (                        //多个

valName1=xx

        valName2=xxx

       .......

     )

package main

import "fmt"

// 常量在运行期间不允许值改变
// 一个常量声明
const PI = 3.14

// 多个常量一起声明
const (
	DIR = 2 * PI
)

// t1 t2是100 t3 t4是200
// 同时声明多个常量时，如果省略了值则表示和上面一行的值相同
const (
	t1 = 100
	t2
	t3 = 200
	t4
)

// iota是go语言的常量计数器
// const中每新增一行常量声明将使iota计数一次
// iota可以理解为const语句块中的行索引，
// 使用iota能简化定义，在定义枚举时很有用
const (
	m1 = iota
	m2
	m3
)

// 增强理解iota
const (
	n1 = 10
	n2
	n3 = iota
	n4
)

// 增强理解iota
// 多个
const (
	s1, s2 =  iota+1, iota+2
	s3, s4 =  iota+1, iota+2
)

// 练习
// const (
// 	_ = iota
// 	KB = 1 << (iota*10)
// 	MB = 1 << (iota*10)
// 	GB = 1 << (iota*10)
// 	TB = 1 << (iota*10)
// 	PB = 1 << (iota*10)
// )

func main() {
	fmt.Println(DIR)
	fmt.Println(t1)
	fmt.Println(t2)
	fmt.Println(t3)
	fmt.Println(t4)
	fmt.Println("============")

	fmt.Println(m1)
	fmt.Println(m2)
	fmt.Println(m3)
	fmt.Println("============")

	fmt.Println(n1)
	fmt.Println(n2)
	fmt.Println(n3)
	fmt.Println(n4)
	fmt.Println("============")

	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)
	fmt.Println(s4)
	fmt.Println("============")
}

结果：

=======================================

package main

import "fmt"

func main() {
	//// 随机数种子
	//rand.Seed(time.Now().UnixNano())
	//
	//scoreMap := make(map[string]int, 200)
	//for i := 0; i < 100; i++ {
	//	key := fmt.Sprintf("student%02d", i)
	//	scoreMap[key] = rand.Intn(100)
	//}
	//
	//fmt.Println(scoreMap)
	//
	//// 排序map的key
	//// 按字符串排序
	//keys := make([]string, 0, 100)
	//for key := range scoreMap {
	//	keys = append(keys, key)
	//}
	//
	//sort.Strings(keys)
	//// 打印
	//for _, key := range keys {
	//	fmt.Println(key, scoreMap[key])
	//}
	//var mapSlice = make([]map[string]string, 3)
	//for index, value := range mapSlice {
	//	fmt.Printf("index:%d value:%v\n", index, value)
	//}
	//
	//fmt.Println("after init")
	//// 对切片中的map元素进行初始化
	//mapSlice[0] = make(map[string]string, 10)
	//mapSlice[0]["name"] = "小王子"
	//mapSlice[0]["password"] = "123456"
	//mapSlice[0]["address"] = "沙河"
	//for index, value := range mapSlice {
	//	fmt.Printf("index:%d value:%v\n", index, value)
	//}

	// 端口：【address,ip】
	info := make(map[int]map[string]string, 3)
	info[8080] = make(map[string]string,4)
	info[8080]["address"] = "上海"
	info[8080]["ip"] = "127.0.0.1"
	info[6060] = make(map[string]string,4)
	info[6060]["address"] = "北京"
	info[6060]["ip"] = "192.168.0.101"
	fmt.Println(info)

	testInfo:= &map[int]map[string]string{
		6000:{
			"address":"香港",
			"ip":"127.0.0.1",
		},
		7000:{
			"address":"武汉",
			"ip":"127.0.0.1",
		},
	}

	fmt.Println(testInfo)

}