Go语言基础语法

本部分包含Go语言的变量、常量、类型转换、枚举、if、switch、循环，属于go语言语法中基础部分

Hello world

package main
// 程序入口
import "fmt"
// 输出库
func main() {
// 主程序入口
	fmt.Print("hello world")
	// 输出语句
}

变量

在go语言中，凡是定义的变量必须使用，否则会报错

变量定义方法

var a int

在go语言中，一般定义变量使用关键字var，在go语言中，变量名写在前，变量类型在后

func variable()  { // go语言函数写法，在后面会说明，此处先看内容
	var a int
	var s string
	fmt.Printf("variable()输出：%d %q\n",a,s)
	// %q可以输出空字符串
	}

在go语言中s是空字符串，而不是null，这在go语言中也是不存在null的，是nil

变量赋值

func variableInitialValue(){
	var a,b int = 3, 4
	var s string = "abc"
	fmt.Printf("%d %q %d\n",a,s,b)
	// 直接输出
	fmt.Println(a,s,b)
	// 带换行的输出
}

go语言中可以直接赋多个值，在多个变量时，也可以省去书写多个var的麻烦，如:

var (//省去多次书写var的麻烦
	aaa=3
	sss="kkk"
	bb=true
	// bool类型
)

当然，你也可以让go语言自动识别变量类型，并同时赋值多个变量

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

如果你连var都不想写了，当然也是可以的

func variableShort(){
	a,b,c,d := 3,4,true,"def"
	//e:=5 //再使用会报错,只能第一次使用
	fmt.Println(a,b,c,d)
}

但是要注意，在一段代码中:=的赋值方式只能使用一次，如果再使用，则会报错

还有一点要注意的是，在定义全局变量时（实际上go语言没有全局变量说法，只有包变量）

同时，go语言在定义全局变量时，不允许使用:=的方式进行赋值

package main
import (
	"fmt"
)
//需要导入多个库写法

var aa = 3
var ss="kkk"
// 没有全局变量说法，只是包变量
// bb:=true
// 不能在全局用:=，必须用var

func main() {
	fmt.Println(aa, ss)
}

go语言与其他语言不同的地方在于它支持复数，具体使用方法见代码注释

package main
import (
	"fmt"
	"math/cmplx"
)
func euler(){
	c:=3+4i //复数类型不能用4*i，会误以为i是变量
	fmt.Println(cmplx.Abs(c),)
	fmt.Printf("%.3f\n",cmplx.Exp(1i * math.Pi)+1) //1i为了让系统知道i是个复数，不是变量
}
func main() {
	euler()
}

/* -----------输出-------------- */

    5
    (0.000+0.000i)

/* -----------输出-------------- */

交换变量时，go可以像python一样，直接将两个变量交换

a, b = b, a

常量与类型转换

在go语言中，任何涉及的类型转换的地方都必须使用显示类型转换

func triangle(){
	a,b:=3,4
	var c int //go语言只能强制类型转换，没有隐式的，所以int（）之类不能省
	c = int(math.Sqrt(float64(a*a+b*b)))
	fmt.Println(c)
	//由于float有时候不准，所以这条式子有可能是4
	//该问题存在于任何编程语言中
}

以求勾股定理代码为例，math.Sqrt()要求以float64为输入类型，而求得的c要求以整形

有这么一种情况可能在实际编写的过程中被认为存在类型转换，实际上并没有，也不是所谓的隐式类型转换

func consts(){
	const(
		filename string = "abc.txt"
		a,b=3,4
	)
	// go语言中常量的写法
	/*关于常量，go语言中常量书写方式一般不大写，因为在go中首字母大写有其他含义日后学习中再总结*/
	
	var c int
	c = int(math.Sqrt(a*a+b*b))
	
	//上面定义未指定a，b类型，可以是int也可以是float
	// 所以在上面不需要显示转换，被认为是float64
	
	fmt.Println(filename,c)
}

/* -----------输出-------------- */

    abc.txt 5

/* -----------输出-------------- */
	

if与switch

在go语言中，它的if与switch写法与其他语言在一般的写法上没有什么太大区别，增加了一些特色的写法，如可以在if后面执行一条语句，

if写法

以这段代码为例子，代码中的nil可以看这篇文章Golang之nil讲解相对详细，在此不废话

package main

import (
	"fmt"
	"io/ioutil"
)
func iftext(){
	const filename = "abc.txt"
	// windows有时可以使用绝对路径如：F:\\GO_S\\stury001\\src\\abc.txt
	
	contents, err := ioutil.ReadFile(filename)
	/* go返回值有两个
	   第一个返回值是正常的返回值
	   第二个返回值err通常作为程序状态返回信息 */
	/* 该方法时go语言读取文件内容，如果文件不存在时err获取到错误信息 */
	/* 文件存在时读取文件内容 */
	if err != nil {
		fmt.Println(err)
	}else{
		fmt.Printf("%s\n",contents)
	}
	
	//特色写法
	if contents2, err2 := ioutil.ReadFile(filename);err2 !=nil {
		fmt.Println(err)
	}else{
		fmt.Printf("%s\n",contents2)
	}
	//fmt.Println(contents2)
	// 这句话会报错，因为contents2生存期只在特色写法的if中存在
}

func iftext2(){
	if a:= 1==1; a{
		fmt.Println("1==1")
	}
}

func main() {
	fmt.Println()
	iftext()
	iftext2()
}

/* -----------输出-------------- */

    文件不存在时：open abc.txt: The system cannot find the file specified.
	
	文件存在时：文件内容

/* -----------输出-------------- */

switch写法

package main

import (
	"fmt"
)

func grade(score int) string {
	g :=""
	switch {
	case score<60:
		g="F"
	case score<80:
		g="C"
	case score<90:
		g="B"
	case score<=100:
		g="A"
	default:
		panic(fmt.Sprintf("Wrong score:%d",score))
	}
	return g
}

func grade2(){
	for i:=0;i<5;i++{
		switch i{
		//此处i可以做运算，如i%2==0
			case 0, 2:
				fmt.Println("Even")
			case 0, 2:
				fmt.Println("0dd")
			defaule:
				fmt.Println("it is not ")
		}
	}
}

func main() {
	fmt.Println()
	fmt.Println(
		grade(0),
		grade(59),
		grade(60),
		grade(82),
		grade(100),
		)//若输入错误，整个程序中断，
		// 输出default中内容，同时不显示其他参数执行结果
}

/* -----------输出-------------- */

    F F C B A

/* -----------输出-------------- */

枚举

这部分直接看样例代码与输出

package main
//day2  常量与枚举
import (
	"fmt"
	"math"
)
const filename1 = "123.txt"//常量也可以在包内定义

func enums1()  {//go没有特殊枚举关键字，一般用一组const
	const( //const必须给其赋值
		cpp = 0
		java = 1
		python = 3
		golang = 5
	)
	const(//const高级用法
		b = 1<<(10*iota)  //移位，下面变量全部使用该公式，结果递增
		kb
		mb
		gb
		tb
		pb
	)
	fmt.Println(cpp,java,python,golang)
	fmt.Println(b,kb,mb,gb,tb,pb)
}
func enums2()  {
	const( //const自增属性
		cpp = iota //若直接cpp=1，则const内所有变量均为1
		//自增顺序以const组中变量书写顺序为准（0开始）
		java
		python
		golang
	)
	fmt.Println(cpp,java,python,golang)
}
func main() {
	fmt.Println(filename1)//输出全局常量
	enums1()
	enums2()
}

/* -----------输出-------------- */

    123.txt
	
	enums1()输出：
	0 1 3 5
	1 1024 1048576 1073741824 1099511627776 1125899906842624
	
	enums2()输出：
	0 1 2 3

/* -----------输出-------------- */

循环

在go语言中，仅支持循环关键字for, 没有while循环，while被for的不同写法代替

• 条件循环

n := 0
for n<5{
	n++
	fmt.Printf(n)
}

• 无限循环

n:=0
for {
	...
}

• for循环

for(j:=7; j<=9 ;j++){
	...
}