Golang基础语法
这是我参与「第五届青训营 」伴学笔记创作活动的第 一 天
1.1 hello world
package main
import (
"fmt"
)
func main() {
fmt.Println("hello world")
}
// go run ./main.go
// hello world
1.2 变量
package main
import (
"fmt"
"math"
)
func main() {
var a = "initial" //字符串
var b, c int = 1, 2 //int
var d = true //bool
var e float64 // float64相当于double
f := float32(e) //float32相当于float
g := a + "foo"
fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
fmt.Println(g) // initialapple
const s string = "constant" 常量，使用const修饰
const h = 500000000
const i = 3e20 / h
fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}
2.3 if-else
- if不需要添加（）
package main
import "fmt"
func main() {
if 7%2 == 0 {
fmt.Println("7 is even")
} else {
fmt.Println("7 is odd")
}
}
2.4 for
- golang只有唯一的一种循环 --for,并且同if一样不需要加（）
package main
import "fmt"
func main() {
i := 1
// 死循环
for {
fmt.Println("loop")
break
}
//一般循环
for j := 7; j < 9; j++ {
fmt.Println(j)
}
for n := 0; n < 5; n++ {
if n%2 == 0 {
continue
}
fmt.Println(n)
}
for i <= 3 {
fmt.Println(i)
i = i + 1
}
}
2.5 switch
- golang中switch并不需要显示添加break跳出执行
- 相比于c/c++，golang的switch可以使用任意变量类型，甚至可以用来取代if-else语句。可以在switch后面不加任何变量，然后在case里面写条件分支。
package main
import (
"fmt"
"time"
)
func main() {
a := 2
switch a {
case 1:
fmt.Println("one")
case 2:
fmt.Println("two")
case 3:
fmt.Println("three")
case 4, 5:
fmt.Println("four or five")
default:
fmt.Println("other")
}
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
}
2.6数组
- golang数组同其他编程语言类似，即为存储同一类型变量的一段连续的内存空间且不可变。
package main
import "fmt"
func main() {
var a [5]int
a[4] = 100
fmt.Println("get:", a[2])
fmt.Println("len:", len(a))
b := [5]int{1, 2, 3, 4, 5}
fmt.Println(b)
var twoD [2][3]int
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
2.7 切片
- 切片不同于数组可以任意更改长度
- 切片原理实际上是他存储一个长度和一个容量，加一个只想一个数组的指针，在执行append操作的时候，如果容量不够的话，会扩容并且返回新的slice
- 切片初始化的时候也可以指定长度
- 可以使用一般for循环或for-range进行遍历
package main
import "fmt"
func main() {
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("get:", s[2]) // c
fmt.Println("len:", len(s)) // 3
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s) // [a b c d e f]
c := make([]string, len(s))
copy(c, s)
fmt.Println(c) // [a b c d e f]
fmt.Println(s[2:5]) // [c d e]
fmt.Println(s[:5]) // [a b c d e]
fmt.Println(s[2:]) // [c d e f]
good := []string{"g", "o", "o", "d"}
fmt.Println(good) // [g o o d]
for i,v := range good {
fmt.Println(good[i]) // g o o d
fmt.Println(v) // g o o d
}
}
2.8 map
- map即为其他编程语言的哈希或字典
- Golang map存储的元素是无序的
- 可以使用range进行遍历
package main
import "fmt"
func main() {
m := make(map[string]int)
m["one"] = 1
m["two"] = 2
fmt.Println(m) // map[one:1 two:2]
fmt.Println(len(m)) // 2
fmt.Println(m["one"]) // 1
fmt.Println(m["unknow"]) // 0
r, ok := m["unknow"]
fmt.Println(r, ok) // 0 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)
for k, v := range m {
fmt.Println(k, v) // b 8; a A
}
for k := range m {
fmt.Println("key", k) // key a; key b
}
2.9 函数
func 函数名 (参数名 参数类型) 返回值类型 {
//函数体
}
- 一般示例
package main
import "fmt"
func add(a int, b int) int {
return a + b
}
func add2(a, b int) int {
return a + b
}
func add3(a, b int) (c int) {
c = a + b
return
}
func exists(m map[string]string, k string) (v string, ok bool) {
v, ok = m[k]
return v, ok
}
func main() {
res := add(1, 2)
fmt.Println(res) // 3
v, ok := exists(map[string]string{"a": "A"}, "a")
fmt.Println(v, ok) // A True
}
2.10 指针
- 相比于c/c++里面的指针，golang指针支持的操作很有限。指针的一个主要用途就是对于传入参数进行修改
package main
import "fmt"
func add2(n int) {
n += 2
}
func add2ptr(n *int) {
*n += 2
}
func main() {
n := 5
add2(n)
fmt.Println(n) // 5
add2ptr(&n)
fmt.Println(n) // 7
}
2.11 结构体
- 结构体是带类型的字段的集合
package main
import "fmt"
type user struct {
name string
password string
}
func main() {
a := user{name: "wang", password: "1024"}
b := user{"wang", "1024"}
c := user{name: "wang"}
c.password = "1024"
var d user
d.name = "wang"
d.password = "1024"
fmt.Println(a, b, c, d) // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
fmt.Println(checkPassword(a, "haha")) // false
fmt.Println(checkPassword2(&a, "haha")) // false
}
func checkPassword(u user, password string) bool {
return u.password == password
}
func checkPassword2(u *user, password string) bool {
return u.password == password
}
2.12 方法
- 在golang里面可以为结构体去定义一些方法。会有一点类似其他语言的类成员函数。
- 在实现结构体的方法的时候也有两种写法，一种是带指针一种是不带指针。带指针的方法可以调用不带指针的方法，反之则不然
package main
import "fmt"
type user struct {
name string
password string
}
func (u user) checkPassword(password string) bool {
return u.password == password
}
func (u *user) resetPassword(password string) {
u.password = password
}
func main() {
a := user{name: "wang", password: "1024"}
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true
}
2.13 错误处理
- 错误处理在拱廊里面符合语言习惯的做法就是使用一个单独的返回值来传递错误信息
- 不同于java自家使用的异常。golang的处理方式，能够很清晰地知道哪个函数返回了错误，并且能用简单的if-else来处理错误
package main
import (
"errors"
"fmt"
)
type user struct {
name string
password string
}
func findUser(users []user, name string) (v *user, err error) {
for _, u := range users {
if u.name == name {
return &u, nil
}
}
return nil, errors.New("not found")
}
func main() {
u, err := findUser([]user{{"wang", "1024"}}, "wang")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(u.name) // wang
if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
fmt.Println(err) // not found
return
} else {
fmt.Println(u.name)
}
}
