go语法基础一(变量类型，变量定义，运算符，数组，语句，函数)

       go或称golang,google在2009年发布的一款新语言，而java上线时间是1995，java比go早14年，go比java好在哪里？对于 Java 来讲，Go语言拥有简明的类型系统、函数式编程范式和先进的并发编程模型。因此其代码块更小更简洁、可重用性更高，并可在多核计算环境下更快地运行。那既然这样，学习一下吧。

package main

import (
	"container/list"
	"container/ring"
	"fmt"
	"math"
	"math/rand"
	"sort"
	"strconv"
	"strings"
	time2 "time"
)


func main() {
	//fmt.Println("hello,world!")
	//scanTest()
	//defineVar()
	//operator()
	//testStr()
	//testSentence()
	//testTime()
	//testMathAndRand()
	//testArr()
	//testMap()
	//testList()
	//testCircleList()
	/**
	 *测试函数定义
	 */
	//testNoArgNoReturn()
	//var a=testNoArgReturn()
	//fmt.Println(a)
	//testArgNoReturn("andy",18)
	//b:=testArgAndReturn("jackay",18)
	//fmt.Println(b)
	//c,d:=testArgAndMoreReturn("lily",16)
	//fmt.Println(c,d)
	//fmt.Println(add(1,2))
	//testVaryParams("a1","b2","c3")
	//testAnonymousFunc()
	//testFuncVary()
	testImport()
}

/**
接收输入Scan
*/
func scanTest() {
	var name, age string
	fmt.Println("请输入姓名和年龄！")
	//输入后换行
	//fmt.Scanln(&name, &age)
	//输入一个字符后换行再接收另外一个字符
	fmt.Scanf("%s \n %s", &name, &age)
	fmt.Println("接收到的内容为", name, age)
}

/**
变量定义测试
*/
func defineVar() {
	//声明变量再赋值
	var a string
	a = "hello,world"
	fmt.Println(a)
	//声明变量直接赋值
	var b string = "haha"
	fmt.Println(b)
	//声明变量直接赋值,可以去除类型
	var c = "你好!"
	fmt.Println(c)
	var d = 123
	//d = "test" //go是静态类型语言,已经设置为int,不能再改成string
	fmt.Println(d)
	//短变量，只能放在函数体内，不能定义成全局变量
	e := "hi"
	fmt.Println(e)
	//一次声明多个变量
	var f, g, h int
	f, g, h = 1, 2, 3
	fmt.Println(f, g, h)
	//一次声明多个变量且赋值
	var i, j, k = 6, 7, true
	fmt.Println(i, j, k)

	//使用var声明并赋值
	var (
		l = 8
		m = 9
		n = "net"
	)
	fmt.Println(l, m, n)

	var z, z1, f1 = 0x795D, 0x5FD7, 0x98DE
	//Println直接换行输出是int数字
	fmt.Println(z, z1, f1)
	//Printf输出格式化,%表示转义，%c表示转成字符
	fmt.Printf("%c%c%c", z, z1, f1)

	var o = 1.23
	fmt.Println(o)

	var f3 float64 = 1234567890
	fmt.Println(f3)
	//float64转int
	fmt.Println(int(f3))
	var f4 = 1234
	//int转float64
	var f5 = float64(f4)
	fmt.Println(f5)
	//bool赋值
	var t1 bool = true
	var f2 = false
	fmt.Println(t1, "\n", f2)

	//通过运算得到bool值
	a2 := 5 > 3
	fmt.Println(a2)
	fmt.Printf("%T", a2)

	var strTest = "\n hello,\t world!"
	fmt.Println(strTest)

	var strTest1 = `hello,\t world!`
	fmt.Println(strTest1)

	var str2, e1 = strconv.ParseInt("11", 10, 64)
	fmt.Println(e1)
	fmt.Println(str2)

}

/**
运算符
*/
func operator() {
	//算数运算符
	//+ - * / ++ -- %
	var a, b, c = -1, 2, 3
	fmt.Println(a + b*c)
	fmt.Println(a + b/c)
	c++
	fmt.Println(c)
	c--
	fmt.Println(c)

	//取模%
	var d = b % c
	fmt.Println(d)
	var e = c % b
	fmt.Println(e)

	//比较运算符< > >= <= == !=
	fmt.Println(a > b)
	fmt.Println(a != b)

	//逻辑运算符 && || !
	var f = false
	var g = true
	fmt.Println(f && g)
	fmt.Println(f || g)
	fmt.Println(!f)

	//赋值运算符 = += -= *= /= %= <<= >>= &= |= ^=
	a += b
	fmt.Println(a)
	a *= b
	fmt.Println(a)
	a %= b
	fmt.Println(a)
	a <<= b
	fmt.Println(a)
	c &= b
	fmt.Println(c)

	//位运算符<< >> | & ^ &^  通过补码进行运算
	//a1补码11111111     b1补码00000010
	var a1 = -1
	var b1 = 2
	fmt.Println(a1 | b1) //11111111->11111110->00000001
	fmt.Println(a1 & b1) //00000010
	fmt.Println(a1 ^ b1)
	fmt.Println(a1 &^ b1)

}

/**
string类型测试
*/
func testStr() {

	var str string = "hello,world"
	fmt.Println(str)
	//工具类strconv 字符串转换
	var a string = "123"
	var i, e = strconv.ParseInt(a, 10, 64)
	if e == nil {
		fmt.Println(i)
		fmt.Printf("%T", i)
		fmt.Println()
	}

	f := "1.5"
	var f1, e2 = strconv.ParseFloat(f, 64)
	if e2 == nil {
		fmt.Println(f1 + 5)
	}

	//Atoi是ParseInt(s, 10, 0)的简写。
	var j, e1 = strconv.Atoi(a)
	if e1 == nil {
		fmt.Println(j)
		fmt.Printf("%T", j)
		fmt.Println()
	}

	//转换成string
	var b int = 12
	var s string = strconv.FormatInt(int64(b), 10)
	fmt.Println(s)

	//Itoa是FormatInt(i, 10) 的简写。
	var s1 string = strconv.Itoa(b)
	fmt.Println(s1)

	var s2 = "testa好 "
	fmt.Println(len(s2))

	//工具类strings
	fmt.Println(strings.HasPrefix(s2, "test"))
	fmt.Println(strings.Index(s2, "a"))
	fmt.Println(strings.ToUpper(s2))
	fmt.Println(strings.Replace(s2, "t", "a", -1))
	fmt.Println(strings.Trim(s2, " "))
	fmt.Println(strings.TrimSpace(s2))
	arr := strings.Split(s2, "t")
	fmt.Println(arr)
	fmt.Printf("%T", arr)
	arr1 := []string{"a", "b", "c"}
	fmt.Println(strings.Join(arr1, "$"))

	//常量定义 const
	const c1 = "very good!"
	fmt.Println(c1)
	const (
		c2 = 1
		c3 = "sh"
		c4 = true
	)
	fmt.Println(c2)
	fmt.Println(c3)
	fmt.Println(c4)

	const (
		c5 = 5
		c6 = iota
		c7
	)
	fmt.Println(c5, c6, c7)
	//获取变量内存地址
	var c8 = "aha"
	fmt.Println(&c8)

	//定义指针变量
	var c9 *int
	var c10 = 123
	c9 = &c10
	fmt.Println(c9, &c10)
	fmt.Println(*c9, c10)
	*c9 = 123456
	fmt.Println(*c9, c10)
	//new定义指针,c11不会为nil,c12不是new不能直接赋值需要先赋地址
	var c11 = new(int)
	var c12 *string
	fmt.Println(c11)
	fmt.Println(c12)
	*c11 = 888888
	fmt.Println(*c11)
	*c12 = "test"

}

//测试go语句
func testSentence() {
	//1.if else
	score := 97
	if score > 90 {
		println("great")
	} else {
		println("need work hard")
	}
	//小括号也可以不加
	if score > 90 {
		println("great1")
	}

	if score > 60 && score < 90 {
		println("中等")
	}

	//2.switch选择
	var case1 = 9
	switch case1 {
	//可以指定多个
	case 5, 8:
		println("it is 5 or 8")
	case 6:
		println("it is 6")
		//fallthrough穿透，可以继续执行 case 9，fallthrough不能放在最后一个case
		fallthrough
	case 9:
		println("it is 9")
		break //break退出，下面的语句将不会被执行
		println("test break")
	default:
		println("nomatch default to do something")
	}

	//3.for循环
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
	//内嵌循环，冒泡排序 >升序，<降序
	var arr [5]int = [5]int{1, 8, 5, 9, 0}
	var len = len(arr) - 1
	for i := 0; i < len; i++ {
		for j := 0; j < len-i; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}
	fmt.Println(arr)

	//4. continue 继续下次循环,break 退出当前循环
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if j == 2 {
				continue
			}
			fmt.Println(i, j)

		}
	}
	//定义标签
tag1:for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if j == 2 {
				//可以对外面的循环生效
				continue tag1
			}
			fmt.Println(i, j)

		}
	}

	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if j == 1 {
				break
			}
			fmt.Println(i, j)

		}
	}
	//定义标签
tag2:for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if j == 2 {
				//可以对外面的循环体生效
				break tag2
			}
			fmt.Println(i, j)

		}
	}

    //5.goto
    a:=6
    if a==6{
    	goto Label1
	}
	fmt.Println("test")
    //定义了标签，goto之后会跳转到标签所在行开始执行， test打印语句将不会执行
	Label1:
		fmt.Println("this is Label1")

}
func testTime() {
	//获取当前时间
	var t = time2.Now()
	fmt.Println(t)
	//根据时间戳获得时间
	var t1 = time2.Unix(0, t.UnixNano())
	fmt.Println(t1)
	//指定时间
	t = time2.Date(2022, 7, 25, 10, 22, 12, 123, time2.Local)
	fmt.Println(t)
	fmt.Println(t.Year())
	fmt.Println(t.YearDay())
	fmt.Println(t.Hour())

	//时间向string格式转换,2006-01-02 15:04:05 go的诞生时间，go不用yyyyMMdd这种格式
	var str = t.Format("2006-01-02 15:04:05")
	fmt.Println(str)
	var str1 = t.Format("2006-01-02 15:04:05.000000")
	fmt.Println(str1)

	//string转换成时间
	var str3 = "2022-01-01 08:08:08"
	var t2, e = time2.Parse("2006-1-2 15:04:05", str3)
	if e == nil {
		fmt.Println(t2)
	} else {
		fmt.Println(e)
	}

}

func testMathAndRand() {
	//math
	var f1 = 12.5
	fmt.Println(math.Round(f1))
	var f2 = 12.3
	fmt.Println(math.Round(f2))
	//rand
	rand.Seed(time2.Now().UnixNano())
	var r = rand.Intn(20000)
	fmt.Println(r)

	//假设取1000~9999之间的随机数

	fmt.Println(1000 + rand.Intn(8999))

}

/**
数组
*/
func testArr() {
	//完整定义 变量名 类型=[长度]类型{值}
	var arr1 [3]int = [3]int{1, 2, 3}
	fmt.Println(arr1)
	//短变量
	arr2 := [3]int{4, 5, 6}
	fmt.Println(arr2)

	//超过数组长度的，取默认值0
	arr3 := [4]int{4, 5, 6}
	fmt.Println(arr3)

	//动态长度
	arr4 := [...]string{"a", "b", "c"}
	fmt.Println(arr4)
	arr4[2] = "1"
	fmt.Println(arr4)
	fmt.Println(len(arr4))

	//二维数组
	var arr5 [3][2]int = [3][2]int{{1, 2}, {3, 4}, {5, 6}}
	fmt.Println(arr5)

	/**
	 *切片不设置数组长度，声明时不赋值不会分配内存空间
	 *切片是引用类型
	 *，数组不赋值也会事先分配内存空间
	 */
	fmt.Println("......切片测试......")
	var slice1 []string
	var arr0 [3]string
	fmt.Println(slice1)
	fmt.Println(len(slice1))//0
	//打印类型
	fmt.Printf("%T",slice1)
	fmt.Println()
	fmt.Println(arr0)
	fmt.Println(len(arr0))//虽然没有赋值但是长度为3
	//打印类型
	fmt.Printf("%T",arr0)
	fmt.Println()
	//切片定义方法1
	slice1=[]string{"a","b","c"}
	fmt.Println(slice1)
	arr0=[3]string{"1","2","3"}
	fmt.Println(arr0)

    //make可以创建slice,map,channel,interface,这里创建一个个数为6，容量为6的切片即数组
    //切片定义方法2
    var arr6=make([]int,6,6)
    //查看数组长度和容量
    fmt.Println(len(arr6),cap(arr6))
    var arr7 [2]string=[2]string{"a","b"}
	fmt.Println(arr7)
     //动态新增
     arr6=append(arr6,7)
     fmt.Println(arr6)
     //指定长度的数组不能append
     //arr7=append(arr7,"c")

	//新增一个其他切片,必须带上...
	arr8 :=[]int{1,2,3}
	arr6=append(arr6,arr8...)
	fmt.Println(arr6)

	//数组的一个片段也是切片，切片定义方法3
	//切片是指针,简单说是没有定义长度的数组
	var slice2=arr0[0:2]
	fmt.Printf("%T \n",slice2)
	fmt.Println(slice2)

	//go 没有删除方法，只能通过append (]前包含后不包含的特性进行删除

	var slice3 []string=[]string{"a","1","b","2","c","3"}
	fmt.Println("slice3=",slice3)
	var index=3//删除第四个元素
	var slice4=slice3[0:index] //0~3 a,1,b,不包含2
	var newSlice=append(slice4,slice3[index+1:]...)//从第5个元素,c开始
	fmt.Println("slice3=",slice3)
	fmt.Println("newSlice=",newSlice)


	var s1=[]int{1,2}
    var s2=[]int{7,5,1,9,8}
    copy(s2,s1)//s1 copy到 s2,替换对应的元素
    fmt.Println(s1)
	fmt.Println(s2)
    //采用copy方法删除元素、
    //需要删除的索引
    var n=3
    //定义切片
    var s3=make([]int,n)
    //s2切片 copy到 s3
    copy(s3,s2[0:n])
    //s2剩余的append到s3
    s3=append(s3,s2[n+1:]...)
    fmt.Println(s3)


    //sort排序
    //升序
	//sort.Ints(s2) 等同于下面
    sort.Sort(sort.IntSlice(s2))
    fmt.Println(s2)
    //降序
	sort.Sort(sort.Reverse(sort.IntSlice(s2)))
	fmt.Println(s2)



}

func testMap()  {
	//没赋值时nil
	var map1=make(map[string]string)
	fmt.Println(map1)
	var map2=map[string]string{"k1":"v1","k2":"v2","k3":"v3"}
	fmt.Println(map2)
	//key不存在则新增
	map2["k6"]="v6"
	//key存在则修改
	map2["k3"]="value3"
	fmt.Println(map2)
	//删除
	delete(map2,"k3")
	fmt.Println(map2)
    //如果k2存在，把值赋给val,是否存在的布尔值赋值给exist
	val,exist:=map2["k2"]
	fmt.Println(val,exist)
    //循环map
	for k,v:= range map2{
		fmt.Println(k,v)
	}

}

func testList(){
	//新建双向链表
	myList:=list.New()
	fmt.Println(myList)
	myList.PushBack("a")
	myList.PushFront("1")
	myList.PushBack("b")
	//将a移到第一个
	myList.InsertBefore("a",myList.Front())
	//从第一个开始循环
	for e:=myList.Front();e!=nil;e=e.Next(){
		fmt.Println(e.Value)
	}
	//将第一个移到最后一个后面
	myList.MoveAfter(myList.Front(),myList.Back())
	fmt.Println(myList)
	//从第一个开始循环
	for e:=myList.Front();e!=nil;e=e.Next(){
		fmt.Println(e.Value)
	}

	//取第三个元素值
	n:=3
	e:=myList.Front()
	for i:=1;i<n;i++{
		e=e.Next()
		//fmt.Println(e.Value)
	}
	fmt.Println(e.Value)
}
/**
测试循环双向链接，双向链接头尾相连的特殊情况
 */
func testCircleList()  {
	r:=ring.New(6)
	r.Value="a"//表示第一个元素赋值a
	r.Next().Value="6"
	r.Next().Next().Value="8"
	r.Next().Next().Next().Value="9"
	r.Prev().Value="5"
	r.Prev().Prev().Value=1
	//循环双向链表
	r.Do(func(i interface{}) {
		fmt.Println(i)
	})
}

/**
函数测试
 */
func testNoArgNoReturn() {
	fmt.Println("无参无返回值函数")
}
func testNoArgReturn()(int){
	fmt.Println("无参有返回值函数")
	return 123
}
func testArgNoReturn(name string,age int) {
	fmt.Println("有参无返回值函数")
}
func testArgAndReturn(name string,age int) string{
	fmt.Println("有参有返回值函数")
	return name+","+strconv.Itoa(age)
}
func testArgAndMoreReturn(name string,age int) (string,int){
	fmt.Println("有参有返回多值函数")
	return name+","+strconv.Itoa(age),100
}
//也可以这么定义,直接赋值给返回值，那么返回就可以直接写return
func add(a int ,b int)(sum int)  {
	sum=a+b
	return
}

func testVaryParams(params...string)  {
	for index,item:=range params{
		fmt.Println(index,item)
		fmt.Println(item)
	}
}

func testAnonymousFunc()  {
	//匿名不带参数
	func (){//不加方法名
		fmt.Println("这么定义匿名函数")
	}()//加上挂号表示调用
    //匿名带参数
	func(name string,age int){
		fmt.Println(name+","+strconv.Itoa(age))
	}("老祝",28)
    //匿名带返回值
	name:=func()string{
		return "张三"
	}()
	fmt.Println(name)

	//匿名带参带返回值
	age:=func(age1 int)int{
		return age1
	}(18)
	fmt.Println(age)
}
/**
定义函数变量
 */
func testFuncVary()  {
	var funcA func()
	funcA= func() {
		fmt.Println("函数变量定义")
	}
	funcA()
}

func testImport()  {
	//b:=stringutil.isempty("abc")
	//fmt.Println(b)
	fmt.Println("测试引用其他包名中的类")
}


package comm


func IsEmpty(param string) bool {
	if param==""||len(param)==0 {
		return true
	}else {
		return false
	}
}