go语言基础语法
20个语言知识点，1天极速入门go语言
GO语言基础语法
- 1.helloworld.go
- 2.varname.go
- 3.ifelse.go
- 4.for.go
- 5.switch.go
- 6.array.go
- 7.slice.go
- 8. map.go
- 9.range.go
- 10.func.go
- 11.pointer.go
- 12.struct.go
- 13.structfunc.go
- 14.errorhandle.go
- 15.strings.go
- 16.stringsformat.go
- 17.json.go
- 18.time.go
- 19.numbersconvert.go
- 20.processinfo.go
1.helloworld.go
package main
import "fmt"
func main() {
fmt.Println("helloworld!")
}
2.varname.go
package main
import (
"fmt"
"math"
)
func main() {
var a = "initial" // 自动推导类型
var b, c int = 1, 2 // 指定类型
var d = true
var e float64 // 指定类型，不给值，内置0
f := float32(e) // 不用var的 ":="用法
g := a + "foo" // string可以直接加
fmt.Println(a, b, c, d, e, f)
fmt.Println(g)
const s string = "constant" // const的用法.const根据上下文自动确定类型
const h = 500000000
const i = 3e20 / h // 3e2=300
fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}
3.ifelse.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("is negative")
} else if num < 10 {
fmt.Println(num, "has 1 digit")
} else {
fmt.Println(num, "has multiple digits")
}
}
4.for.go
package main
import "fmt"
func main() {
// 死循环
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)
}
i := 1
for i <= 3 {
fmt.Println(i)
i = i + 1
}
}
5.switch.go
package main
import (
"fmt"
"time"
)
func main() {
i := 2
switch i {
case 1:
fmt.Println("one")
case 2:
fmt.Println("two")
case 3:
fmt.Println("three")
case 4, 5:
fmt.Println("fot or five")
default:
fmt.Println("other")
}
//go语言中，switch的奇特用法(可以自己写条件)
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
}
6.array.go
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)
}
7.slice.go
package main
import "fmt"
//切片是长度可随时更改的数组,而且有更丰富的操作
func main() {
// 1. 第一种创建方式：使用make创建切片，使用append继续追加元素
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("get:", s[2])
fmt.Println(len(s))
// 2. 使用append追加元素（因为会扩容，必须要赋值回切片）
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println("len:", len(s))
// 3. 使用copy将一个切片复制到另一个切片
c := make([]string, len(s))
copy(c, s)
fmt.Println(c)
// 4. 使用切片操作:取出元素
fmt.Println(s[2:5])
fmt.Println(s[:5])
fmt.Println(s[2:])
//第二种创建方式：一步到位
//good := make([]string, 4)
good := []string{"g", "o", "o", "d"}
fmt.Println(good)
}
8. map.go
package main
import "fmt"
//切片是长度可随时更改的数组,而且有更丰富的操作
func main() {
// 1. 第一种创建方式：使用make创建切片，使用append继续追加元素
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("get:", s[2])
fmt.Println(len(s))
// 2. 使用append追加元素（因为会扩容，必须要赋值回切片）
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println("len:", len(s))
// 3. 使用copy将一个切片复制到另一个切片
c := make([]string, len(s))
copy(c, s)
fmt.Println(c)
// 4. 使用切片操作:取出元素
fmt.Println(s[2:5])
fmt.Println(s[:5])
fmt.Println(s[2:])
//第二种创建方式：一步到位
//good := make([]string, 4)
good := []string{"g", "o", "o", "d"}
fmt.Println(good)
}
9.range.go
package main
import "fmt"
// 用 range 可以遍历 slice 和 map
func main() {
// 切片的遍历方法
nums := []int{2, 3, 4} // 定义数组
sum := 0
// 可用下划线代替不用的。i 是索引，num 是值
for i, num := range nums { //for [_,num] [:=] [range nums] // for i,_ := range nums
sum += num
if num == 2 {
fmt.Println("index:", i, "num:", num)
}
}
fmt.Println(sum)
//map的遍历方法(纯纯的随机)
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m { //key,value
fmt.Println(k, v)
}
for k := range m {
fmt.Println("key", k)
}
for k, _ := range m {
fmt.Println("key", k)
}
for _, v := range m {
fmt.Println("key", v)
}
}
10.func.go
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 string, ok bool)是函数类型
v, ok = m[k]
return v, ok
} //ok是是否存在这个值，也就是错误报告
func main() {
res := add(1, 2)
fmt.Println(res)
v, ok := exists(map[string]string{"a": "A"}, "a")
fmt.Println(v, ok)
}
11.pointer.go
package main
import "fmt"
//为了对传入的值进行修改，go语言支持简单的指针，仅支持有限的操作
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)
}
12.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)
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
}
13.structfunc.go
package main
import "fmt"
//类似于类成员函数
type user struct {
name string
password string
}
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"))
}
14.errorhandle.go
package main
import (
"errors"
"fmt"
)
// go语言 错误就是一个返回值，处理错误就是if else
type user struct {
name string
password string
}
func findUser(users []user, name string) (v *user, err error) { //返回一个指针一个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)
if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
fmt.Println(err)
return
} else {
fmt.Println(u.name)
}
}
15.strings.go
package main
import (
"fmt"
"strings"
)
// strings 含有很多内置的操作
func main() {
a := "hello"
fmt.Println(strings.Contains(a, "ll"))
fmt.Println(strings.Count(a, "l"))
fmt.Println(strings.HasPrefix(a, "he")) //判断变量 a 是否以 "he" 为前缀
fmt.Println(strings.HasSuffix(a, "llo"))
fmt.Println(strings.Index(a, "ll"))
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) //strings.Join 函数的第一个参数需要是一个字符串数组（slice of strings），第二个参数为分隔符，用来将数组中的元素连接起来。
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))
}
16.stringsformat.go
package main
import (
"fmt"
"strings"
)
// strings 含有很多内置的操作
func main() {
a := "hello"
fmt.Println(strings.Contains(a, "ll"))
fmt.Println(strings.Count(a, "l"))
fmt.Println(strings.HasPrefix(a, "he")) //判断变量 a 是否以 "he" 为前缀
fmt.Println(strings.HasSuffix(a, "llo"))
fmt.Println(strings.Index(a, "ll"))
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) //strings.Join 函数的第一个参数需要是一个字符串数组（slice of strings），第二个参数为分隔符，用来将数组中的元素连接起来。
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))
}
17.json.go
package main
import (
"encoding/json"
"fmt"
)
// 注意：使用json，需要将struct 属性首字母大写，表示公开字段
type userInfo struct {
Name string
Age int `json:"age"` //输出风格如果要改成小写，就用这个`json:"age"`
Hobby []string
}
func main() {
//在Go语言中，不同于C++，struct的初始化必须通过显式的赋值或者推导赋值来进行-[]string
a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
// 1. 序列化 Marshal
buf, err := json.Marshal(a) // buf就是序列化后的JSON字符串，err则是序列化过程中可能出现的错误，如err为nil则序列化成功
if err != nil {
panic(err)
}
fmt.Println(buf) // 打印的是16进制的编码
fmt.Println(string(buf)) //需要加上string转换一下
// 2.MarshalIndent:跟Marshal一样，方便阅读。第二个参数是首行缩进使用的字符串，第三个参数是每一层之间缩进使用的字符串。
buf, err = json.MarshalIndent(a, "", "\t") //
if err != nil {
panic(err)
}
fmt.Println(string(buf)) //需要加上string转换一下
// 3.反序列化-Unmarshal
var b userInfo
err = json.Unmarshal(buf, &b) // json.Unmarshal 的第二个参数需要一个指向结构体的指针
if err != nil {
panic(err)
}
fmt.Printf("%#v\n", b)
/* 在 Go 中，指针是一个存储内存地址的变量，* 符号表示指针类型。例如，*p 表示 p 指针所指向的内存地址中的值。
* 所以 &b 是一个指向 b 变量地址的指针,类型是*userInfo, 可以用来传入json.Unmarshal函数中.*/
}
18.time.go
package main
import (
"fmt"
"time"
)
func main() {
// 1. 最常用的方式：time.Now()
now := time.Now()
fmt.Println(now)
// 2. time.Date()构造带时区的时间
t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
fmt.Println(t)
fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
fmt.Println(t.Format("2006-01-02 15:04:05")) //格式化时间，不像yyyy-mm这种，go语言用了一个特殊的时间
t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
diff := t2.Sub(t) //时间差
fmt.Println(diff)
fmt.Println(diff.Minutes(), diff.Seconds())
// 3.Parse
//time.Parse()是Go语言中的一个函数，它用于将字符串解析为时间。该函数需要两个参数:
// 第一个参数是一个格式字符串，用于指定输入字符串的格式。
// 第二个参数是要解析的字符串
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)
fmt.Println(now.Unix()) //时间戳
}
19.numbersconvert.go
package main
import (
"fmt"
"strconv"
)
//数字和字符串的转化：strconv
func main() {
//1.ParseFloat、ParseInt
f, _ := strconv.ParseFloat("1.234", 64) // 精度为64
fmt.Println(f)
n, _ := strconv.ParseInt("111", 10, 64) // 10进制，精度为64
fmt.Println(n)
n, _ = strconv.ParseInt("0x1000", 0, 64) //第二个参数是进制，0表示根据字符串自动推断，16进制
fmt.Println(n)
//2. Atoi
n2, _ := strconv.Atoi("123") // 字符串转数字
fmt.Println(n2)
n2, err := strconv.Atoi("AAA") // 错误
fmt.Println(n2, err)
}
20.processinfo.go
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))
}