第二章、Go-基础语法

2.1.变量定义

（1）第一个程序helloworld

package main

import(

	"fmt"

)

func main() {

	fmt.Println("helloworld")

}

（2）变量的初始值

如果定义一个变量，没有赋值，会有一个默认的初始值

package main

import(

	"fmt"

)

func variableZeroValue(){

	//定义两个变量，没有赋值

	var a int

	var s string

	fmt.Printf("%d %q\n",a,s)   //格式化输出

}

func main() {

	fmt.Println("helloworld")

	variableZeroValue()        //a,s初始值：0 ""

}

（3）变量的定义和赋值　

package main

import(

	"fmt"

)

func variableInitialValue(){

	//变量的定义和赋值

	var a, b int = 3,4

	var s string = "derek"

	fmt.Println(a,b,s)

}

func variableShorter(){

	//用冒号

	d,e,f := 5,false,"zhang"

	fmt.Println(d,e,f)

}

func main() {

	variableInitialValue()     // 3 4 derek

	variableShorter()         // 5 false zhang

}

（4）使用var()集中定义变量

package main

import(

	"fmt"

)

//集中定义变量

var (

	aa = 2

	bb = true

	cc = "jack"

)

func main() {

	fmt.Println(aa,bb,cc)     // 2 true jack

}

总结

使用var关键字：var s1,s2 string = "zhang","derek"
让编译器自动选择类型：var a,b,i,s1,s2 = true,false,3,"hello","world"
使用冒号等于定义变量：a,b,i,s1,s2 := true,false,3,"hello","world",只能在函数内使用

2.2.内建变量类型

（1）类型

bool,string
(u)int,(u)int8,(u)int16,(u)int32,(u)int64,unitptr
byte,rune
float32,float64,complex64,comlex128

（2）强制类型转换

package main

import(

	"fmt"

	"math"

)

func main() {

	var a,b int = 3,4

	// Sqrt必须接收float64类型，先把a,b平方的和转换成float64类型，然后在把结果转换成int类型

	var c int = int(math.Sqrt(float64(a*a + b*b)))

	fmt.Println(c)    //5

}

2.3.常量与枚举

const数值如果不指定类型可以作为各种类型使用，也可以指定类型。

（1）常量的定义

package main

import(

	"fmt"

)

func main() {

	//不指定类型，则可以作为各种类型使用

	const a,b = 3,4

	//指定为string类型，则为指定的类型

	const str string  = "derek"

	//可以放在括号不用每次写const

	const (

		c = false

		d = "jack"

	)

	fmt.Println(a,b,str)     //3 4 derek

	fmt.Println(c,d)         //false jack

}

（2）枚举类型

package main

import(

	"fmt"

)

func main() {

	const (

		java = 0

		python =1

		golang = 2

	)

	fmt.Println(java,python,golang)     //0 1 2

}

（3）使用iota自增值枚举类型

package main

import(

	"fmt"

)

func main() {

	const (

		java = iota    //iota表示这组const自增值

		python

		golang

		javascript

	)

	fmt.Println(java,python,golang,javascript)     //0 1 2 3

}

2.4.条件语句

（1）if语句

if语句条件里面不需要括号

package main

import(

	"fmt"

	"io/ioutil"

)

func main() {

	const filename = "C:\\Users\\86158\\Desktop\\awesomeProject\\src\\abc.txt"

	//ioutil.ReadFile:返回两个值，一个是读出的文件内容，一个是error信息

	//if的条件里可以赋值

	if contents,err := ioutil.ReadFile(filename); err != nil{

		fmt.Println(err)

	}else {

		fmt.Printf("%s\n",contents)

	}

	//if条件里赋值的变量的作用域就在if语句里，像下面这样在if外面访问则报错

	fmt.Println(contents)

}

（2）switch语句

switch后可以没有表达式
switch不需要break
可以直接switch多个条件

package main

import(

	"fmt"

)

func grade(score int) string{

	g := ""

	switch {

	case score < 0 || score > 100:

		//报错信息

		panic(fmt.Sprintf("错误的分数：%d",score))

	case score < 60:

		g = "D"

	case score < 80:

		g = "C"

	case score < 90:

		g = "B"

	case score <= 100:

		g = "A"

 	}

	return g

}

func main() {

	fmt.Println(grade(2))

	fmt.Println(grade(70))

	fmt.Println(grade(83))

	fmt.Println(grade(101))     //panic: 错误的分数：101

}

2.5.循环

for

for的条件里不需要括号
for的条件里可以省略初始条件，结束条件，递增表达式

package main

import "fmt"

func main() {

	sum := 0

	for i :=1; i <= 100; i++{

		sum += i

	}

	fmt.Println(sum)

}

2.6.函数

特点：

返回值类型写在最后面
可返回多个值
函数可以作为参数
没有默认参数和可选参数

（1）基本用法

package main

import "fmt"

//函数名（函数参数，参数类型）返回值类型

func eval(a,b int, op string) int {

	switch op {

	case "+":

		return a + b

	case "-":

		return a - b

	case "*":

		return a * b

	case "/":

		return a / b

	default:

		//错误信息

		panic("unsupport operation: " + op)

	}

}

func main() {

	fmt.Println(eval(3,5,"+"))      //8

	fmt.Println(eval(3,5,"*"))     //15

	fmt.Println(eval(3,5,"gg"))    //panic: unsupport operation: gg

}

（2）两个返回值

package main

import "fmt"

//返回两个值

func div(a,b int) (q,r int){

	return a / b, a % b

}

func main() {

	//接收两个值

	q,r := div(13,3)

	fmt.Println(q,r)       //4 1

}

　只接收一个返回值

package main

import "fmt"

//返回两个值

func div(a,b int) (q,r int){

	return a / b, a % b

}

func main() {

	//如果只想接收一个返回值，可以用“_”

	q,_ := div(13,3)

	fmt.Println(q)       //4

}

2.7.指针

用法

package main

import "fmt"

func main() {

	var a int = 2

	var pa *int = &a

	*pa = 3

	fmt.Println(a)     //3

}

巴特西