go语言基础语法

阿里云国内75折回扣微信号：monov8

阿里云国际，腾讯云国际，低至75折。AWS 93折免费开户实名账号代冲值优惠多多微信号：monov8 飞机：@monov6

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