Go语言基础

Go语言

• 高性能、高并发
• 语法简单、学习曲线平缓
• 丰富的标准库
• 完善的工具链
• 静态链接
• 快速编译跨平台
• 垃圾回收

package main

import(
"net/http"
)
func main（）{
http.Handle("/",http.Fileserver(http.Dir("."))
http.ListenAndServe(":8080",nil)
}

Go的基础语法

package main
import(
"fmt"
)
func main（）{
fmt.Println("hello world")
)

go run example/01-hello/main.go
hello world
go build example/01-hello/main.go
./main
hello world

//变量声明
package main
import(
"fmt"
"math"
)
func main（）{
var a "initial"
var b,c int = 1,2
var d = true
var e float64
f := float32(e)
g:= a + "foo"
fmt.Println(a,b,c,d,e,f)
fmt.Println(g)
const s string = "constant"
const h=500000000
const i 3e20 / h
fmt.Println(s,h,i,math.Sin(h),math.sin(i))
//if else
package main
import "fmt"
func main（）{
if 7%2 == 0{
fmt.Println("7 is even")
else{
fmt.Println("7 is odd")
1f8%4==0{
fmt.Println("8 is divisible by 4")
}
if num :9;num 0{
fmt.Println(num,"is negative")
}
else if num 10{
fmt.Println(num,"has 1 digit")
}
else{
fmt.Println(num,"has multiple digits")
}
}

Go只有for循环

package main
import "fmt"
func main（）{
i := 1 
for{
fmt.Println("Loop")
break
)
for j:=7;j<9;j++ {
fmt.Println(j)
}
forn:=0;n<5;n++{
ifn%2==0{
continue
}
fmt.Println(n)
}
for i <=3{
fmt.Println(i)
1=1+1
}

Switch分支结构

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")
}
}

数组

package main
import "fmt"
func main（）{
var a [5]int
a[4]=100
fmt.Println(a[4],len(a))
b:=[5]int{1,2,3,4,5}
fmt.Println(b)
var twoD [2][3]int
fori:=0;i<2;i+{
f0rj:=0;j<3;j+
{
twoD[i][j]=i+j
}
}
fmt.Println("2d:"twoD)
}

切片

package matn
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)
c :make([]string,len(s))
copy(c,s)
fmt.Println(c)//a b c d e f
fmt.Println(s[2:5])
fmt.Println(s[:5])
fmt.Println(s[2:])
good :=[]string{"g","o","o","d"}
fmt.Println(good)
}

MAP

package main
import "fmt"
func main（）{
m make(map[string]int)
m["one"]=1
m["two"]=2
fmt.Println(m)

fmt.Println(len(m))

fmt.Println(m["one"])

fmt.Println(m["unknow"])/0
r,ok:=m["unknow"]
fmt.Println(r,ok)
delete(m,"one")
m2 :map[string]int{"one":1,"two":2}
var m3 map[string]int{"one":1,"two":2}
fmt.Println(m2,m3)
}

range

package main
import "fmt"
func main（）{
nums:=[]int{2,3,4}
sum :0
for i,num :range nums{
sum +num
if num ==2{
fmt.Println("index:"i,"num:"num)
fmt.Println(sum)
m :map[string]string{"a":"A","b":"B"}
for k,v :range m
fmt.Println(k,v)
for k :range m{
fmt.Println("key",k)//key a;key b
}

函数

package main
import "fmt"
func add(a int,b int)int
return a +b
}
func add2(a,b int)int
return a +b
}
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
}

指针

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
}

结构体

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)
fmt.Println(checkPassword(a,"haha"))//false
fmt.Println(checkPassword2(&a,"haha"))//false
func checkPassword(u user,password string)bool{
return u.password ==password
}b 
func checkPassword2(u *user,password string)bool{
return u.password =password
}

错误处理

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)
}

字符串操作

package main
import
"fmt"
"strings"
)
func main（）{
a :"hello"
fmt.Println(strings.Contains(a,"Il"))
//true
fmt.Println(strings.Count(a,"I"))
/2
fmt.Println(strings.HasPrefix(a,"he"))
/true
fmt.Println(strings.HasSuffix(a,"llo"))
/true
fmt.Println(strings.Index(a,"Il"))
//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(lep(b))//6
)

字符串格式化

package main
import "fmt"
type point struct
x,y int
}
func main（）{
s :"hello"
n:=123
p :point{1,2}
fmt.Println(s,n)//hello 123
fmt.Println(p)
//(12}
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
}

JSON

package main
import
"encoding/json"
"fmt"
type userInfo struct
Name string
Age
int json:"age"
Hobby[]string
func main（）{
a :userInfo{Name:"wang",Age:18,Hobby:[]string{"Golang","TypeScript"})
buf,err :json.Marshal(a)
if err !nil{
panic(err)
fmt.Println(buf)
/1123347897..1
fmt.Println(string(buf))//{"Name":"wang","age":18,"Hobby":/"Golang","TypeScript")
buf,err json.MarshalIndent(a,"""\t")
if err !nil
panic(err)
fmt.Println(string(buf )
var b userInfo
err json.Unmarshal(buf,&b)
if err !nil{
panic(err)
fmt.Printf("%#v\n",b)//main.userInfo(Name:"wang",Age:18,Hobby:[]string("Golang","TypeScript")}