1.GO语言命令

go build 用于编译源码文件、代码包、依赖包

go run 可以编译并运行GO 源码文件

go get 用来动态获取远程代码包的

2. Goland 编辑器

配置 setting goRoot

3.GO语言基础语法

a.关健字，标识符，注释，基础结构

基础结构

//程序所属包 *必须

package main

//导入依赖包

import (
   "fmt"
)

//常量定义 string不写也可以

const NAME string ="wawa";

//全局变量的声明与赋值

var mainName string = "宝贝";

//一般类型声明

type wawaInt int

//结构的声明

type Learn struct {

}

//声明接口

type Ilearn interface{

}

//函数定义

func learnWawa(){

   fmt.Print(mainName)

}

//main函数

func main(){

   learnWawa()

   fmt.Print("Hello world!")

}

b. package,import别名，路径，".","_"的使用说明

package是最基本的分发单位和工程管理中依赖关系的体现

每个GO语言源文件开头都必须拥有一个package声明，表示源码文件所属代码包

要生成GO语言可执行程序，必须要有main的package包，且必须在该包下有main()函数

同一个路径下只能存在一个package,一个package可以拆成多个源文件组成

import原理

如果一个main导入其他包，包将被顺序导入

如果导入的包中依赖其他包（包B），会首先导入B包，然后初始化B包中常量和变量，最后如果B包中有init，会自动执行init()

所有包导入完成后才会对main中常量和变量进行初始化，然后执行main中的init函数（如果存在），最后执行main函数

如果一个包被导入多次则该包只会被导入一次

test.go
package wangwawa

import "fmt"

func init() {
   fmt.Println("this is wangwawa test")
}
func Test()  {

}

test1.go

package wawa

import (
   "fmt"
   "awesomeProject/wangwawa"
)

func init() {
   fmt.Println("this is wawa test1")
}
func Test1()  {
   wangwawa.Test()
}

test2.go
package wawa

import "fmt"

func init() {
   fmt.Println("this is wawa test2")
}
func Test2()  {
   Test1()
}

Hello.go
//程序所属包 *必须

package main

//导入依赖包

import (
   "fmt"
   "awesomeProject/wawa"
   "awesomeProject/wangwawa"
)

//常量定义 string不写也可以

const NAME string ="wawa"

//全局变量的声明与赋值

var mainName string = "宝贝"

//一般类型声明

type wawaInt int

//结构的声明

type Learn struct {

}

//声明接口

type Ilearn interface{

}

func init()  {
   fmt.Println("this is hello.go");
}

//函数定义

func learnWawa(){

   fmt.Print(mainName)

}


//main函数

func main(){
   learnWawa()
//只会导入一次 
   wangwawa.Test()
   wawa.Test2()
   fmt.Print("Hello world!")

}

运行结果：

this is wangwawa test
this is wawa test1
this is wawa test2
this is hello.go
宝贝Hello world!

引入从最里面开始往外执行

import特殊用法

别名操作的含义是：将导入的包命名为另一个容易记忆的别名

点（.）操作的含义是:点（.）标识的包导入后，调用该包中函数时可以活力前缀包名

下划线（_）操作含义是：导入该包，但不导入整个我，而是执行该包中的init函数，因此无法通过包名来调用包中其他函数，使用下划线（_）操作往往是为了注册包里的引擎，让外部可以方便地使用

//程序所属包 *必须
package main

//导入依赖包

import (
   //f为别名
   //f "fmt"
   //可省略
   . "fmt"
   //直接调用某包下的方法
   _ "awesomeProject/wangwawa"
)


func init()  {
   Println("this is hello.go")
}


//main函数

func main(){
   Print("Hello world!")

}

运行结果：

this is wangwawa test
this is hello.go
Hello world!

c.GO变量，函数，可见性规则

GO语言的数据类型

数据类型，字符串类型和布尔型

• byte 等同于int8，常用来处理ascii字符
• rune 等同于int32,常用来处理unicode或utf-8字符

• rune类型的值需要由单引号“'”包裹。例如，'A'或'郝'。这种表示方法一目了然。不过，我们还可以用另外几种形式表示rune类型值。请看下表。  

  

//程序所属包 *必须
package main

import (
   "fmt"
   "unsafe"
)

//main函数

func main(){
   //一个字节是8位
   //这个是32个位 所以占用的是1个字节的大小
   var i uint8 = 1
   //这个是32个位 所以占用的是4个字节的大小
   var j int32 = 4
   //这个是64个位 所以占用的是8个字节的大小
   var m int64 = 2
   //int后面不带数字，会根据电脑的位数来，现电脑的位数是64位 所以占用的是8个字节的大小，如果电脑是32位的，那边占用的是4个字节的大小
   var n int = 5
   //无符号也是8
   var u uint = 5
   //以上是INT----------------float后面不可不跟数字，因为要么32，要么64
   var f float32 = 1
   //以上是float----------------bool型，因为在PHP中1也是true,但GO语言中只能用true和false
   var b bool = true;
   //以上是bool----------------以下为其他类型
   //1个（byte）字节 无符号整形8的大小uint8
   var k byte = 1
   //无符号整形32的大小int32
   var l rune = 1
   fmt.Print(unsafe.Sizeof(i))
   fmt.Print(unsafe.Sizeof(j))
   fmt.Print(unsafe.Sizeof(m))
   fmt.Print(unsafe.Sizeof(n))
   fmt.Print(unsafe.Sizeof(u))
   fmt.Print(unsafe.Sizeof(f))
   fmt.Print(unsafe.Sizeof(b))
   fmt.Print(unsafe.Sizeof(k))
   fmt.Print(unsafe.Sizeof(l))

   //运行结果：148884114
}

派生类型

指针类型（Poiniter）

数组类型

结构化类型（struct）

Channel类型（chan）

通道（Channel）是Go语言中一种非常独特的数据结构。它可用于在不同Goroutine之间传递类型化的数据，并且是并发安全的

函数类型（func）

切片类型（slice）

在进行“切片”操作的时候需要指定元素下界索引和元素上界索引,切片表达式的求值结果相当于以元素下界索引和元素上界索引作为依据从被操作对象上“切下”而形成的新值。注意，被“切下”的部分不包含元素上界索引指向的元素

//程序所属包 *必须
package main

//导入依赖包

import (
   "fmt"
)


//main函数
func main(){
   var numbers3 = [5]int{1, 2, 3, 4, 5}
   var slice1 = numbers3[1:4]
   var slice2 = slice1[1:3]
   //切片是1-4 4不算，所以是2, 3, 4,
   fmt.Println(slice1)
   //容量是从第一个参数开始算，所以是2345
   fmt.Println(cap(slice1))
   //2, 3, 4,切片是1-3 3不算，所以是3
   fmt.Println(slice2)
   //容量是从第一个参数开始算，所以是345
   fmt.Println(cap(slice2)) 
}

//程序所属包 *必须
package main

//导入依赖包

import (
    "fmt"
)
func main() {
    var numbers4 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    slice5 := numbers4[4:6:8]
    length := (2)
    capacity := (4)
    fmt.Printf("%v, %vn", length == len(slice5), capacity == cap(slice5))
    slice5 = slice5[:cap(slice5)] //5,6,7,8
    slice5 = append(slice5, 11, 12, 13)
    length = (7)
    fmt.Printf("%vn", length == len(slice5))
    slice6 := []int{0, 0, 0}
    copy(slice5, slice6)
    e2 := (0)
    e3 := (8)
    e4 := (11)
    fmt.Printf("%v, %v, %vn", e2 == slice5[2], e3 == slice5[3], e4 == slice5[4])
 

接口类型（interface）

Map类型（map）

    Go语言的字典（Map）类型其实是哈希表（Hash Table）的一个实现。字典用于存储键-元素对（更通俗的说法是键-值对）的无序集合。注意，同一个字典中的每个键都是唯一的

    字典类型的字面量如下：

map[K]T    

    其中，“K”意为键的类型，而“T”则代表元素（或称值）的类型。如果我们要描述一个键类型为int、值类型为string的字典类型的话，应该这样写：

map[int]string    

    请注意，字典的键类型必须是可比较的，否则会引起错误。也就是说，它不能是切片、字典或函数类型。
  
    字典值的字面量表示法实际上与数组和切片的字面量表示法很相似。首先，最左边仍然是类型字面量，右边紧挨着由花括号包裹且有英文逗号分隔的键值对。每个键值对的键和值之间由英文冒号分隔。以字典类型map[int]string为例，它的值的字面量可以是这样的：

map[int]string{1: "a", 2: "b", 3: "c"}

    我们可以把这个值赋给一个变量：

mm := map[int]string{1: "a", 2: "b", 3: "c"}    

    然后运用索引表达式取出字典中的值，就像这样：

b := mm[2]  

    注意，在这里，我们放入方括号中的不再是索引值（实际上，字典中的键值对也没有索引），而是与我们要取出的值对应的那个键。在上例中变量b的值必是字符串"b"。当然，也可以利用索引表达式来赋值，比如这样：

mm[2] = b + "2"   

    这使得字典mm中与键2对应的值变为了"b2"。现在我们再来向mm添加一个键值对：

mm[4] = ""  

    之后，在从中取出与`4`和`5`对应的值：

d := mm[4]
e := mm[5]

类型零值和类型别名

类型零值不是空值，而是某个变量被声明后的默认值，一般情况下，值类型的默认值为0，布尔型默认值为false,string默认值 为空字符串

我们可以对类型设置别名

//程序所属包 *必须
package main

import (
   "fmt"
   "reflect"
   "unsafe"
)

//int32起的别名
type wawa int32
//main函数
func main(){
   var i int32
   var ii wawa
   var j float32
   var b bool
   var d complex64
   var s string
  	fmt.Print("int32 默认值为")
	fmt.Println(i)
	fmt.Print("int32k数据类型值为")
	fmt.Println(reflect.TypeOf(i))
	fmt.Print("int32数据占用空间值为")
	fmt.Println(unsafe.Sizeof(i))
	fmt.Println("------------------------------")
	fmt.Print("int32k别名wawa 默认值为")
	fmt.Println(ii)
	fmt.Print("int32k别名wawa 数据类型值为")
	fmt.Println(reflect.TypeOf(ii))
	fmt.Print("int32k别名wawa 数据占用空间值为")
	fmt.Println(unsafe.Sizeof(ii))
	fmt.Println("------------------------------同类型下才可以相匹配（+-等")
	fmt.Print("float32 默认值为")
	fmt.Println(j)
	fmt.Print("bool 默认值为")
	fmt.Println(b)
	fmt.Print("complex64 默认值为")
	fmt.Println(d)
	fmt.Print("string 默认值为")
	fmt.Println(s)
}

运行结果：

int32 默认值为0
int32k数据类型值为int32
int32数据占用空间值为4
------------------------------
int32k别名wawa 默认值为0
int32k别名wawa 数据类型值为main.wawa
int32k别名wawa 数据占用空间值为4
------------------------------同类型下才可以相匹配（+-等）
float32 默认值为0
bool 默认值为false
complex64 默认值为(0+0i)
string 默认值为

类型所占存储大小