这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记，也是作为自己学习的一个记录吧，初次撰写，欢迎大家提出意见，后续也会不断补充扩展内容。
话不多说，直接进入正文：
go语言的基本的实现框架如下
package main
import (
"fmt" //导入的包名
)
func main(){ //注意！go语言的大括号一定与函数名同一行
fmt.Println("hello go!")
}
其他基本上都是在上述代码的扩展与补充
变量定义
1.四种定义变量的语法
var a int //默认初始值为0
var b int = 1
var c = 2
d := 3 //最常用的定义方式
需要注意的是第四种方法不能声明全局变量
2.声明多个变量的语法
var a,b int = 1,2 //a=1,b=2
var c,d =3,"test" //c=3,d="test"
var(
e int = 4
d bool = true
)
3.定义指针,基本类似于定义变量，加个*
var a *int
4.定义常量
const a int =1
使用const定义枚举类型
const(
//关键字iota，每行的iota都会+1，第一行的iota值为0
//注意：iota只配合const()使用
a,b=iota+1,iota+2 //a=0+1,b=0+2-----iota=0
c,d=iota*2,iota*3 //c=1*2,d=1*3-----iota=1
)
5.定义数组
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
}
}
6.切片
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
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]
7.map，没有顺序，遍历的顺序是随机的
m := make(map[string]int) //string为key，int为value的类型
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)
8.定义结构体
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
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true
}
func checkPassword(u user, password string) bool {
return u.password == password
}
func checkPassword2(u *user, password string) bool {
return u.password == password
}
func (u user) checkPassword3(password string) bool {//使用这种方法可以为结构体添加方法，然后结构体可以通过.操作符调用该方法
return u.password == password
}
func (u *user) resetPassword4(password string) {
u.password = password
}
9.字符串方法
a := "hello"
fmt.Println(strings.Contains(a, "ll")) // true
fmt.Println(strings.Count(a, "l")) // 2
fmt.Println(strings.HasPrefix(a, "he")) // true
fmt.Println(strings.HasSuffix(a, "llo")) // true
fmt.Println(strings.Index(a, "ll")) // 2
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
fmt.Println(strings.Repeat(a, 2)) // hellohello
fmt.Println(strings.Replace(a, "e", "E", -1)) // hEllo
fmt.Println(strings.Split("a-b-c", "-")) // [a b c]
fmt.Println(strings.ToLower(a)) // hello
fmt.Println(strings.ToUpper(a)) // HELLO
fmt.Println(len(a)) // 5
b := "你好"
fmt.Println(len(b)) // 6
10.字符串格式化输出
func main() {
s := "hello"
n := 123
p := point{1, 2}
fmt.Println(s, n) // hello 123
fmt.Println(p) // {1 2}
//不同于c语言，全部都可以用%v
fmt.Printf("s=%v\n", s) // s=hello
fmt.Printf("n=%v\n", n) // n=123
fmt.Printf("p=%v\n", p) // p={1 2}
fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}
f := 3.141592653
fmt.Println(f) // 3.141592653
fmt.Printf("%.2f\n", f) // 3.14
}
循环控制语句
1.if else的使用
if 7%2==0 { //注意表达式不用括号，加上后会被自动去掉；后面必须跟上{}，不能省略
fmt.Println("7 is even")
} else{
fmt.Println("7 is odd")
}
2.golang只有for循环，总体风格类似于c语言
for i:=0;i<5;i++ { //其中三个条件都可以省略
...
//循环里同样类似于c++可以用break和continue控制
}
3.switch语句，与c语言不同的是，即使不显示加上break也不会继续向下执行
a：=2
switch a{ //变量名同样不需要括号
case 1：
fmt.Println（"one"）
case 2:
fmt.Printin（"two"）
case3:
fmt.Printin（"three"）
case 4,5:
fmt.Println（"four or five"）
default:
fmt.Printin（"other"）
}
4.range
nums := []int{2, 3, 4}
sum := 0
for i, num := range nums { //range遍历数组返回两个值，一个是索引i,另一个是值num
//不需要索引可以用_替代，作为匿名
sum += num
if num == 2 {
fmt.Println("index:", i, "num:", num) // index: 0 num: 2
}
}
fmt.Println(sum) // 9
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m { //range遍历map返回两个值，一个是key,另一个是value
fmt.Println(k, v) // b 8; a A
}
for k := range m {
fmt.Println("key", k) // key a; key b
}
函数
1.func 函数名（参数名1 参数类型1，参数名2 参数类型2，...）（返回参数名1 返回值类型1，返回参数名1返回值类型2，...）{ 函数体 }
其中返回参数名可以省略
func funcname(a int,b int)(int,int){
...
return a,b
}
//有返回参数名时可以直接写return
//调用时 funcname(a,&b)
func funcname(a int,b *int)(r1 int,r2 int){
r1=a
r2=*b
return
}
2.变参函数
使用 ...作为标记
package main import"fmt"
func sum(nums ...int){
fmt. Print(nums,"")
total:=8
for, num:=range nums{
total+=num
}
fmt. Println(total)
}
func main(){
sum(1,2) sum(1,2,3)
nums:=[] int{1,2,3,4}
sum(nums...)
}
其他
数字解析
import (
"fmt"
"strconv"
)
func main() {
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
n, _ := strconv.ParseInt("111", 10, 64)//（字符，进制，位数）
fmt.Println(n) // 111
n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096
n2, _ := strconv.Atoi("123")
fmt.Println(n2) // 123
n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}
defer关键字 使用defer关键字可以修饰函数或者其他语句，那么这个语句将会在函数最后结束（即return之后）执行，如果有多个defer那么就会安装逆序执行（先入后出）
