Go语言入门学习（一）——变量，类型，运算符

Go语言入门学习（一）——变量，类型，运算符

最近看了蔡超老师与极客邦合作的Go语言学习教程，让我这个之前学java一知半解的我收获颇丰，所以想借此机会把自己的学习历程记录下来，以供后续的查阅

一.第一个Go语言程序

我所使用的IDE是jetbrains的Goland，这款IDE虽然看起来并没有市面上其他简洁型IDE一样“轻盈”，但是它的功能如同JetBrains的其他开发软件一样，强大且方便。
以下是Hello World程序的实例。

package main //包，表明代码所在的模块，目录名可以不为main

import (
	"fmt"
	"os"
) //引入代码依赖

//功能实现，main不能有返回值,main不可以传入参数
func main() {
	fmt.Println(os.Args)
	if len(os.Args) > 1 {
		fmt.Println(os.Args)
	}
	fmt.Println("Hello World!")
	os.Exit(0)
}

这里有一些要注意的点，如果你在程序中声明了main函数，那么package后面也一定要声明main，但是与java不同的一点是，package 后面的包名，可以和所在目录名不一致。
在注释中也提到了一点main中不能有返回值，可以用os包中的Exit函数进行程序退出。

二.变量、类型与常量

变量定义的基本范式为 var [name] [type] = [value]，当然Go语言也会支持类型的自动识别，可以使用[name]:=[value]的形式。为了之后的测试用例运行方便，我们采用Go语言所支持的测试文件，测试方法。
测试用例的文件名一定是是xxx_test.go，其中函数的函数名为Test[Name]，测试程序以及测试方法全部源于Go语言的testing包。
下面用一段简单的斐波那契额数列程序来举例：

package fib
//fib_test.go
import (
	"testing"
)

func TestFibList(t *testing.T) {
	//var a int = 1
	//var b int = 1
	var (
		a int = 1
		b int = 1
	)
	t.Log(a)
	for i := 0; i < 5; i++ {
		t.Log(" ", b)
		tmp := a
		a = b
		b = tmp + a
	}
}

func TestExchange(t *testing.T) {
	a := 1
	b := 3
	a, b = b, a
	t.Log(a, b)
}

如上面的程序所示，变量定义的方式是多样化的，我们可以按照基本的范式定义var a int = 1的形式，当需要定义的变量比较多的时候还可以用括号将所需的变量全部都括起来。(上述代码所示并非是全部的变量定义方式，只是举了两个最为常用的例子)
运行结果：

Go语言中的变量类型与大部分主流语言是一样的都是囊括了整型，浮点型，字符串，布尔，字符等常用类型，除此之外其还支持指针操作。
下面是关于类型的一些测试

package type_test
//type_test.go
import (
	"math"
	"testing"
)

type MyInt int64

//预定义的值
var max int = math.MaxInt64

func TestImplicit(t *testing.T) {
	var a int32 = 1
	var b int64
	b = int64(a)
	t.Log(a, b)
}

func TestPoint(t *testing.T) {
	a := 1
	aPtr := &a
	t.Log(a, aPtr)
	t.Logf("%T %T", a, aPtr) //指针无法运算
}

func TestString(t *testing.T) {
	var s string //初始化为空串
	t.Log("*" + s + "*")
}

我们可以使用type关键字自己来设置类型的名称，例如上述代码的type MyInt int64。指针操作与C语言有类似之处，其形式都是&[name]，但是Go语言中的指针不支持运算。
同样要注意的一点是，Go语言只支持显式类型转换，不支持隐式类型转换
如下是上述代码的运行结果

接下来我们来看一下常量的部分

package constant_test
//constant_test.go
import "testing"

const (
	Monday = iota + 1
	Tuesday
	Wednesday
)

const (
	Readable = 1 << iota
	Writeable
	Excuteable
)

func TestConstantTry(t *testing.T) {
	t.Log(Monday, Tuesday, Wednesday)
}

func TestConstantTry1(t *testing.T) {
	a := 7 //0111
	t.Log(a&Readable == Readable, a&Writeable == Writeable, a&Excuteable == Excuteable)
}

和C语言一样，Go语言中的常量定义也是通过关键字const来定义的。在常量的定义过程中我们可以使用Go语言中的iota来实现后续常量的递增赋值，也可以使用<<运算符进行二进制递增移位。
其最终的运行结果如下

三.运算符

众所周知，运算符这个东西基本上是不怎么有差别的，在Go语言中也是如此。但是Go语言中也有独特的一点。在其它语言中例如：C，==是不可以拿来比较数组的，但是在Go语言中其可以用于比较数组，但是有使用条件，需要这两个数组有相同维度以及相同个数的元素
相关的示例如下，

package operator_test
//operator_test.go
import "testing"

func TestCompareArray(t *testing.T) {
	a := [...]int{1, 2, 3, 4}
	b := [...]int{1, 2, 3, 5}
	//c := [...]int{1, 2, 3, 4, 5}
	d := [...]int{1, 2, 3, 4}
	t.Log(a == b)
	t.Log(a == d)
}

//按位清零测试
const (
	Readable = 1 << iota
	Writeable
	Excuteable
)

func TestBitClear(t *testing.T) {
	a := 7 //0111
	a = a &^ Readable
	t.Log(a&Readable == Readable, a&Writeable == Writeable, a&Excuteable == Excuteable)
}

上述代码中的第三部分是一组按位清零测试，&^按位置清零 1&^0=1，1&^1=0，0&^1=0，0&^0=0（后者为零则保持原样，后者为一则主动清零）
其运行结果如下图