go语言学习

liubulong

Go 语言的基础组成有以下几个部分：包声明 引入包 函数 变量 语句 & 表达式 注释

当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。

在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。

Go 语言按类别有以下几种数据类型：

序号        类型和描述

1        布尔型

        布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。

2        数字类型

        整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。

3        字符串类型:

        字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。

4        派生类型:

包括：

(a) 指针类型（Pointer）

(b) 数组类型

(c) 结构化类型(struct)

(d) Channel 类型

(e) 函数类型

(f) 切片类型

(g) 接口类型（interface）

(h) Map 类型

变量声明

第一种，指定变量类型，如果没有初始化，则变量默认为零值。

        数值类型（包括complex64/128）为 0  例如：var b int

        布尔类型为 false        例如：var c bool

        字符串为 ""（空字符串）        例如：var a string

        其他几种类型为 nil：        例如：var a []int

第二种，根据值自行判定变量类型。

        var d = true

第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：

        v_name := value

常量的定义格式：

const identifier [type] = value

你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

显式类型定义： const b string = "abc"

隐式类型定义： const b = "abc"

多个常量的声明可以简写为：

const c_name1, c_name2 = value1, value2

其他运算符：

&        返回变量存储地址        &a; 将给出变量的实际地址。

*        指针变量。        *a; 是一个指针变量

Go 没有三目运算符，所以不支持 ?: 形式的条件判断。

Go 语言的 For 循环有 3 中形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

for init; condition; post { }

        例如：

        func main() {

                sum := 0

                       for i := 0; i <= 10; i++ {

                        sum += i

                }

                fmt.Println(sum)

}

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }

Go 语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {

   函数体

}

例如：

/* 函数返回两个数的最大值 */

func max(num1, num2 int) int {

   /* 声明局部变量 */

   var result int

   if (num1 > num2) {

      result = num1

   } else {

      result = num2

   }

   return result

}

函数返回多个值

Go 函数可以返回多个值，例如：

实例

package main

import "fmt"

func swap(x, y string) (string, string) {

   return y, x

}

func main() {

   a, b := swap("Google", "Runoob")

   fmt.Println(a, b)

}

Go 语言变量作用域

局部变量：在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。

全局变量：在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。

声明数组

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

例如：var balance [10] float32

初始化数组：var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

Go 语言切片(Slice)

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片(切片不需要说明长度)

你可以声明一个未指定大小的数组来定义切片：

var identifier []type

或使用make()函数来创建切片:

var slice1 []type = make([]type, len)     也可以简写为 slice1 := make([]type, len)

也可以指定容量，其中capacity为可选参数。

make([]T, length, capacity)

channel:

channel 是 goroutine 之间通信的一种方式

channel 的读写操作

ch := make(chan int)

// write to channel

ch <- x

// read from channel

x <- ch

// another way to read

x = <- ch

flag:

在 go 标准库中提供了一个包：flag，方便进行命令行解析

定义 flags 有两种方式

1）flag.Xxx()，其中 Xxx 可以是 Int、String，Bool 等；

返回一个相应类型的指针，如：

var ip = flag.Int("flagname", 1234, "help message for flagname")

第一个参数 ：flag名称为flagname

第二个参数 ：flagname默认值为1234

第三个参数 ：flagname的提示信息

返回的ip是指针类型，

所以这种方式获取ip的值应该fmt.Println(*ip)

2）flag.XxxVar()，将 flag 绑定到一个变量上，

如：

var flagValue int

flag.IntVar(&flagValue, "flagname", 1234, "help message for flagname")

第一个参数 ：接收flagname的实际值的

第二个参数 ：flag名称为flagname

第三个参数 ：flagname默认值为1234

第四个参数 ：flagname的提示信息

这种方式获取ip的值fmt.Println(ip)就可以了：

select：

select的用法与switch非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述。每个case语句里必须是一个IO操作，确切的说，应该是一个面向channel的IO操作。

在执行select语句的时候，运行时系统会自上而下地判断每个case中的发送或接收操作是否可以被立即执行（立即执行：意思是当前Goroutine不会因此操作而被阻塞）。

函数和方法：

方法是包含了接收者的函数。

函数的格式是固定的：func＋函数名＋ 参数 ＋ 返回值（可选） ＋ 函数体

方法：func (variable_name variable_data_type) function_name() [return_type]{

   /* 函数体*/

}

defer后面的函数在defer语句所在的函数执行结束的时候会被调用

有两个常见的defer语句应用场景是：

1)file对象打开后的自动关闭  (在打开输入文件输出文件后，不管后面的代码流程如何影响，这两个文件能够被自动关闭。)

func CopyFile(dstName, srcName string) (written int64, err error) {

    src, err := os.Open(srcName)

    if err != nil {

        return

    }

    defer src.Close()

    dst, err := os.Create(dstName)

    if err != nil {

        return

    }

    defer dst.Close()

    // other codes

    return io.Copy(dst, src)

}

2)mutex对象锁住后的自动释放(确保mu锁能够在函数foo退出之后自动释放。)

func foo(...) {

    mu.Lock()

    defer mu.Unlock()

    // code logic

}

匿名函数的类似于下面这样子：

func main() {

   func(message string) { //声明匿名函数并执行

       println(message)

   }("hello world!")

}

并不需要函数名，最后的小括号才是真正的调用，小括号里面传参，除了可以用于goroutine以外还可以用于defer声明

传统散列：

        当节点数变化时，绝大多数键需要重新分配，传统散列表的键对应的节点由其散列值对节点总数取膜决定。

一致性散列（散列环）：一致性散列的实现方式可以被看成一个环。一致性散列可以极大地减少需要重新映射地键的数量。

        节点ID和key一样需要进行散列计算，决定自己在环上的位置。计算散列值的散列函数由算法决定，不受节点总数变化的影响。

两个相邻节点的散列值决定一个半开半闭区间的范围，落在这个范围内的键由闭节点处理。新增或删除节点的影响范围仅限于该节点跟相邻节点形成的区间。

        一致性散列还有一个比较重要的概念——虚拟节点，它让我们的负载分散得更均匀。

1301664724

看到这帖子真是高兴！