study_go_day1

package main

import (

"fmt"

"io/ioutil"

"math"

"math/cmplx"

)

//函数外定义变量,必须使用关键字作为开头，不能使用:=定义变量，作用域在包的内部

var aa  =3

var bb  ="ddd"

//可以使用var ()  来定义多个变量

var (

ss ="tt"

dd =true

)

//不初始化，编译器自己赋空值

func variableZeroValue()  {

var a int

var s  string

fmt.Printf("%d %q\n",a,s)

}

//初始化

func variableInitialValue()  {

var  a,bint  =2,4

var sstring  ="adc"

fmt.Println(a,b,s)

}

//类型推断

func variableTypeDeduction()  {

var a,b,c,d  =3,4,true,"dfg"

fmt.Println(a,b,c,d)

}

//使用:= 定义变量的变量不能在使用:=赋值,要使用=赋值，并且类型一致

func variableShorter()  {

a,b,c,d :="a",1,true,4.9

a ="字符串"

fmt.Println(a,b,c,d)

}

/**内建变量

bool string

(u)int (u)int8 (u)int16 (u)int32 (u)int64 uintptr指针

byte:8位 int8的别名

rune:go语言字符型 32位 int32的别名 4字节

float32 float64 complex64 complex128

*/

//欧拉公式

func euler()  {

//复数

//c := 3 + 4i

//fmt.Println(cmplx.Abs(c))

//complex64 实部和虚部是float32 complex128 实部和虚部是float64 导致值算出来不等于0

//fmt.Println(cmplx.Pow(math.E,1i *math.Pi) + 1)

//fmt.Println(cmplx.Exp(1i *math.Pi) + 1)

fmt.Printf("%.3f\n",cmplx.Exp(1i * math.Pi) +1)

}

//go语言强制类型转换

func triangle()  {

var  a,bint  =3,4

var  c int

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

fmt.Println(c)

}

//常量的定义,不用大写，可以指定类型，也可以不指定,不指定类型a,b的类型是不确定的

//可以定义在包内部，所有函数可以使用，const数值可以作为各种类型使用

func consts()  {

const(

filename ="gfgf.text"

a,b =3,4

)

var c int

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

fmt.Println(filename,c)

}

//枚举 iota表示自增值 “_”表示跳过  << 左移

func enums()  {

const (

cpp =iota

_

python

golang

js

)

fmt.Println(cpp,python,golang,js)

//b,kb,mb,gb,tb,pb

const (

b =1 << (10 *iota)

kb

mb

gb

tb

pb

)

fmt.Println(b,kb,mb,gb,tb,pb)

}

//条件语句里可以赋值，值的范围在条件语句里

func iff()  {

const filename  ="abc.txt"

//读取文件函数 ioutil.ReadFile()

//

//contents,err := ioutil.ReadFile(filename)

//if err != nil {

//  fmt.Println(err)

//} else {

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

//}

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

fmt.Println(err)

}else{

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

}

}

//switch 不需要加break 会自动加 除非使用fallthrough

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

var  result int

switch op {

case "+":

result = a + b

case "-":

result = a - b

case "*":

result = a * b

case "/":

result = a / b

default:

panic("unsupported operator:" + op)//报错

}

return  result;

}

//switch后面可以不跟表达式，在case里跟判断语句

func grade(score int) string  {

g :=""

switch  {

case score <0 || score >100:

panic(fmt.Sprintf("wrong score: %d",score))

case score <60:

g ="F"

case score <80:

g ="C"

case score <90:

g ="B"

case score <=100:

g ="A"

}

return  g

}

func main() {

fmt.Println("hlleo go")

//

variableZeroValue()

//

variableInitialValue()

//

variableTypeDeduction()

//

variableShorter()

//

fmt.Println(aa,bb,dd,ss)

//

euler()

//

triangle()

//

consts()

//

enums()

//

iff()

//

fmt.Println(

eval(10,2,"-"),

eval(10,2,"+"),

eval(10,2,"*"),

eval(10,2,"/"),

)

//

fmt.Println(grade(0))

fmt.Println(grade(59))

fmt.Println(grade(70))

fmt.Println(grade(90))

fmt.Println(grade(100))

fmt.Println(grade(101))

}