GO语言开篇-Go语言急速入门（基础知识点）｜ 青训营笔记

package main



import (

   "fmt"

)



func main() {

   fmt.Println("hello world，上进小菜猪")

}

var a = "initial"

var b, c int = 1, 2

var d = true

f := float32(e)

g := a + "foo"

import (

   "fmt"

   "math"

)

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) // initial 1 2 true 0 0

fmt.Println(g)                // initialapple

const s string = "constant"

const h = 500000000

const i = 3e20 / h

fmt.Println(s, h, i, math.Sin(h), math.Sin(i))

if 7%2 == 0 {

   fmt.Println("7 is even")

} else {

   fmt.Println("7 is odd")

}

import "fmt"

if 7%2 == 0 {

   fmt.Println("7 is even")

} else {

   fmt.Println("7 is odd")

}



if 8%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")

}

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)

}

import (

   "fmt"

   "time"

)

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

}

var a [5]int

a[2] = 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)

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]

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)

nums := []int{2, 3, 4}

sum := 0

for i, num := range nums {

   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 {

   fmt.Println(k, v) // b 8; a A

}

for k := range m {

   fmt.Println("key", k) // key a; key b

}

res := add(1, 2)

fmt.Println(res) // 3

func add(a int, b int) int {

   return a + b

}

v, ok := exists(map[string]string{"a": "A"}, "a")

fmt.Println(v, ok) // A True

func exists(m map[string]string, k string) (v string, ok bool) {

   v, ok = m[k]

   return v, ok

}

func add2(n int) {

   n += 2

}

func add2ptr(n \*int) {

   \*n += 2

}

n := 5

add2(n)

fmt.Println(n) // 5

add2ptr(&n)

fmt.Println(n) // 7

type user struct {

   name     string

   password string

}

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}

func checkPassword(u user, password string) bool {

   return u.password == password

}

func checkPassword2(u \*user, password string) bool {

   return u.password == password

}

fmt.Println(checkPassword(a, "haha"))   // false

fmt.Println(checkPassword2(&a, "haha")) // false

a := user{name: "wang", password: "1024"}

a.resetPassword("2048")

func (u \*user) resetPassword(password string) {

   u.password = password

}

fmt.Println(a.checkPassword("2048")) // true

func (u user) checkPassword(password string) bool {

   return u.password == password

}

import (

   "errors"

   "fmt"

)

u, err := findUser([]user{{"wang", "1024"}}, "wang")

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

}

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)

}

import (

   "fmt"

   "strings"

)

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

s := "hello"

n := 123

p := point{1, 2}

fmt.Println(s, n) // hello 123

fmt.Println(p)    // {1 2}

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

import (

   "encoding/json"

   "fmt"

)

type userInfo struct {

   Name  string

   Age   int `json:"age"`

   Hobby []string

}

a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}

func Marshal(v interface{}) ([]byte, error)

buf, err := json.Marshal(a)

if err != nil {

   panic(err)

}

fmt.Println(buf)         // [123 34 78 97...]

fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]} 

func MarshalIndent(v any, prefix, indent string)([]byte, error)

buf, err = json.MarshalIndent(a, "", "\t")

if err != nil {

   panic(err)

}

fmt.Println(string(buf))

func Unmarshal(data []byte, v interface{}) error

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

import (

   "fmt"

   "time"

)

now := time.Now()

fmt.Println(now) 

t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)

t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)

fmt.Println(t)                                                  // 2022-03-27 01:25:36 +0000 UTC

fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25

fmt.Println(t.Format("2006-01-02 15:04:05"))     

diff := t2.Sub(t)

fmt.Println(diff)                           // 1h5m0s

fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900

func Parse(layout, value string) (Time, error)

t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")

if err != nil {

   panic(err)

}

fmt.Println(t3 == t)    // true

fmt.Println(now.Unix()) // 1648738080

import (

   "fmt"

   "strconv"

)

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

import (

   "fmt"

   "os"

   "os/exec"

)

fmt.Println(os.Args)

fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...

fmt.Println(os.Setenv("AA", "BB"))

buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()

if err != nil {

   panic(err)

}

fmt.Println(string(buf)) // 127.0.0.1       localhost