【Golang】2.用代码形式归纳Go的基础语法、数据类型、变量、常量、运算符、条件语句

package main

import (
	"fmt"
	"unsafe"
)

/*
	go的数据类型
	布尔型：bool
	数字类型：int   float	uint8-64	int8-64 float32-64	complex64-128	byte（uint8别称）  rune是代表单个Unicode字符
	字符串类型：string
	派生类型：指针pointer   数组类型  结构化类型struct	联合体类型union	函数类型	切片类型	接口类型interface	map类型	channelbeijing
*/



//go的语言变量定义及书写形式
var num2 int

var aa = "hello"
var bb string = "helloworld"
var cc bool

var(
	a int
	b bool
)

var c, d int = 1, 2
var e, f =123, "hhhhhhhhhhhhh"

//go的语言常量只可以是布尔型、数字型（整形浮点和复数） 字符串
//显示定义
const CONA int = 100
//隐式定义
const CONB = "abc"
//常量做枚举
const(
	unknow = 0
	female =1
	male = 2
)

//算数运算符
/*
	+ 相加
	- 相减
	× 相乘
	/ 相除
	% 求余
	++ 自增
	-- 自减
*/

//关系运算符
/*
	== 判等
	!= 判不相等
	> 大于
	< 小于
	>= 大于等于
	<= 小于等于
*/

//逻辑运算符
/*
	&& 逻辑与
	|| 逻辑或
	！ 逻辑非
*/

//位运算符
/*
	& 按位与
	| 按位或
	^ 按位异或
	<< 左移运算符
	>> 右移运算符
*/

//其他运算符
/*
	* 指针变量， 定义一个*a就是说明是定义啦一个指针变量
	& 返回变量存储地址， &a就是获得变量a的实际地址
*/
func pointerPrac(){
	var pa *string
	var numa string = "指针类型啊？"
	println(numa)
	pa = &numa
	println(*pa)
}

//go的控制结构
func ifelifPrac(a int){
	//if和else的使用嗷
	if(a <= 10){
		println("小于10")
	}else if(a > 10 && a <= 20){
		println("小于20")
	} else{
		println("大于20啊")
	}

	//三种switch的用法
	switch a {
	case 10: println("10!")
	case 20: println("20!")
	case 30: println("30!")
	case 40: println("40!")
	default:
		println("others")
	}

	switch {
	case a == 10:
		println("差～")
	case a == 20, a == 30:
		println("中～")
	case a == 40:
		println("优～")
	}

	var x interface{}
	switch i := x.(type){	// type-switch 是用来判断某个interface变量中实际存储的变量类型
	case nil:
		fmt.Println("x的类型是%T" , i)
	case int:
		fmt.Println("x的类型是int")
	case float64:
		fmt.Println("x是float64型")
	case func(int) float64:
		fmt.Println("x的类型是fun(int)型")
	case bool, string:
		fmt.Println("x是bool或string型")
	default:
		fmt.Println("未知型")
	}

	//select语句
	/*
	每个case都必须是一个通信
	所有channel表达式都会被求值
	所有被发送的表达式都会被求值
	如果任意某个通信可以进行，它就执行；其他被忽略。
	如果有多个case都可以运行，Select会随机公平地选出一个执行。其他不会执行。
	否则：
	如果有default子句，则执行该语句。
	如果没有default字句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。
	*/
	var c1, c2, c3 chan int
	var i1, i2 int
	select {
	case i1 = <-c1:
		fmt.Printf("received ", i1, " from c1\n")
	case c2 <- i2:
		fmt.Printf("sent ", i2, " to c2\n")
	case i3, ok := (<-c3): // same as: i3, ok := <-c3
		if ok {
			fmt.Printf("received ", i3, " from c3\n")
		} else {
			fmt.Printf("c3 is closed\n")
		}
	default:
		fmt.Printf("no communication\n")	//结果no communication
	}
}

func main() {
	var num1 int
	num1 = 5
	fmt.Println(num1)

	num2 = num1
	fmt.Println(num2)

	fmt.Println(aa, bb, cc)

	g, h := 123, "heiha"
	println(a, b, c, d, e, f, g, h)

	//常量
	const coa, cob, coc = 1, false, "ccccc"
	println(coa, cob, coc)
	fmt.Println("面积为：", coa*num1, ",这是面积啊")

	println(unknow, male, female)

	const (
		cosa = "abc"
		cosb = len(cosa)
		cosc = unsafe.Sizeof(cosa)
	)
	println(cosa, cosb, cosc)

	//iota特殊常量，是一个可以被编译器修改的常量，有种类似行计数器的感觉
	const (
		aaa = iota
		bbb          //1
		ccc          //2
		ddd = "ha"   //独立值，iota += 1
		eee          //"ha"   iota += 1
		fff = 100    //iota +=1
		ggg          //100  iota +=1
		hhh = iota   //7,恢复计数
		iii          //8
	)
	println(aaa, bbb, ccc, ddd, eee, fff, ggg, hhh, iii)
	const (
		i = 1 << iota	//i=1<<0	1
		j = 3 << iota	//j=3<<1	011 <- 110 6
		k				//k=3<<2	12
		l				//l=3<<3	24
	)
	println(i, j, k, l)

	pointerPrac()
	ifelifPrac(100)
}