GO 基础加实战案例
走进 GO 语言基础
Hello World
package main
import "fmt"
func main(){
fmt.Println("Hello World!")
}
变量
package main
import (
"fmt"
)
func main(){
var a = "goland"
var b,c = "hello",123
var d = true
var e float64
e = 1.23
f := a+"nihao"
fmt.Println(a,b,c,d,e) // goland hello 123 true 1.23
fmt.Println(f) // golandnihao
const s = 7000
const h string = "constant"
fmt.Println(s,h)// 7000 constant
}
if else
package main
import "fmt"
func main(){
if 8%2==0{
fmt.Println("8 是偶数")
}
if num := 7;num <0{
fmt.Println(num+num)
}else{
fmt.Println(num)
}
if i := 0; i<0 {
fmt.Println(i+10)
}else if i > 10{
fmt.Println(i)
}else {
fmt.Println(i+3)
}
}
循环
package main
import "fmt"
func main(){
for i:=0;i<3;i++{
fmt.Println(i)
}
for i:=0;i<20;i++{
if i%3 == 0{
continue // 继续循环
}
fmt.Println(i)
}
for { // for后面啥也不加,死循环
fmt.Println("Hello1")
break // 停止循环
}
}
}
swich
package main
import (
"fmt"
"time"
)
func main(){
a := 2
switch a{
case 1:
fmt.Println("one")
// 不需要加 break
case 2:
fmt.Println("two")
case 3,4:
fmt.Println("three or four")
default:
fmt.Println("other")
}
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("it is before noon")
case t.Hour() >12:
fmt.Println("it is after noon")
}
}
数组
数组是一个具有编号且长度固定的元素序列
package main
import "fmt"
func main(){
var a [5]int
a[4] = 4
fmt.Println(a[4]) // 4
b := []string{"Hi","Hello","Goland"}
fmt.Println(b[2],len(b)) // Goland 3
fmt.Println(b) // [Hi Hello Goland]
var c [3][4]int
num := 1
for i:=0;i<len(c);i++{
for j:=0;j<len(c[0]);j++{
c[i][j] = num
num++
}
}
fmt.Println(c) // [ [1 2 3 4] [5 6 7 8] [9 10 11 12] ]
}
切片(slice)
切片不同于数组可以任意更改长度,通过make来常见一个切片,可以像数组一样取值,使用append来追加元素,使用append时必须把append的结果赋值给原数组。
slice原理实际上是存储了一个长度和一个容量,加一个指向数组的指针,在你执行append操作时如果容量不够,会扩容并且返回新的slice。
package main
import "fmt"
func main(){
s := make([]string,3)
s[0]="a"
s[1]="b"
s[2]="c"
fmt.Println(s[0]) // a
fmt.Println(s,len(s)) // [a b c] 3
s = append(s, "d")
s = append(s,"e","f")
fmt.Println(s) // [a b c d e f]
s2 := make([]string,len(s))
copy(s2,s) // 复制切片
fmt.Println(s2,len(s2)) // [a b c d e f] 6
fmt.Println(s[:3]) // 左闭右开 [a b c]
fmt.Println(s[2:4]) // [c d]
fmt.Println(s[3:]) // [d e f]
s3 := []int{1,2,3,4,5}
fmt.Println(s3) // [1 2 3 4 5]
}
map
map 实际过程中最常用的数据结构
用make来创建map时需要两个类型,一个key一个value,我们可以从里面取出键值对,也可以用delete删除
map是无序的,遍历时按照随机顺序
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["three"]) // 0 没有对应的键值对
r,ok := m["three"] // r接收value,ok 判断是否有该键值对
fmt.Println(r,ok) // 0 false
delete(m,"one")
fmt.Println(m) // map[two:2]
m2 := map[int]string{1:"one",2:"two"}
var m3 = map[int]string{1:"one",2:"two"}
fmt.Println(m2,m3) // map[1:one 2:two] map[1:one 2:two]
}
range
对于一个 slice 和 map 来说,我们可以用range来快速遍历。range 遍历时返回两个值,一个是索引,一个是对应位置的值。如果不需要索引可以用下划线忽略。
package main
import "fmt"
func main(){
nums := []int{1,2,3,4,5}
sum := 0
for num := range nums{
sum += num
if num == 3{
fmt.Println(num) // 3
}
}
fmt.Println(sum) // 10
m := map[string]string{"A":"a","B":"b"}
for k,v := range m{
fmt.Println(k,v) // A a
// B b
}
for _,v := range m{
fmt.Println(v) // a
// b
}
}
函数
package main
import "fmt"
func add(a,b int)int{
sum := a+b
return sum
}
func exists(m map[string]int, k string ) (v int, ok bool){
r,ok := m[k]
return r,ok
}
func main(){
sum := add(7,9)
fmt.Println(sum) // 16
m := map[string]int{"one": 1, "two": 2}
value,ok := exists(m,"two")
fmt.Println(value,ok) // 2 true
value,ok = exists(m,"three")
fmt.Println(value,ok) // 0 false
}
指针
package main
import "fmt"
func add1(n int){
n += 2
fmt.Println(n) // 5
}
func add2(n *int){
*n += 2
fmt.Println(n) // 5
}
func main(){
n := 3
add1(n)
fmt.Println(n) // 3
add2(&n)
fmt.Println(n) // 5
}
结构体
package main
import "fmt"
type user struct {
name string
age string
}
func checkAge(u user,age string)bool{
return u.age == age
}
func checkAge2(u *user,age string){
if u.age != age {
u.age = age
}
}
func main(){
pika := user{name:"pika",age:"3"}
fmt.Println(pika) // {pika 3}
var duola user
duola.name = "duola"
duola.age = "2"
fmt.Println(duola.name) // duola
fmt.Println(checkAge(pika,"2")) // false
checkAge2(&duola,"1")
fmt.Println(duola) // {duola 1}
}
结构体方法
package main
import "fmt"
type user struct {
name string
password string
}
func (u user)checkAge(password string)bool{
return u.password == password
}
func (u *user)rePassword(newPassword string){
u.password = newPassword
}
func main(){
pika := user{name:"pika",password:"123"}
fmt.Println(pika) // {pika 123}
fmt.Println(pika.checkAge("000")) // false
pika.rePassword("666")
fmt.Println(pika) // {pika 666}
}
错误处理
错误处理在go语言里面符合语言习惯的就是使用一个单独的返回值来传递错误信息
在函数里面,可以在函数的返回值类型里面加一个 error ,就代表这个函数可能会返回错误
package main
import (
"errors"
"fmt"
)
type user struct {
name string
password string
}
func findUser(users []user,name string)(u *user,err error){
for _,user := range users{
if user.name == name{
return &user,nil
}
}
return nil,errors.New("not found")
}
func main(){
pika := user{name:"pika",password:"123"}
duola := user{name:"duola",password:"123"}
haibao := user{name:"haibao",password:"123"}
users := []user{pika,duola,haibao}
u,err := findUser(users,"pika")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(u) // &{pika 123}
if u,err := findUser(users,"haha");err!=nil{
fmt.Println(err) // not found
return
}else {
fmt.Println(u)
}
}
字符串操作
contains 判断一个字符串里面是否包含另一个字符,count 字符串计数,index 查找某个字符串的位置,replace 替换字符串,repeat重复多个字符串,join 连接多个字符串
package main
import (
"fmt"
"strings"
)
func main (){
s := "hello"
fmt.Println(strings.Contains(s,"lo")) // true
fmt.Println(strings.Count(s,"o")) // 1
fmt.Println(strings.Index(s,"l")) // 2
fmt.Println(strings.Replace(s,"e","E",-1)) // hEllo
fmt.Println(strings.Repeat(s,2)) // hellohello
fmt.Println(strings.Join([]string{"he" ,"llo",},"-")) // he-llo
}
字符串格式化
package main
import (
"fmt"
)
func main (){
s := "hello"
d := 123
f := []int{1,2,3}
g := map[string]int{"one":1,"two":2}
// Printf 格式化输出
// %v 可以输出任意类型
fmt.Printf("s=%v\n",s) // s=hello
fmt.Printf("d=%v\n",d) // d=123
fmt.Printf("f=%v\n",f) // f=[1 2 3]
fmt.Printf("g=%v\n",g) // g=map[one:1 two:2]
fmt.Printf("g=%+v\n",g) // g=map[one:1 two:2]
fmt.Printf("g=%#v\n",g) // g=map[string]int{"one":1, "two":2}
h := 1.2345679
fmt.Println(h) // 1.2345679
fmt.Printf("%.2f\n",h) // 1.23
}
JOSN处理
JSON编码是将Golang中的数据结构转换为JSON格式,而JSON解码则是将JSON格式的数据转换为Golang中的数据结构。
JSON格式具有以下几个基本规则:
- JSON数据必须是键值对的形式。
- 数据由逗号分隔,并且必须被大括号{}或中括号[]括起来。
- 键必须包含在双引号""中,值可以是字符串、数字、布尔值、数组或对象。
对于一个结构体,只要保证每个字段的第一个字母是大写,也就是公开字段,那么这个结构体就能用 json.marshaler 去序列化,变成一个JSON的字符串。
序列化之后的字符也能够用 json.Unmarshal 去反序列化一个空的变量里面。
package main
import (
"encoding/json"
"fmt"
)
type user struct {
Name string
Age string
Hobby []string
}
func main (){
pika := user{Name: "pika",Age: "3",Hobby: []string{"sing","dance","pingpong"}}
pikajson,err := json.Marshal(pika)
if err != nil{
fmt.Println(err)
return
}
fmt.Println(pikajson) // [123 34 78 97 109 101 34 58 34...]
fmt.Println(string(pikajson)) // pika 是 []byte 类型,在这里转换为string类型
// {"Name":"pika","Age":"3","Hobby":["sing","dance","pingpong"]}pika
var result user
err = json.Unmarshal(pikajson,&result)
if err != nil{
fmt.Println(err)
return
}
fmt.Printf("%#v\n",result)
// main.user{Name:"pika", Age:"3", Hobby:[]string{"sing", "dance", "pingpong"}}
}
时间处理
最常用的就是用 time.now() 来获取当前时间,然后也可以用 time.data 去构造一个带区的时间。也能用点 sub 去对两个时间进行减法,得到一个时间段。时间戳用 .UNIX 来获取。
package main
import (
"fmt"
"time"
)
func main (){
now := time.Now()
fmt.Println(now) // 2023-05-13 10:26:25.5765925 +0800 CST m=+0.002576101
t1 := time.Date(2023,5,10,13,14,0,0,time.UTC)
t2 := time.Date(2023,5,10,14,15,0,0,time.UTC)
fmt.Println(t1) // 2023-05-10 13:14:00 +0000 UTC
fmt.Println(t1.Year(),t1.Month(),t1.Day(),t1.Hour(),t1.Minute(),t1.Second())
// 2023 May 10 13 14 0
fmt.Println(t1.Format("2006-01-02 15:04:05")) // 2023-05-10 13:14:00
diff := t2.Sub(t1)
fmt.Println(diff) // 1h1m0s
fmt.Println(diff.Minutes(),diff.Seconds()) // 61 3660
// 时间戳
fmt.Println(now.Unix()) // 1683944893
}
GO语言实战案例
猜谜游戏
bufio.NewReader(os.Stdin) // 读取文件内容
reader.ReadString('\n') // 读取一行内容
strings.TrimSuffix(reader, "\n") // 去掉换行符
strconv.Atoi() // 将string 转换为 int
package main
import (
"bufio"
"fmt"
"math/rand"
"os"
"strconv"
"strings"
"time"
)
// 猜谜游戏介绍
func main() {
maxNum := 100
rand.Seed(time.Now().UnixNano()) // 利用时间戳来设置随机数种子
secretNumber := rand.Intn(maxNum)
fmt.Println("Please input your guess number")
reader := bufio.NewReader(os.Stdin) // 读取文件内容 reader : &{[0 0 0 0 ...0 0 0 0]
// 设置循环可以多次输入猜测数字
for {
input, err := reader.ReadString('\n') // 读取一行内容
if err != nil {
fmt.Println(err)
return
}
input = strings.TrimSuffix(input, "\n") // 去掉换行符
guess, err := strconv.Atoi(input) // 将string转换为int
if err != nil {
fmt.Println(err)
return
}
if guess > secretNumber {
fmt.Println("your guess is bigger than the secret number")
} else if guess < secretNumber {
fmt.Println("your guess is smaller than the secret number")
} else {
fmt.Println("Correct,you Legend!")
return // 如果猜中了就退出循环
}
}
}
在线词典
代码生成
https://curlconverter.com/go/
JSON转Golang Struct
https://oktools.net/json2go
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"os"
)
type DictRequest struct {
TransType string `json:"trans_type"`
Source string `json:"source"`
UserID string `json:"user_id"`
}
type DictResponse struct {
Rc int `json:"rc"`
Wiki struct {
} `json:"wiki"`
Dictionary struct {
Prons struct {
EnUs string `json:"en-us"`
En string `json:"en"`
} `json:"prons"`
Explanations []string `json:"explanations"`
Synonym []string `json:"synonym"`
Antonym []string `json:"antonym"`
WqxExample [][]string `json:"wqx_example"`
Entry string `json:"entry"`
Type string `json:"type"`
Related []interface{} `json:"related"`
Source string `json:"source"`
} `json:"dictionary"`
}
func main(){
// 首先判断命令行参数
// os.Args是一个string的切片,用来存储所有的命令行参数
// args 第一个片 是文件路径
// 第二个参数是, 用户输入的参数 例如 go run osdemo01.go 123
if len(os.Args) != 2{
// 打印错误
// Fprintf() 根据 format格式说明符将内容格式化写入文件,返回内容是写入的字节与错误
fmt.Fprintf(os.Stderr,`usage:simpleDict WORD example:simpleDict hello`)
// os.Exit() 函数终止程序
// 退出程序且退出状态为3
os.Exit(1)
}
word := os.Args[1]
query(word)
}
func query(word string) {
client := &http.Client{}
// 将一个字符串转换为流
//var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
// 创建一个 DictRequest 结构体
request := DictRequest{TransType: "en2zh",Source: word}
// 将结构体序列化
buf , err := json.Marshal(request)
// buf 是 []byte 类型,转化为流
data := bytes.NewReader(buf)
// 创建请求 三个参数 method 的 post ,url,data是一个流
req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
if err != nil {
log.Fatal(err)
}
// 设置请求头
req.Header.Set("authority", "api.interpreter.caiyunai.com")
req.Header.Set("accept", "application/json, text/plain, */*")
req.Header.Set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,ja;q=0.7")
req.Header.Set("app-name", "xy")
req.Header.Set("content-type", "application/json;charset=UTF-8")
req.Header.Set("device-id", "44fa7e1a11d1cb9b019a7b2ffe67511d")
req.Header.Set("origin", "https://fanyi.caiyunapp.com")
req.Header.Set("os-type", "web")
req.Header.Set("os-version", "")
req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
req.Header.Set("sec-ch-ua", `"Google Chrome";v="113", "Chromium";v="113", "Not-A.Brand";v="24"`)
req.Header.Set("sec-ch-ua-mobile", "?0")
req.Header.Set("sec-ch-ua-platform", `"Windows"`)
req.Header.Set("sec-fetch-dest", "empty")
req.Header.Set("sec-fetch-mode", "cors")
req.Header.Set("sec-fetch-site", "cross-site")
req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36")
req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
// 发起请求
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
// 函数完成之后关闭 防止信息泄露
defer resp.Body.Close()
// 读取响应
bodyText, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
// 检查 response 状态码是否错误
if resp.StatusCode != 200{
log.Fatal("bad StatusCode",resp.StatusCode,"body",string(bodyText))
}
// 反序列化
var dictResponse DictResponse
err = json.Unmarshal(bodyText,&dictResponse)
if err != nil {
log.Fatal(err)
}
// 输出结果
fmt.Println(word,dictResponse.Dictionary.Prons.En,dictResponse.Dictionary.Prons.EnUs)
for _,one := range dictResponse.Dictionary.Explanations{
fmt.Println(one)
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2yGt8qf9-1684040381231)(image/image-20230514093352300.png)]