Go语言基础语法学习笔记
目录
1. 变量定义
2.变量类型
3.常量和枚举
4.条件
5.循环
6.函数
7.指针
今天稍微转化一下思路，看一下一直大热的Go语言到底有什么魅力，初探门径，还是从学习语法开始，整理了七段基础代码，再次不用详述，大家应该都能看懂：
1. 变量定义
package main
import "fmt"
func variableZeroValue() {
var a int
var s string
fmt.Printf("%d %q\n", a, s)
}
func variableInitialValue() {
var a, b int = 3, 4
var s string = "a,b,c"
fmt.Println(a,s,b)
}
//go中一个变量定义了，必须要使用，赋不赋值都可以
func variableTypeDetection() {
var a,b,v,s = 1,true,'1','s'
fmt.Println(a,b,v,s)
}
//go中允许不同类型的变量定义的
func variableShorter() {
a,b,c :=3,'a',false
fmt.Println(a,b,c)
}
//相对于上面，这种方式更加简洁，推荐使用，仅仅在函数内
var aa = 3
var sd = "a"
//没有全局变量的说法，只是作用域包内部，也可以这样写：
var (
aaa = 3
sdd = 'a'
)
//因为go中""和''是不一样的，因此字符串一定要使用""
func main() {
fmt.Println("Hello world")
variableZeroValue()
variableInitialValue()
fmt.Printf("%q\n", sd)
fmt.Println(sd, sdd, aaa)
}
2.变量类型
package main
import (
"fmt"
"math"
"math/cmplx"
)
func euler(){
//c := 3 + 4i
fmt.Println(
//cmplx.Pow(math.E, 1i*math.Pi) + 1)
cmplx.Exp(1i*math.Pi)+1)
}
func triangle() {
a,b:=3,4
fmt.Println(math.Sqrt(float64(a*a + b*b)))
}
func main() {
euler()
triangle()
}
3.常量和枚举
package main
import (
"fmt"
"math"
)
func consts() {
const (
filename = "a.py"
a, b float64 = 3, 4
)
var c int
c = int(math.Sqrt(a*a + b*b))
println(c)
}
//go语言中大小写是有特殊含义的，因此不需要把常量一定小写
//go中的常量可以当作任何类型使用，当然也可以设置类型
func enums() {
const (
cpp = iota
java
python
golang
javascript
)
const(
b = 1 << (10*iota)
kb
mb
hb
)
fmt.Println(cpp, java, python, golang, javascript)
fmt.Println(b,kb,mb,hb)
}
//枚举类型
func main() {
consts()
enums()
}
4.条件
package main
import (
"fmt"
"io/ioutil"
)
func grade(score int) string {
g := "C"
switch {
case score <0 || score > 100:
panic(fmt.Sprintf("wrong answer:%d", score))
case score <60:
g = "D"
case score <90:
g = "B"
case score<100:
g = "A"
}
return g
}
func main() {
const filename = "abc.txt"
if contents, err := ioutil.ReadFile(filename); err != nil {
//if 可以赋值多个语句
fmt.Println(err)
} else {
fmt.Printf("%s\n", contents)
}
//fmt.Println(contents)
// 因为是在if中定义的contents，生存期也仅仅限于if的block中
fmt.Println(
grade(0),
grade(23),
grade(66),
grade(99))
// panic可以让之直接报错
}
5.循环
package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func convertToBin(n int) string {
result := ""
for ;n>0;n/=2{
//条件可以省略，同时这里是没有括号的
lsb:=n%2
result = strconv.Itoa(lsb)+result
}
return result
}
func readFile(filename string){
file, erros := os.Open(filename)
if erros!= nil{
panic(erros)
}
scanner := bufio.NewScanner(file)
for scanner.Scan(){
fmt.Println(scanner.Text())
}
}
//一行一行的读取
func forever() {
for{
fmt.Println("abc")
}
}
//这样就是死循环，这在并发编程中经常使用，没有while
func main() {
fmt.Println(
convertToBin(5),
convertToBin(13),
)
readFile("abc.txt")
}
6.函数
package main
import (
"fmt"
"math"
"reflect"
"runtime"
)
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,_:= divide(a,b)
return q,nil
default:
return 0,fmt.Errorf(
"unsupprted operation: %s", op)
}
}
func divide(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.Println("func name: ", opName)
return op(a,b)
}
func pow(a,b int) int {
return int(math.Pow(float64(a),float64(b)))
}
//可变参数列表
//和python语法很像
func sum(numbers ...int) int {
s:=0
for i := range numbers{
s+=numbers[i]
}
return s
}
func main() {
if result,err := eval(3,4,"^");err!=nil{
fmt.Println("error: ", err)
}else{
fmt.Println(result)
}
//fmt.Println(eval(3,5,"&"))
q,r := divide(12,7)
fmt.Println(q,r)
//fmt.Println(apply(pow,3,4))
fmt.Println(apply(
func(a int, b int) int {
return int(math.Pow(
float64(a),float64(b)))
},3,4))
fmt.Println(sum(1,2,3,4,5))
}
//函数式编程，函数是一级单位7.指针
/*
@Author: Asen Wang @Date: 2019/7/18 21:28
@Contact Email: [email protected]
*/
//值传递和引用传递，python中大部分我们自定义的都是引用传递，但是cpp两者是专门区分的，明显的：a,b=b,a
//go中只有值传递！
package main
import "fmt"
func swap(a,b int) (int, int) {
b,a = a,b
return b, a
}
//值传递，打印出的依然还是3，5
func swapRight(a, b *int) {
*b,*a = *a,*b
}
func main() {
fmt.Println(swap(3,5))
a,b:=3,6
swapRight(&a,&b)
fmt.Println(a,b)
}