go语言基础(一)

一、变量定义
变量命名通过 var+参数名+类型即可

var a int = 1
var s string = "b"
var b true

还可以多个变量一起定义，且可以是不同的类型，只要是逗号分隔即可

var a,b,c,d :=3,4,true,"def"

甚至连var也可以省掉，依靠解释器自己分辨不同的类型

a:=1
s:="str"
b:=true

常量可以使用const关键字

const fileName = "abc.txt"
const a,b=3,4

当然所有的变量或常量都可以统一进行定义

var (
    aa = 3
    ss = "kkk"
    bb = true
)
const(
    cpp = iota
    java
    python
    golang
)

二、条件语句
以if为例，使用如下

a:=3
if a==3 {
    //dosomething
}

if里面是可以提前运行函数的，以读取文件，并判断文件是否存在为例

const filename  = "abcd.txt"
if contents, err:=ioutil.ReadFile(filename);err!=nil{
    fmt.Print(err)
}else {
    fmt.Printf("%s\n",contents)
}

三、循环
先介绍for，for没有括号，格式为for 初始;条件;遍历语句，eg:

for i:=0;i<100;i++{
    fmt.Println(i)
}

如果没有初始和遍历语句，只有条件语句，那么可以省略分号，功能就和while一致了(反正go也没有while关键字),eg:

i:=0
for i<100{
    fmt.Println(i)
    i++
}

稍微复杂一点，以扫描文件io，并读取文件内容为例

func printfile(filename string){
    file,err :=os.Open(filename)
    if err!=nil{
        panic(err)
    }
    scanner:=bufio.NewScanner(file)
    for scanner.Scan(){
        fmt.Println(scanner.Text())
    }
}

需要注意的是，如果条件也没有，直接就一个for结构，那么就是死循环，go语言支持这样的语法的，方便多线程的原因，go语言也会在很多情况用这种用法。eg:

for{
    fmt.Println("abc")
}

四、函数
go语言的函数格式为 func 函数名(参数 参数类型) 返回值{}，eg:

func add(a int, b int) int {
    return a+b
}

如果没有返回值，相当于java中的返回void那么可以不写返回值，eg:

func add(a int, b int) {
    fmt.Println(a+b)
}

并且如果想要返回多个值，go语言也支持(知道这一点的时候我都惊了)，eg:

func div(a int,b int) (int, int)  {
    return a/b, a%b
}

当然，多个返回值很多时候是用来返回多余的错误信息，以swich为例,eg:

func eval(a,b int, op string) (int, error) {
    switch op {
    case "+":
        return a+b, nil
    case "-":
        return a-b, nil
    case "*":
        return a*b, nil
    case "/":
        q,_:=div(a,b)
        return q, nil
    default:
        return 0, fmt.Errorf(
            "unsupported operation: %s" + op)
    }
}

如果参数格式相同，那么可以像定义变量一样(a,b int)，去定义参数或者返回值，eg:

func div(a,b int) (q, r int)  {
    return a/b, a%b
}

go语言也支持函数式编程

func apply(op func(int, int) int,c,d int) int{
    p:=reflect.ValueOf(op).Pointer()
    opName:=runtime.FuncForPC(p).Name()
    fmt.Printf("Calling function %s with args (%d, %d)",opName, c, d)
    return op(c,d)
}

func pow(a,b int) int {
    return int(math.Pow(float64(a),float64(b)))
}

或者是这样写

func apply(op func(int, int) int,c,d int) int{
    p:=reflect.ValueOf(op).Pointer()
    opName:=runtime.FuncForPC(p).Name()
    fmt.Printf("Calling function %s with args (%d, %d)",opName, c, d)
    return op(c,d)
}

func main() {
    fmt.Println(apply(func(i int, i1 int) int {
        return int(math.Pow(float64(i),float64(i1)))
    },1,2))
}

五、指针
go语言支持指针，首先举个例子，下面的程序结果运行为1,2。也就是说是值传递。

func swap(a, b int){
    a,b=b,a
}

func main() {
    a,b:=1,2
    swap(a,b)
    fmt.Println(a,b)
}

如果想要使用引用传递，那就要用到指针，eg:

func swap(a, b *int){
    *a,*b=*b,*a
}
func main() {
    a,b:=1,2
    swap(&a,&b)
    fmt.Println(a,b)
}

当然，不想使用指针，使用返回值进行控制也可以，eg:

func swap(a, b int) (int,int){
    a,b=b,a
    return a,b
}
func main() {
    a,b:=1,2
    a,b=swap(a,b)
    fmt.Println(a,b)
}