Go语言基础
发表于:2024-12-10
字数统计:2146 字
预计阅读8分钟
Go语言有点像c语言，也有点像js。
例子
hello
go
package main
import (
"fmt"
)
// main 是程序的入口点
func main() {
// Println 将字符串输出到控制台
fmt.Println("hello world")
}在Go语言中，main函数是程序的入口点。当你运行一个Go程序时，main函数会自动执行。你不需要显式地调用它。[main]函数必须位于[main]包中，这是Go语言规定的。
var
go
package main
import (
"fmt"
"math"
)
func main() {
// 同js
var a = "initial"
// 使用var后，指定了b，c的类型
var b, c int = 1, 2
// 使用var后
var d = true
// 使用var后，指定了e的类型
var e float64
// 使用:=，省略了var，类型自动判断
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))
}for
go
package main
import "fmt"
func main() {
i := 1
// for循环，这个只运行了一次，因为是无限循环，但是有break
// 如果注释掉break，会一直打印loop，并且程序会提示警告信息
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
}
}if
go
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")
}
}switch
go
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")
// 4或5
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")
}
}array
go
package main
import "fmt"
func main() {
var a [5]int
a[4] = 100
// 获取值，默认为0
fmt.Println("get:", a[2])
fmt.Println("len:", len(a))
fmt.Println(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)
}slice
go
package main
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) // [a b c d e f]
c := make([]string, len(s))
fmt.Println(c) // [ ]
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]
}map
go
package main
import "fmt"
func main() {
// 创建一个新的 map
m := make(map[string]int)
// 向 map 中添加键值对
m["one"] = 1
m["two"] = 2
// 打印 map
fmt.Println(m) // map[one:1 two:2]
// 打印 map 的长度
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")
// 初始化带有值的 map
m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}
// 打印初始化的 map
fmt.Println(m2, m3)
}range
go
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) // 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
}
}func
go
package main
import "fmt"
// 两个add没区别，只是在参数的类型写法上有区别
func add(a int, b int) int {
return a + b
}
func add2(a, b int) int {
return a + b
}
// 返回两个值，一个是值，一个是是否存在，如果存在返回true，否则返回false
// 返回值的类型写在括号外面
// 返回值可以命名，也可以不命名
// 返回值可以有多个
// 返回值可以是任意类型
// 返回值可以是函数
// 参数的类型写在括号里面，参数可以有多个，参数的类型可以是任意类型
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
}point
go
// This program demonstrates the difference between passing a value and passing a pointer to a function in Go.
// The `add2` function takes an integer value and adds 2 to it, but since it operates on a copy of the value,
// the original value remains unchanged.
// The `add2ptr` function takes a pointer to an integer and adds 2 to the value at that memory address,
// modifying the original value.
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
}struct
go
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) // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
fmt.Println(checkPassword(a, "haha")) // false
fmt.Println(checkPassword2(&a, "haha")) // false
}
func checkPassword(u user, password string) bool {
return u.password == password
}
func checkPassword2(u *user, password string) bool {
return u.password == password
}struct-method
go
package main
import "fmt"
type user struct {
name string
password string
}
// user 结构体的方法，检查密码是否正确，返回布尔值
// 第一次见这种这么写的方法
func (u user) checkPassword(password string) bool {
return u.password == password
}
func (u *user) resetPassword(password string) {
u.password = password
}
func main() {
a := user{name: "wang", password: "1024"}
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true
}error
go
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)
}
}string
go
package main
import (
"fmt"
"strings"
)
func main() {
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
}json
go
package main
import (
"encoding/json"
"fmt"
)
type userInfo struct {
Name string
Age int `json:"age"`
Hobby []string
}
func main() {
// a is an instance of the userInfo struct, initialized with the following values:
// Name: "wang"
// Age: 18
// Hobby: a slice containing "Golang" and "TypeScript"
// main.go 文件展示了如何在 Go 语言中使用 JSON。
// 该示例定义了一个名为 userInfo 的结构体，并创建了一个包含用户信息的实例。
// 结构体包含用户的姓名、年龄和爱好列表。
// 在这个示例中，创建了一个名为 a 的 userInfo 实例，
// 其中 Name 字段为 "wang"，Age 字段为 18，Hobby 字段为一个包含 "Golang" 和 "TypeScript" 的切片。
a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
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"]}
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"}}
}参考资料
https://gobyexample-cn.github.io/
字节青训营