基础语法
包
- pakcage
- import
- main 包的 main 函数开始
- 没有public, protected 和 private,函数首字母大写类似public, 小写类似private
- 通过文件路径判断包
package main
import (
"fmt"
"math"
)
func main() {
fmt.Println(math.Pi)
}
函数
- 连续2个或多个命名形参类型相同时,除最后一个类型外,其它都可省略
- 多值返回
- 命名返回值
package main
import (
"fmt"
"math"
)
func double(x int) int {
return x * 2
}
func add(x, y int) int {
return x + y
}
func swap(a, b int) (int, int) {
return b, a
}
func swapString(a, b string) (string, string) {
return b, a
}
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
func main() {
fmt.Println(math.Pi)
fmt.Println(double(4))
fmt.Println(add(4, 5))
fmt.Println(swap(6, 7))
fmt.Println(swapString("hello ", "world! "))
fmt.Println(split(16))
}
jiazhao@DESKTOP-AMJKBOJ:~/samples/languages/go/quick_start$ go run .
3.141592653589793
8
9
7 6
world! hello
7 9
jiazhao@DESKTOP-AMJKBOJ:~/samples/languages/go/quick_start$
var变量
- 可以出现在 package 级别,也定义在 func 里。
- 可以一起初始化,也可以不指定类型。
- 简介赋值语句
:=
可以在类型明确的地方代替 var 生命,但不能出现在 func 外。
package main
import (
"fmt"
)
var a, b, c bool
var x, y int = 10, 20
func main() {
var i int
var c, python, java = "nice", true, "yeah"
j := 3
mother, father := "my mother", "my father"
fmt.Println(a, b, c, i)
fmt.Println(c, python, java)
fmt.Println(j)
fmt.Println(mother, father)
}
jiazhao@DESKTOP-AMJKBOJ:~/samples/languages/go/quick_start$ go run .
false false nice 0
nice true yeah
3
my mother my father
jiazhao@DESKTOP-AMJKBOJ:~/samples/languages/go/quick_start$
const变量
类型
- 基本类型
- bool
- string
- int, int8, int16, int32, int64
- uint, uint8, uint32, uint64, uintptr
- byte == uint8
- rune == int32 表示一个unicode
- float32, float64
- complex64, complex128
- 类型自动推导
- 类型转换
- 不同类型转换时需要显示转换
- sting -> int :
- int -> string :
- string -> []byte :
- []byte -> string :
- float64 -> string :
package main
import (
"fmt"
"strconv"
)
func main() {
i := 22
j := float32(i)
k := uint(j)
_a := "43"
a, _ := strconv.Atoi(_a)
_b := 55555
b := strconv.Itoa(_b)
myString := "ABCD"
var myByte []byte = []byte(myString)
var infoByte []byte = []byte{65, 66}
infoString := string(infoByte)
fmt.Printf("%d\r\n", i)
fmt.Printf("%f\r\n", j)
fmt.Printf("%d\r\n", k)
fmt.Println(a)
fmt.Println(b)
fmt.Println(myByte)
fmt.Println(infoString)
}
流程控制
- 只有一种循环结构 for
- for i := 1; i <= 10; i++ {}
- for a < b {} 和其它的while一样
- for {} 死循环
- for index, value := range arrOrMap {}
- if else
- if 可在执行判断前,先执行一个语句 if z := x + y; z < a {}
- switch
- 每个case 之后自带 break, 除非指定 fallthrough,否则不会自动往后执行
- 也可以在执行前,先执行一个语句。 switch v := x + y; v {}
- defer
package main
import (
"fmt"
"time"
)
func main() {
sum := 0
for i := 1; i <= 10; i++ {
sum += i
}
fmt.Println(sum)
j := 1
for j <= 5 {
fmt.Println(j)
j++
}
for {
fmt.Printf(". ")
time.Sleep(time.Duration(1) * time.Second)
}
}
jiazhao@DESKTOP-AMJKBOJ:~/samples/languages/go/quick_start$ go run .
55
1
2
3
4
5
. . . . . .
package main
import (
"fmt"
"runtime"
"time"
)
func add(x, y int) int {
fmt.Println("------add.")
return x + y
}
func main() {
defer fmt.Println("exit..... ", add(2, 3))
fmt.Print("Go run on ")
switch os := runtime.GOOS; os {
case "linux":
fmt.Println("Linux.")
default:
fmt.Printf("%s, ah\r\n", os)
}
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("Good morning.")
case t.Hour() < 17:
fmt.Println("Good afternoon.")
default:
fmt.Println("Good evening.")
}
}
jiazhao@DESKTOP-AMJKBOJ:~/samples/languages/go/quick_start$ go run .
------add.
Go run on Linux.
Good afternoon.
exit..... 5
jiazhao@DESKTOP-AMJKBOJ:~/samples/languages/go/quick_start$
更多类型