开发环境配置：

package main

import "fmt"

func main(){

fmt.Printf("Hello Word!\n");

}

D:\Go\src>go build hello.go
can\'t load package: package main:
hello.go:1:1: expected \'package\', found \'EOF\'

 //报错原因是文件编辑后，未保存就直接进行编译

D:\Go\src>go build hello.go

D:\Go\src>go run hello.go
Hello Word!

D:\Go\src>

1.GO语言命令：

godoc -http :8080   //在本地获取官网文档

go get                    //获取远程资源包

go run                   //直接运行程序

go build                //测试编译，检测是否有编译错误

go install              //编译包文件并编译整个程序

2.GO环境变量及工作目录

*bin：存放编译后生成的可执行文件

*pkg：存放编译后生成的包文件

*src：存放项目源码

3.GO环境变量：

set GOARCH=amd64           //CPU架构
set GOBIN=                           //工作目录下的bin文件夹
set GOCACHE=C:\Users\xcxz\AppData\Local\go-build
set GOEXE=.exe                  //生成可执行文件的后缀
set GOFLAGS=
set GOHOSTARCH=amd64      //交叉编译的架构
set GOHOSTOS=windows        //交叉编译的系统
set GOOS=windows
set GOPATH=C:\Users\xcxz\go      //工作目录
set GOPROXY=
set GORACE=
set GOROOT=D:\Go                       //安装目录
set GOTMPDIR=

4.第一个GO程序：Hello  world

（1）在D:\Go\src目录下新建，文件hello.go

package main

import "fmt"

func main(){
    fmt.Println("Hello world 你好，世界！")
}

（2）CMD下运行：D:\Go\src>go run hello.go

5.GO程序的一般结构：

（1）GO程序是通过package来组织的

（2）只有package名称为main的包可以包含main函数

（3）一个可执行程序有且仅有一个main包

（4）通过import关键字来导入其它非main包

（5）通过const关键字来进行常量的定义

（6）通过在函数体外部使用var关键字来进行全局变量的声明与赋值

（6）通过type关键字来进行结构（struct）或接口（interface）的声明

（7）通过func关键字来进行函数的声明

//当前程序的包
package main

//导入其他的包
import "fmt"

//常量的定义
const PI=3.14
//全局变量
var name="chunyu"

//一般类型声明inttype是类型的名称
type inttype int

//结构的声明，chunyu是结构的名称
type chunyu struct{}

//接口的声明
type golang interface{}

//main函数作为程序的入口或启动
func main(){
    fmt.Println("Hello world 你好，世界！")
}

6.导入包之后没有调用包中的函数，那么就会出现编译错误；

7.包别名：

import   std  "fmt"

std.Println("Hello word!")

8.省略调用：

import  .   "fmt"

Println("Hello word!")

9.可见性规则：使用大小写来决定常量，变量，类型，接口，结构和函数，是否可以被外部包所调用

（1）函数名首字母小写，即为private

（2）函数名首字母大写，即为public

10.多个常量，全局变量或一般类型（非接口，非结构）可以进行简写：使用的是括号

//常量的定义
const(
    PI = 3.14
    SI = 1.15
    CI = "test"
)

//全局变量。变量组只能用在全局变量的声明中使用，函数体内是不可以这样使用的

var(
    name = "chunyu"
    sex  = "man"
    age  = 15
)

//一般类型声明
type(
    typetest1 int
    tptest2   float32
    tptest3   string
)

11.GO基本类型：

（1）布尔型：bool

-长度：1字节

-取值范围：true，false

-注意事项：不可以用数字代表true或false

（2）整型：int/uint

（3）8位整型;int8/uint8      uint8---无符号的8位整型

-长度：1字节

-取值范围：-128~127/0~255（2的8次方）--（无符号的8位整型的取值范围）    

（4）字节型：byte（uint8别名）

（5）16位整型：int16/uint16

-长度：2字节

-取值范围：-32768~32767/0-65535（2的16次方）

（6）32位整型（别名rune，处理Unicode字符）（4字节），64位整型（8字节）类似上述；

（7）浮点型：float32/float64

-长度：4/8字节

-小数位：精确到7/15小数位

（8）复数：complex64/complex128    长度：8/16字节

（9）足够保存指针的32位或34位整数型：uintptr

（10）其他值类型：array，struct，string

（11）引用类型：slice---切片，map---类似hash表，chan--通道，高并发

（12）接口类型：interface

（13）函数类型：func。可以赋值给变量

12.类型的零值：零值不等于空值，而是当变量被声明为某种类型后的默认值，

     通常情况下，值类型的默认值为0，bool为false，string为空字符串

     引用类型的零值，就是new，代表没有分配内存地址

13.类型别名：例如：string类型可以起一个中文的别名为：文本，然后b变量可以声明为“文本”类型

type(
    byte int8
    rune int32
    文本 string
)
//main函数作为程序的入口或启动
func main(){
    var b 文本
    b = "中文类型名"
    fmt.Println(b)
}

14.单个变量的声明与赋值：

--变量的声明格式：var  <变量名称> <变量类型>

：当这个变量还没有要用到，但是在后边的分支结构中可能会用到它，那么你就不能在这个结构体中声明，因为如果你在结构中声明，当这个结构退出之后你还要进行一些其他的运算，这个时候你就需要提前的对这个变量进行声明，然后你才能在后边的这个过程中进行使用；可以在一些分支结构中进行赋值

--变量的赋值格式：<变量名称>  =  <表达式>

：一般是用在全局变量中

--声明的同时赋值：var  <变量名称>   [变量类型] =   <表达式>

func main(){

    var a int    //变量的声明
    a = 234      //变量的赋值
    //变量声明的同时赋值
    var b int = 789
    //上述的格式可以省略变量类型，由系统判断
    var c = 367
    //变量声明与赋值的最简写法
    d := 365
    
    fmt.Println(a,b,c,d)
}

15.多个变量的声明与赋值：

--全局变量的声明可使用var()的方式进行简写；

--全局变量的声明不可以省略var，但可使用并行方式

--所有变量都可以使用类型推断

--局部变量不可以使用var(）方式简写，只能使用并行方式

func main(){
    var a,b,c,d int = 1,2,3,4    
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
}

空白符：_   表示空白符，暂时忽略的变量

func main(){
    var a,_,c,d int = 1,2,3,4    //往往用在函数多个返回值得情况下
    fmt.Println(a)
    fmt.Println(c)
    fmt.Println(d)
}

16.变量的类型转换：

--Go中不存在隐式转换，所有类型转换必须显式声明

--转换只能发生在两种相互兼容的类型之间

--类型转换的格式：

        <ValueA>  [:] = <TypeOfValueA>(<ValueB>)

func main(){
    var a float32 = 100.1
    b := int(a)  //把未定义的变量b转换并赋值为int类型的a
    fmt.Println(a,b);
}

func main(){
    var a int = 65
    b := string(a)  //把未定义的变量b转换并赋值为int类型的a
    fmt.Println(a,b);
}
上述代码，输出：65，A

     ***string()表示数据转换成文本格式，因为计算机中存储的任何东西本质上都是数字，因此函数自然的认为我们需要的是用数字65表示的文本A