2023年暑假字节——青训营DAY01笔记

OnlyOneHYT
95 阅读8分钟

字节青训营--第一天学习

什么是GO语言

特点：

1.高并发、高并发
2.语法简单、学习曲线平缓
2行开发出一个服务器（可见GO的牛*）
package main

import(
    "fmt"
)

func main(){
    http.Handle("/",http.FileServer(http.Dir(".")))
    http.ListenAndServe(":8080",nil)
}
3.丰富的标准库
4.完整的工具链
5.静态链接
6.快速编译
7.跨平台
8.垃圾回收

基本语法

入门第一步“Hello,World!”

示例代码：

package main

import (
    "fmt"
)

func main(){
    fmt.Println("Hello,world!")
}
  • 想要跑代码，有两步操作。
  • 第一步：先package main，代表的是这个文件是程序的主入口，
  • 第二步：import()需要的包。fmt主要的作用是往屏幕上格式化输出字符串。

变量

示例代码：

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

  • 写法1（显式写法）var 变量名 [变量类型] := 值

  • 写法2（隐式写法）变量名 := 值

  • 数据类型

    • 基本数据类型

      • 数值型

        • int（整型）

          • 有符号：int, int8, int16, int32, int64
          • 无符号：uint, uint8, uint16, uint32, uint64

        • float（实型）:float32,float64

        • complex（复数型）:complex64, complex128

      • 布尔型:bool (true / false)

      • 字符串:string

        • 双引号字符串："hello world"
        • 双波浪线字符串：hello world

    • 注意：

      • 若不显式声明类型，则由值自动推断类型
      • 声明过的变量必须要使用
      • int, uint的位数由操作系统的位数确定
      • byte是uint8的别名，rune是int32的别名

  • 强制类型转化

    • Go是强类型语言，类型转化方法：类型(变量）

  • 常量: const

    • 也分为显式和隐式和变量一样的操作

if-else

示例代码：

package main

import "fmt"

func main() {

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

  格式1：if 条件 { 分支代码 }
  格式2：if 条件 { 分支代码 } else { 分支代码 }
  格式3：if 条件 { 分支代码 } else if 条件 { 分支代码 } ... else{ 分支代码 }
  格式4：if 初始化语句;条件 { 分支代码 } else ... ```
  • 注意：初始化语句中声明的变量作用域为该if语句
  • 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
    }

}
  • 死循环可以用for{}来代替
  • for的条件也同样是没有括号的
  • continue和break也是和其他语言一样的使用
  • %---代表的是取模
  • 其他的和其他语言没什么区别

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

注意：switch 语句中的 case 代码块会默认带上 break，但可以使用 fallthrough 来强制执行下一个 case 代码块。

数组

示例代码：

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
    for i := 0; i < 2; i++ {
       for j := 0; j < 3; j++ {
          twoD[i][j] = i + j
       }
    }
    fmt.Println("2d: ", twoD)
}

数组的定义：
一维数组var a[size]【类型】
二维数组var a[size][size]【类型】
注意:一般情况下我们不会使用数组，因为大小固定，一般使用切片

切片

package main

import "fmt"

func main() {
    s := make([]string, 3)
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("get:", s[2])
    fmt.Println("len", len(s))

    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println(s)

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println(c)

    fmt.Println(s[2:5])
    fmt.Println(s[:5])
    fmt.Println(s[2:])

    good := []string{"g", "o", "o", "d"}
    fmt.Println(good)
}

数组切片make([]【类型】,size)
append()是对字符串进行拼接
copy()对数组进行复制
s[ : ]前包后不包

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

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

map和其他语言中的hashmap几乎差不多，同样也可以用切片来声明。用delete来删除元素。

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 := range m {
       fmt.Println("key", k)
    }
}

数组range返回两个值第一个值是索引，第二个值是值
map range返回两个值，第一个是key，第二个是value

函数

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)
    
    v, ok := exists(map[string]string{"a": "A"}, "a")
    fmt.Println(v, ok)
}

GO的函数和其他语言除了结构上有一点差别之外，其余无太大区别

指针

示例代码：

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)

    add2ptr(&n)
    fmt.Println(n)
}

GO比Java多了一个指针的操作，但是比C的指针又简单了许多。

结构体

示例代码：

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

结构体这块感觉和其他语言差不多，没有太大的变动，但是声明风格上感觉更加清晰。

结构体方法

类似于类成员函数
函数前加（u user）

错误处理

`error`错误的类型
error.New()可以自定义生成报错信息
nil是GO中唯一未有准确类型的类型

字符串操作

package main

import (
    "fmt"
    "strings"
)

func main() {
    a := "hello"
    fmt.Println(strings.Contains(a, "ll"))
    fmt.Println(strings.Count(a, "l"))
    fmt.Println(strings.HasPrefix(a, "he"))
    fmt.Println(strings.HasSuffix(a, "ll"))
    fmt.Println(strings.Join([]string{"he", "llo"}, "-"))
    fmt.Println(strings.Repeat(a, 2))
    fmt.Println(strings.Replace(a, "e", "E", -1))
    fmt.Println(strings.Split("a-b-c", "-"))
    fmt.Println(strings.ToLower(a))
    fmt.Println(strings.ToUpper(a))
    fmt.Println(len(a))
    b := "你好"
    fmt.Println(len(b))
}

contain(string s,string ss)判断ss是否在s里
count(string s,string ss)判断ss在s中出现的次数
hasPrefix(string s,string ss)判断s中是否有ss(从前往后)
hassuffix(string s,string ss)判断s中是否有ss(从后往前)
join(string s,string ss,string sss)在s和ss中间插入sss Repeat(string s,int n)把字符串s重复n次 Replace(string s,string ss,string sss,-1)在s中把ss替换成sss
Split(string s,string ss)把s中的ss去除
ToLower(string a)字符全部变成小写
ToUpper(string a)字符全部变成大写
len(string s)字符串s的长度

字符串格式化

package main

import "fmt"

type point struct {
    x, y int
}

func main() {
    s := "hello"
    n := 123
    p := point{1, 2}
    fmt.Println(s, n)
    fmt.Println(p)

    fmt.Printf("s=%v\n", s)
    fmt.Printf("n=%v\n", n)
    fmt.Printf("p=%v\n", p)
    fmt.Printf("p=%+v\n", p)
    fmt.Printf("p=%#v\n", p)

    f := 3.141592653
    fmt.Println(f)
    fmt.Printf("%.2f\n", f)
}

这个操作和C差不多 %v可以代替大部分的类型，比C简单一点，%+v代表的是带变量名一起输出%#v代表的是带类和结构体一起输出

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)
    fmt.Println(string(buf))

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

使用Go标准库中的 json.Marshal()与json.Unmarshal进行基本的序列化和反序列化
这里的json:"age"就是给Name字段的设置的tag。 tag由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。如下：

时间处理

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now)
    t := time.Date(2023, 7, 27, 18, 26, 36, 0, time.UTC)
    t2 := time.Date(2023, 7, 27, 19, 30, 36, 0, time.UTC)
    fmt.Println(t)
    fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute())
    fmt.Println(t.Format("2006-01-02 15:04:05"))
    diff := t2.Sub(t)
    fmt.Println(diff)
    fmt.Println(diff.Minutes(), diff.Seconds())
    t3, err := time.Parse("2006-01-02 15:04:05", "2023-07-27 18:26:36")
    if err != nil {
       panic(err)
    }
    fmt.Println(t3 == t)
    fmt.Println(now.Unix())

}

Go 语言中时间的表示方式是通过 time.Time 结构体来表示的。time.Time 类型代表了一个时刻，它包含了年月日时分秒和纳秒等信息。
我们可以使用 time.Now() 函数获取当前时间，或者使用 time.Date() 函数创建一个指定的时间。
在 Go 语言中，可以使用 time.Before()、time.After() 和 time.Equal() 等方法来比较两个时间的先后顺序以及是否相等。

数字解析

package main

import (
    "fmt"
    "strconv"
)

func main() {
    f, _ := strconv.ParseFloat("1.234", 64)
    fmt.Println(f)

    n, _ := strconv.ParseInt("111", 10, 64)
    fmt.Println(n)

    n, _ = strconv.ParseInt("0x1000", 0, 64)
    fmt.Println(n)

    n2, _ := strconv.Atoi("123")
    fmt.Println(n2)
    
    n2, err := strconv.Atoi("AAA")
    fmt.Println(n2, err)
}

将字符串转换成数字，分别代替字符串，进制，位数，0表示自动推测。Atoi()快速把十进制数（字符串类型）转换成数字。如果不对，同样会报错。

进程信息

package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    fmt.Println(os.Args)
    fmt.Println(os.Getenv("PATH"))
    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))
}
avatar
文章
阅读
粉丝