环境变量：
-
$GOROOT:
表示Go的安装目录。也就是上面我们解压出来的文件夹里面的go文件夹。 -
$GOPATH:
表示我们的工作空间。用来存放我们的工程目录的地方。
GOPATH目录：
一般来说GOPATH下面会有三个文件夹：bin、pkg、src，没有的话自己创建。每个文件夹都有它的作用。
-
bin：编译后可的执行文件的存放路径 -
pkg：编译包时，生成的.a文件的存放路径 -
src：源码路径，一般我们的工程就创建在src下面。
注意：
如果要用Go Mod(Go1.11及以上支持)进行包管理，则需要在GOPATH以外的目录创建工程。
Go程序主要组成：
- 包声明
- 导入包
- 函数
- 变量
- 语句和表达式
- 注释
package main // 包声明
import "fmt" // 导入包
func main() {
/* This is my first sample program. */
fmt.Println("Hello, World!")
}
让我们来看看上面的程序的各个部分：
-
程序包体的第一行定义了这个程序包的名称。这是一个必须声明为
Go程序运行在什么包。main包是起始点来运行程序。每个包都有一个与之关联的路径和名称。 -
下一行
import "fmt"是告诉编译器去包含文件在包fmt的预处理命令。 -
下一行
func main()主要功能是为程序执行的开始。 -
下一行
/*...*/会被编译器被忽略，它已被加入到程序添加注释。因此，这样的行称为程序中的注释。注释也使用//类似于Java或C++注释。 -
下一行
fmt.Println（...）是提供另一种功能，使消息“Hello, World!”要显示在屏幕上。这里fmt包已导出，println方法用来在屏幕上显示消息。 -
注意
println方法。在Go语言中，一个名字如果它用大写字母开头为导出。导出是指一个函数或变量/常访问到相应的包导入。
fmt 打印
fmt.Println("helloworld")
fmt.Println("a=", a)
var x float32
fmt.Println(x)
fmt.Printf("x is of type %T\n", x) // x is of type float32
结构体
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
结构体定义
type struct_variable_type struct {
member definition
member definition
...
member definition
}
一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：
variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}
例子：
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
// 创建一个新的结构体
fmt.Println(Books{"Go 语言", "张一", "Go 语言教程", 6495407})
// 也可以使用 key => value 格式
fmt.Println(Books{title: "Go 语言", author: "张二", subject: "Go 语言教程", book_id: 6495407})
// 忽略的字段为 0 或 空
fmt.Println(Books{title: "Go 语言", author: "张三"})
}
访问结构体成员
如果要访问结构体成员，需要使用点号 . 操作符，格式为：
结构体.成员名"
结构体指针
你可以定义指向结构体的指针类似于其他指针变量，格式如下：
var struct_pointer *Books
以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：
struct_pointer = &Book1
使用结构体指针访问结构体成员，使用 . 操作符：
struct_pointer.title
外接方法
语法
func (variable_name variable_data_type) function_name() [return_type]{
/* function body*/
}
package main
import (
"fmt"
"math"
)
/* define a circle */
type Circle strut {
x,y,radius float64
}
/* define a method for circle */
func(circle Circle) area() float64 {
return math.Pi * circle.radius * circle.radius
}
func main(){
circle := Circle(x:0, y:0, radius:5)
fmt.Printf("Circle area: %f", circle.area())
}
切片
子切片
numbers = []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// 子切片
subSlice1 := numbers[1:4]
fmt.Println("subSlice1 = ", subSlice1) // subSlice1 = [1 2 3]
subSlice2 := numbers[:4]
fmt.Println("subSlice2 = ", subSlice2) // subSlice2 = [0 1 2 3]
subSlice3 := numbers[4:]
fmt.Println("subSlice3 = ", subSlice3) // subSlice3 = [4 5 6 7 8 9]
append() 和 copy() 函数
// append() copy() 函数
var appends_array []int
appends_array = append(appends_array, 0)
printSlice(appends_array)
appends_array = append(appends_array, 1, 2, 3)
printSlice(appends_array)
appends_copy := make([]int, len(appends_array), cap(appends_array))
copy(appends_copy, appends_array)
printSlice(appends_copy)
range
// range
range_array := []int{0, 1, 2, 3, 4, 5, 6, 7}
for i := range range_array {
fmt.Println("range item:", i)
}
// --- console
range item: 0
range item: 1
range item: 2
range item: 3
range item: 4
range item: 5
range item: 6
range item: 7
map 字典
// map 映射 就是字典
var coutryMap map[string]string // 声明一个key是string，值是string的map
coutryMap = make(map[string]string) // 创建一个map
coutryMap["France"] = "Paris"
coutryMap["China"] = "Beijing"
for i := range coutryMap {
fmt.Printf("coutry %s capital is %s \n", i, coutryMap[i])
}
captial, ok := coutryMap["Janpan"]
if ok {
fmt.Println("capital of Janpan is ", captial)
} else {
fmt.Println("capital of Janpan is not present")
}
--- console
coutry France capital is Paris
coutry China capital is Beijing
capital of Janpan is not present
delete() 函数
delete()函数是用于从映射中删除一个项目。映射和相应的键将被删除。下面是一个例子：
delete(countryMap,"France");
类型转换
类型转换是一种可变从一种数据类型转换成另一种数据类型。例如，如果要存储一个long值转成一个简单的整数，那么可以强制类型转换 long为int。可以从一种类型使用转换运算符将原类型值转换为另一种类型值，如下：
type_name(expression)
package main
import "fmt"
func main() {
var sum int = 17
var count int = 5
var mean float32
maen = float32(sum)/float32(count)
fmt.Printf("Value of mean : %f\n",mean)
}
--- console
Value of mean : 3.400000
错误处理
Go编程提供了一个非常简单的错误处理框架，下面的声明中内置错误接口类型：
type error interface {
Error() string
}
例子
// 错误处理
func sqrt(value float64) (float64, error) {
if value < 0 {
return 0, errors.New("Math: negative number passed to Sqrt")
}
return math.Sqrt(value), nil
}
---
// 错误处理
result, error := sqrt(-1)
if error == nil {
fmt.Println("sqrt: ", result)
} else {
fmt.Println("sqrt: ", error)
}
---console
sqrt: Math: negative number passed to Sqrt
网友评论