source /etc/profile

单一用户：~/.bash_profile

多用户：/etc/profile

环境变量：

export GOROOT=/usr/local/go

export GOPATH=~/golib:~/goproject

export GOBIN=~/gobin

export PATH=$PATH:$GOROOT/bin:$GOBIN

如果填的是0，代表`myChannel`是一个非缓存通道。发送方在向通道值发送数据的时候会立即被阻塞，直到有某一个接收方已从该通道值中接收了这条数据。

所以在第一个匿名函数执行到`sender <- number`语句之后，便被阻塞了，这时第二个匿名函数开始被执行。等到语句`fmt.Println("Received!", <-receiver)`被执行之后，通道内的值被清空了，`sender <- number`之后的语句继续被执行。所以就会看到

Received! 6

Sent!

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, %v\n", length == len(slice5), capacity == cap(slice5))

slice5 = slice5[:cap(slice5)]

slice5 = append(slice5, 11, 12, 13)

length = (7)

fmt.Printf("%v\n", length == len(slice5))

slice6 := []int{0, 0, 0}

copy(slice5, slice6)

e2 := (0)

e3 := (8)

e4 := (11)

fmt.Printf("%v, %v, %v\n", e2 == slice5[2], e3 == slice5[3], e4 == slice5[4])

}

一个切片值的容量即为它的第一个元素值在其底层数组中的索引值与该数组长度的差值的绝对值

length := (3)

capacity := (3)

func main() {

    var numbers2 [5]int

numbers2[0] = 2

numbers2[3] = numbers2[0] - 3

numbers2[1] = numbers2[2] + 5

numbers2[4] = len(numbers2)

sum := (11)

// “==”用于两个值的相等性判断

fmt.Printf("%v\n", (sum == numbers2[0]+numbers2[1]+numbers2[2]+numbers2[3]+numbers2[4]))

}

有符号的整数类型int和无符号的整数类型uint

0.000589

基础命令

go run ：
1、用于运行命令源码文件，只能接受1个命令源码文件以及若干个库源码文件作为文件参数。

2、操作步骤  先编译源码文件 》临时文件夹  》运行  》结果：可执行文件  以及  归档文件

命令的更多细节以及更多命令，参见《Go命令教程》：

https://github.com/hyper-carrot/go_command_tutorial

Go语言原生的支持并发

请在命令源码文件index.go的第12行的反引号中填入变量str1所代表的字符串值。

```

package main

import ( 

    "fmt" 

)

func main() {

    // 声明一个string类型变量并赋值

    var str1 string = "\\\"" 

    // 这里用到了字符串格式化函数。其中，%q用于显示字符串值的表象值并用双引号包裹。

    fmt.Printf("用解释型字符串表示法表示的 %q 所代表的是 %s。\n", str1, (`\"`) )//12行

}

```

"\\\""所代表的字符串值是\"。

go run

    用于运行命令源码文件

    只能接受一个命令源码文件以及若干个库源码文件作为文件参数

go bulid

go install

go get

Go语言的优势

1，脚本化的语法

2，静态类型+编译型，程序运行速度有保障，速度大于动态类型+解释型语言，速度高出很多

3，原生的支持并发编程

降低开发、维护成本

程序可以更好的执行

Go语言的劣势

1，语法糖并没有Python和Ruby那么多

2，目前的程序运行速度还不及C，速度已赶超C++和java

3，第三方函数库暂时不像绝对主流的编程语言那么多

Go源码文件:名称以.go为后缀，内容以Go语言代码组织的文件   多个Go源码文件是需要用代码包组织起来的
  源码文件分为三类:命令源码文件、库源码文件(go语言程序)    测试源码文件(辅助源码文件)
  命令源码文件:声明自己属于main代码包、包含无参数声明和结果声明的main函数;被安装后，相应的可执行文件会被存放到GOBIN指向的目录或<当前工作区目录>/bin下
              命令源码文件是Go程序的入口，但不建议把程序都写在一个文件中;同一个代码包中强烈不建议直接包含多个命令源码文件。
  库源码文件:不具备命令源码文件的那两个特征的源码文件, 被安装后，相应的归档文件会被存放到<当前工作区目录>/pkg/<平台相关目录>下
  测试源码文件:不具备命令源码文件的那两个特征的源码文件。名称以_test.go为后缀。其中至少有一个函数的名称以Test或Benchmark为前缀。并且，该函数接受一个类型为
              *testing.T或*testing.B的参数
              func TestFind(t *testing.T){//省略若干条语句}  func BenchmarkFind(b *testing.B){//省略若干条语句}

ffll

fgdf
gsgg

结构体比函数类型更加灵活，他可以封装属性和操作。

匿名结构体无方法。

与其它的数据类型不同，我们无法表示一个通道类型的值。因此，我们也无法用字面量来为通道类型的变量赋值。我们只能通过调用内建函数make来达到目的

Map）类型其实是哈希表的一个实现。字典用于存储键-元素对

被“切下”的部分不包含元素上界索引指向的元素

也就是左开右闭

切片与数组的类型字面量的唯一不同是不包含代表其长度的信息

GOROOT 安装包所在路径，GOPATH go语言的工作目录GOBING 存放编译后的程序

指针类型同时拥有指针类型方法和值类型方法，但是值类型只拥有值类型方法

为什么切片都是基于底层数组操作呢？有啥好处啊？节省内存，数组的复制是值复制

slice5 := numbers4[4:6:8] 这里边的8指的是容量上界的索引，而且不包含numbers4[8]。

append 之后如果容量没有超过原容量，还会新建数组吗？不会新建数组，直接修改了底层数组中的数据。实验代码

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, %v\n", length == len(slice5), capacity == cap(slice5))

    slice5 = slice5[0:1]

    var slice7 = slice5[:3]

     fmt.Printf("修改前slice7 %v\n", slice7[1])

     var slice6 = append(slice5, 11)

     fmt.Printf("修改后slice6 %v\n", slice6[1])

     fmt.Printf("修改后slice7 %v\n", slice7[1])

     slice5 = append(slice5, 2)

     fmt.Printf("修改原始切片后slice7 %v\n", slice7[1])

     fmt.Printf("修改原始切片后slice6 %v\n", slice6[1])

}

time.Sleep

runtime.Gosched()