Go语言基础语法

特点： 1、高性能、高并发 2、语法简单、学习曲线平缓 3、丰富的标准库 4、完善的工具链 5、静态链接 6、快速编译 7、跨平台 8、垃圾回收

基础语法 --变量 变量类型：字符串（内置类型可以直接用 ‘+’ 拼接）、整数、浮点型、布尔型 变量声明： （1）var name = vaule值 例：var a = "initial" （2） 变量名 : = vaule值 例：f :=float32(e) 常量 ： 把var改为const 在golong中没有确定的类型，会根据使用的是上下文自动锁定类型

--if else if后面没有（） if后直接跟{} 例： package main import "fst" func main(){ if 7%2 == 0{ fat.println("7 is even") }else{ fat.println("7 is odd") } }

--循环 只有for循环
例： package main import "fst" func main(){ for j := 7; j<9;j++{ fat.println(j) } }

--switch switch后的变量名不需要() 例： package main import "fst" func main(){ a :=2; switch a { case 1: fat.println("one") case 2: fat.println("two") case 3,4: fat.println("three or four") default : fat.println("other") } t :=time.Now() switch{ case t.Hour() <12; fat.println("It is before noon") default : fat.println("It is after noon") } }

--数组 例： package main import "fst" func main(){ var a [5]int a[4] = 100 //第4个元素赋值 fat.println(a[4],len(a)) }

--切片 可变长度的数组 package main import "fst" func main(){ s := make([]string, 3) s[0] = "a" s[1] = "b" s[3] = "c" fat.println("get:" , s[2]) //c fat.println("len:" ,len(s)) //3

  s = append{s,"d"}    //追加元素
  fat.println(s)   //{a b c d}

}

--map package main import "fmt" func main(){ m :make(map[string]int) m["one"]=1 m["two"]=2 fmt.Printun(m) //map[one:1 two:2] fmt.Printin(len(m)) //2 fmt.Println(m["one1) //1 fmt.Printin(m["unknow"]) //0 r, ok :m["unknow"] fmt.Println(ir,ok) //io false delete(m,"one") m2 := map[string]int{one":1,"two":2} var m3 = map[string]int{"one":1,"two":2} fmt.Println(m2,m3) }

--函数 --错误处理
// 函数返回多个值时可以起名字，但仅适用于非常简单的函数

package main

import ( "fmt" "math" "reflect" "runtime" )

// 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 // q, _ := div(a, b) // return q // default: // panic("unsupported operation: " + op) // } // }

// Go语言的错误处理方式 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 "/": // return a / b q, _ := div(a, b) return q, nil default: return 0, fmt.Errorf( "unsupported operation: %s", op) } }

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

// 函数式编程 func apply(op func(int, int) int, a, b int) int { p := reflect.ValueOf(op).Pointer() opName := runtime.FuncForPC(p).Name() fmt.Printf("Calling function %s with args: "+ "(%d, %d)", opName, a, b) return op(a, b) }

// 重写Pow // func MyPow(a, b int) int { // return int(math.Pow(float64(a), float64(b))) // }

// 求和，可变参数列表 ...int func sum(numbers ...int) int { s := 0 for i := range numbers { s += numbers[i] } return s }

func main() { fmt.Println(eval(3, 4, "m"))

// 判断错误类型，并不中断程序
if result, err := eval(3, 4, "x"); err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println(result)
}
fmt.Println(eval(12, 4, "/"))
fmt.Println(div(13, 3))
q, r := div(13, 3)
fmt.Println(q, r)

// fmt.Println(apply(MyPow, 3, 4))
fmt.Println(apply((func(a, b int) int {
    return int(math.Pow(
        float64(a), float64(b)))
}), 3, 4))

fmt.Println(sum(1, 2, 3, 4, 5))

}

----指针 // Go语言的指针不能运算 // 参数传递：Go只有值传递一种方式 // 没有引用传递——>通过指针实现类似的效果

package main

import "fmt"

// func swapFalse(a, b int) { // b, a = a, b // }

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

func main() { a, b := 3, 4 // swapFalse(a, b) // fmt.Println(a, b) swap(&a, &b) fmt.Println(a, b) }