golong基础相关操作--一

package main

//go语言以包作为管理单位，每个文件必须先声明包
//程序必须有一个main包
// 导入包，必须要要使用
// 变量声明了，必须要使用
import (
	"fmt"
)

/*
*
包内部的变量
*/
var aa = 3

var ss = "kkk"

var bb = true

var (
	aaa = 3
	sss = "kkk"
	bbb = true
)

/*
*
定义变量 必须有值
*/
func variableZeroValue() {
	var a int
	var s string
	fmt.Printf("%d %q\n", a, s)
}

/**
变量赋值
*/

func variableInitialValue() {
	var a, b int = 3, 4
	var s string = "abc"
	fmt.Println(a, b, s)
}

func variableTypeDeduction() {
	var a, b, c, s = 3, 4, true, "def"
	fmt.Println(a, b, c, s)
}

func variableShorter() {
	a, b, c, s := 3, 4, true, "def" //自动推到类型，必须初始化，%T打印变量所属的类型
	b = 5
	fmt.Println(a, b, c, s)
}

func test() (a, b, c int) {
	return 1, 2, 3
}

/**
数据类型作用：告诉编译器这个变量应该以多大的内存存储
*/
// 一个文件夹里面只有一个main文件
func main() {
	//fmt.Println("hello world")
	//variableZeroValue()
	//variableInitialValue()
	//variableTypeDeduction()
	//variableShorter()
	//fmt.Println(aa, ss, bb)
	//fmt.Println(aaa, sss, bbb)
	//
	交换2个变量
	//
	//a, b := 10, 20
	//a, b = b, a
	//fmt.Println(a, b)
	//var (
	//	e int
	//	c int
	//	d int
	//)
	匿名变量，丢弃数据不处理，_匿名变量配合函数返回值使用，才有优势
	//e, c, d = test()
	//fmt.Println(e, c, d)
	 常量：程序运行期间，不可以改变的量，常量声明需要const
	//
	//const f int = 10
	//
	f = 20; 常量不允许赋值，不允许修改
	//fmt.Println("f= ", f)
	//
	//const g = 10 //没有使用:= 不允许使用
	//fmt.Println("g= ", g)
	//
	多个变量或常量定义
	var a1 int
	var b1 float64
	
	a1, b1 = 10, 3.14
	//
	//var (
	//	a1 int
	//	b1 float64
	//)
	//a1, b1 = 10, 3.14
	//fmt.Println(a1, b1)
	//
	const i int = 10
	const j float64 = 3.14
	//
	const (
		i int = 10
		j float64 = 3.14
	)
	//
	//const (
	//	i = 10
	//	j = 3.14 // 可以自动推导类型
	//)
	//fmt.Println(i, j)
	//
	 iota常量自动生成器，每个一行，自动累加1
	 iota给常量赋值使用
	//const (
	//	a2 = iota
	//	b2 = iota
	//	c2 = iota
	//)
	//
	//fmt.Printf("a2 = %d, b2 = %d, c2 = %d\n", a2, b2, c2)
	3 iota遇到const，重置为0
	//const d2 = iota
	//fmt.Printf("d2 = %d\n", d2)
	//
	 可以只写一个iota
	//const (
	//	a3 = iota
	//	b3
	//	c3
	//)
	//fmt.Printf("a3 = %d, b3 = %d, c3 = %d\n", a3, b3, c3)
	//
	如果是同一行，值都一样
	//const (
	//	a4         = iota
	//	b4, b5, b6 = iota, iota, iota
	//	c4         = iota
	//)
	//fmt.Printf("a4 = %d, b4 = %d, b5 = %d, b6 = %d, c4 = %d\n", a3, b4, b5, b6, c4)
	//
	/类型分类
	 bool 类型 int8 这里的8代表8位
	//var boolean1 bool
	//boolean1 = true
	//fmt.Println("boolean1 = ", boolean1)
	//
	//var float3 float32
	//float3 = 3.14
	//fmt.Println("float = ", float3)
	//float4 := 3.124
	//fmt.Printf("float4 = %T\n", float4)
	//
	 float64存储小数比float32更准确，15小数点，7为小数点
	//
	字符类型
	//var ch byte //声明字符类型
	//ch = 97
	格式化输出，%d以字符方式打印
	//fmt.Printf("ch = %c, %d\n", ch, ch)
	//
	//ch = 'a' //字符单引号
	//fmt.Printf("ch = %c, %d\n", ch, ch)
	//
	大写转小写，小写转大写
	//str := "mike"
	//
	内建函数，len可以测字符串的长度，有多少个字符 len(str) =  4
	//fmt.Println("len(str) = ", len(str))
	//
	复数类型
	//var t complex128
	//t = 2.1 + 3.14i
	//fmt.Println("t = ", t) //t =  (2.1+3.14i)
	//
	内建函数，取实数和虚数
	//fmt.Println("readl(t)=", real(t), "imag(t)=", imag(t)) //readl(t)= 2.1 imag(t)= 3.14

	//var inta int
	//fmt.Println("请输入变量a: ")
	阻塞等待用户的输入
	//fmt.Scanf("%d", &inta) //或者fmt.Scan(&a)
	//fmt.Println("a = ", inta)

	//类型转换
	var flag bool
	flag = true
	//bool 类型不能转换为int
	//fmt.Printf("flag = %d\n", int(flag)) //%!d(bool=true)
	fmt.Printf("flag = %t\n", flag) //%!d(bool=true)

	// 0就是假 非0就是真
	// 整型也不能转换为bool 这种不能转换的类型，叫不兼容类型
	//flag = 1

	//类型转换,把ch的值取出来后转出int再给t赋值
	var ch byte
	ch = 'a' //字符类型本质上就是整型
	var t int
	t = int(ch)
	fmt.Println("t = ", t)

	// 类型别名 给int64起一个别名叫bigint
	type bigint int64
	var a1 bigint
	fmt.Printf("a1 = %T\n", a1) //a1 = main.bigint

	type (
		long int64
		char byte
	)

	//运算符
	fmt.Println("f>3", 4 > 3)

	//if语句
	s := "王思聪"

	//if和{就是条件，条件通常就是关系运算符
	if s == "王思聪" {
		fmt.Println("左手一个妹子,右手一个校花")
	}

	//if支持1个初始化语句 初始化语句和判断条件以分号分隔
	if a := 10; a == 10 {
		fmt.Println("a==10")
	}

	//多个分支 if else
	s1 := 11

	if s1 == 0 {
		fmt.Println("a==10")
	} else {
		fmt.Println("a!=10")
	}

	//var num int
	//fmt.Printf("请按下楼层:")
	//fmt.Scan(&num)
	//
	//switch num { //switch后面写的是变量本身
	//case 1:
	//	fmt.Println("按下的是1楼\n")
	//	//fallthrough //不跳出switch语句，后面的无条件执行
	//	//break //go语言保留break字，跳出switch语句，不写，默认就包含了
	//case 2:
	//	fmt.Println("按下的是2楼\n")
	//	//fallthrough
	//	//break
	//case 3:
	//	fmt.Println("按下的是3楼\n")
	//	//fallthrough
	//	//break
	//case 4:
	//	fmt.Println("按下的是4楼\n")
	//	//fallthrough
	//	//break
	//default:
	//	fmt.Println("按下的是xxx楼")
	//}

	//score := 85
	//switch {
	//case score > 90:
	//	fmt.Println("优秀")
	//case score > 80:
	//	fmt.Println("优秀")
	//case score > 70:
	//	fmt.Println("优秀")
	//}
	//
	//sum := 0
	for循环使用 1 初始化条件，2 判断是否为真，如果为真，执行循环体，如果为假跳出循环 3 条件变化i++ 4 重复2,3 4
	//for i := 1; i <= 100; i++ {
	//	fmt.Println("i=", i)
	//	sum = sum + i
	//}
	//fmt.Println("sum = ", sum)
	//
	//strr := "abc"
	range 迭代打印每个元素,默认返回2个值 一个是元素的位置，一个是元素本身
	//for i, data := range strr {
	//	fmt.Printf("str[%d] = %c\n", i, data)
	//}
	//
	range 第二个返回值，默认丢弃，返回元素的位置(下标)
	//for i, _ := range strr {
	//	fmt.Printf("str[%d] = %c\n", i, strr[i])
	//}
	//
	//i1 := 0
	//for { //for后面不写任何东西，这个循环条件永远为真，死循环
	//	i1++
	//	time.Sleep(time.Second) //延时1s
	//	if i1 == 5 {
	//		break //跳出循环，如果嵌套多个循环，跳出最近的那个内循环
	//		//continue //跳过本次循环，下一次继续
	//	}
	//	fmt.Println("i= ", i1)
	//}

	//goto可以用在任何地方，但是不能跨函数使用
	fmt.Println("111111111111")

	goto End //goto是关键字，End是用户起的名字，他叫标签

	fmt.Println("222222222222")
End:
	fmt.Println("33333333333333")
}