go语言的基础使用

（学习go语言第一天的一点总结）

Go语言基础语法

Go语言是一种现代化、高效的编程语言，由Google开发。它具有简洁的语法和强大的并发支持，适用于构建高性能的网络服务和分布式系统。本文将介绍Go语言的基础语法，包括变量、函数、流程控制和数据类型等。

变量

在Go语言中，变量的声明和赋值可以分开进行，也可以一起进行。以下是一些变量声明和赋值的示例：

var name string
name = "John"

var age int = 25

city := "New York"

var a, b, c = 1, 2, 3

var (
	q = 1
	w = 2
)

注意当个变量省略var时不能用“=”号。

函数

Go语言中的函数使用func关键字进行声明。以下是一个简单的函数示例：

func add(a, b int) int {
    return a + b
}

在上面的示例中，我们定义了一个名为add的函数，它接受两个整数参数a和b，并返回它们的和。

流程控制

Go语言提供了常见的流程控制语句，例如条件语句和循环语句。以下是一些示例：

条件语句

if age >= 18 {
    fmt.Println("成年人")
} else if age >= 13 {
    fmt.Println("青少年")
} else {
    fmt.Println("儿童")
}

在上面的示例中，我们使用if语句根据年龄的不同输出不同的消息。

循环语句

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

在上面的示例中，我们使用for循环打印出0到4的数字。

数据类型

Go语言具有丰富的数据类型，包括基本类型（如整数、浮点数、布尔值和字符串）以及复合类型（如数组、切片、映射和结构体）。以下是一些示例：

var age int = 25
var price float64 = 19.99
var isStudent bool = true
var name string = "John"

var numbers [5]int
numbers[0] = 1
numbers[1] = 2

var scores []int
scores = append(scores, 90)
scores = append(scores, 85)

var person = map[string]string{"name": "John", "city": "New York"}

type User struct {
    name string
    age  int
}

在上面的示例中，我们声明了不同类型的变量，包括整数、浮点数、布尔值和字符串。我们还声明了一个整数数组和一个整数切片，并向它们添加了元素。我们还声明了一个字符串映射，并初始化了一个结构体类型。（go语言有自动类型判断功能）

语法注意事项

（1）每行代码不用“；”隔开（go语言自动会加上去），但放在同一行就需要了

（2）Go语言是大小写敏感的，因此变量名和函数名的大小写要一致。

（3）main函数为执行入口。

（4）在使用if语句、for循环和switch语句时，代码块的左括号"{"必须和关键字放在同一行，否则会报错。

（5）在函数的返回值列表中，如果多个返回值的类型相同，可以将类型写在最后一个返回值的后面，例如func fundemo(a, b float64) float64。

以下是对一些常用包的分析

encoding/json

encoding/json是Go语言中用于JSON编码和解码的包。它提供了将Go数据结构转换为JSON格式的函数，以及将JSON数据转换为Go数据结构的函数。以下是一些encoding/json包的基本使用示例：

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

func main() {
	// 将Go数据结构转换为JSON格式
	p := Person{Name: "John", Age: 25}
	jsonData, err := json.Marshal(p)
	if err != nil {
		fmt.Println("JSON encoding error:", err)
		return
	}
	fmt.Println(string(jsonData))

	// 将JSON数据转换为Go数据结构
	jsonData = []byte(`{"name":"Alice","age":30}`)
	var p2 Person
	err = json.Unmarshal(jsonData, &p2)
	if err != nil {
		fmt.Println("JSON decoding error:", err)
		return
	}
	fmt.Println(p2.Name, p2.Age)
}

在上面的示例中，我们定义了一个名为Person的结构体类型，并使用json标签指定了JSON字段的名称。我们将Person类型的实例转换为JSON格式并打印出来，然后将JSON数据转换为Person类型的实例并打印出来。

os

os包提供了与操作系统交互的函数和方法，例如文件操作、环境变量和命令行参数等。以下是一些os包的基本使用示例：

package main

import (
	"fmt"
	"os"
)

func main() {
	// 获取命令行参数
	args := os.Args
	fmt.Println(args)

	// 获取环境变量
	env := os.Getenv("PATH")
	fmt.Println(env)

	// 创建目录
	err := os.Mkdir("test", 0755)
	if err != nil {
		fmt.Println("Directory creation error:", err)
		return
	}

	// 创建文件
	file, err := os.Create("test.txt")
	if err != nil {
		fmt.Println("File creation error:", err)
		return
	}
	defer file.Close()

	// 写入文件
	_, err = file.WriteString("Hello, World!")
	if err != nil {
		fmt.Println("File writing error:", err)
		return
	}
}

在上面的示例中，我们使用os.Args获取命令行参数，并使用os.Getenv获取环境变量。我们还使用os.Mkdir创建一个目录，并使用os.Create创建一个文件。然后，我们使用file.WriteString向文件中写入内容。

math

math包提供了数学函数和常量，例如三角函数、指数函数和对数函数等。以下是一些math包的基本使用示例：

package main

import (
	"fmt"
	"math"
)

func main() {
	// 计算平方根
	fmt.Println(math.Sqrt(16))

	// 计算正弦值
	fmt.Println(math.Sin(math.Pi / 2))

	// 计算自然对数
	fmt.Println(math.Log(math.E))

	// 计算底数为2的对数
	fmt.Println(math.Log2(8))

	// 计算以10为底的对数
	fmt.Println(math.Log10(100))
}

在上面的示例中，我们使用math.Sqrt计算平方根，使用math.Sin计算正弦值，使用math.Log计算自然对数，使用math.Log2计算以2为底的对数，使用math.Log10计算以10为底的对数。

string

string是Go语言中表示字符串的类型。string类型是不可变的，即一旦创建就不能修改。以下是一些string类型的基本使用示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 字符串拼接
	str1 := "Hello"
	str2 := "World"
	result := str1 + " " + str2
	fmt.Println(result)

	// 字符串长度
	fmt.Println(len(result))

	// 字符串切割
	parts := strings.Split(result, " ")
	fmt.Println(parts)

	// 字符串替换
	newStr := strings.Replace(result, "World", "Go", 1)
	fmt.Println(newStr)

	// 字符串包含
	fmt.Println(strings.Contains(result, "Hello"))
}

输出：

Hello World

11

[Hello World]

Hello Go

在上面的示例中，我们使用+运算符将两个字符串拼接在一起，并使用len函数获取字符串的长度。我们使用strings.Split函数将字符串切割成多个部分，并使用strings.Replace函数替换字符串中的部分内容。最后，我们使用strings.Contains函数判断字符串是否包含某个子串。

errors

errors包提供了处理错误的函数和类型。它定义了一个error接口，用于表示错误。以下是一些errors包的基本使用示例：

package main

import (
	"errors"
	"fmt"
)

func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("division by zero")
	}
	return a / b, nil
}

func main() {
	result, err := divide(10, 2)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println(result)

	result, err = divide(10, 0)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println(result)
}

在上面的示例中，我们定义了一个divide函数，用于计算两个浮点数的商。如果除数为0，则返回一个error类型的值，表示除零错误（error(*errors.errorString) *{s: "division by zero"}）。在main函数中，我们调用divide函数并检查返回的错误。如果错误不为空，则打印错误信息。

今天用go的遇到的错误（用的vscode）：

（1）go: cannot find main module; see 'go help modules'

原因：没有go.mod文件

（2）Build Error: go build -o d:\programme\GO\workspace\demo\__debug_bin3251768621.exe -gcflags all=-N -l . main.go:1:1: illegal character U+200B (exit status 1)

原因：有不明符号，可能是复制粘贴别人的代码出错了（我当时重新打一遍就好了）。

（3）missing return at end of function

原因：表示函数没有返回值，但是在函数的定义中声明了返回值