Z.S.K.'s Records

发表于 分类于 本文字数： 4.8k 阅读时长 ≈ 4 分钟

service在kubernetes是一个比较核心的概念, 得益于service机制，才让业务可以don’t care后端real pod的IP 可动态变化. 可以说,service是一组具有提供相同能力pod的代理.

阅读全文 »

发表于 分类于 本文字数： 2.3k 阅读时长 ≈ 2 分钟

经常听到运维前辈说到方法论这个词, 之前觉得很高深, 后来想想, 其实也就是经验多了, 把对某类事务的处理沉淀或者抽象为一种统一的方法. 就像下面我要说一个例子来讲一讲

阅读全文 »

发表于 分类于 本文字数： 3.1k 阅读时长 ≈ 3 分钟

项目中需要一个分布式数据库用于存储业务的KV数据, 在前期项目调研结合业务比对了业界常用的KV数据库模型后, 最后选择了CockRoachDB(CRDB).

阅读全文 »

发表于 分类于 本文字数： 2.5k 阅读时长 ≈ 2 分钟

有一个私有云环境的运维同事反应项目中的ES集群无法查询, 由于是私有云环境, 没有直接运维权限, 所以没有接收到一线报警, 远程登录上去后发现ES集群已经宕机了, 这次的排查过程也发现了几个比较容易忽视的细节, 在此记录一下,比较有意思.

阅读全文 »

发表于 分类于 本文字数： 4.5k 阅读时长 ≈ 4 分钟

字符串在所有语言中可以说是用的最频繁的一种数据结构, 在golang中当然也存在.虽然字符串往往被看做一个整体，但是实际上字符串是一片连续的内存空间，我们也可以将它理解成一个由字符组成的数组

阅读全文 »

发表于 分类于 本文字数： 2k 阅读时长 ≈ 2 分钟

生产中由于历史遗留问题，有些程序还是二进制部署, 对于这类程序需要使用守护进程进行托管，常用的能实现对程序进行守护的用的多的有如systemd, supervisor,monit等工具, monit其实更好用一些，拓展性也很强，但是因为线上已经有一些使用了supervisor，为了工具统一化，就都使用了supervisor了，这次讲一讲supervisor使用自定义邮件模板实现报警的实现

阅读全文 »

发表于 分类于 本文字数： 1.4k 阅读时长 ≈ 1 分钟

如果使用Prometheus做监控系统的话, node-exporter一定是不能绕过的采集工具, 开箱即用的实用性让运维同学节省很多时间, 最近也是发现了一个比较有意思的功能, NodeExporter可以采集额外的Metrics到Prometheus中

阅读全文 »

发表于 分类于 本文字数： 3k 阅读时长 ≈ 3 分钟

变量引用

组成一个package的多个文件，编译后实际上和一个文件类似，组成包的不同文件相互之间可以直接引用变量和函数，不论是否导出

go中对于变量(函数也是如此)使用首字母大小写来区别是否可引用. 首字母大写则能被其它包引用(不完全正常, 目前先这么理解).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// cat main.go
package main

import "fmt"

//Aa public var
var Aa int //包变量, 同时对外是public的，初始值跟变量初始值相同， int为0

const (
	a = 1 << iota
	b
	_
	d
	e
)

func main() {
  fmt.Println(Aa) // 0
  Aa := 789  //main中的局部变量，注意这里使用了 :=
	fmt.Println(Aa) // 789
	fmt.Println(a, b, d, e)
	mainxx()
}
1
2
3
4
5
6
7
8
9
10
11
// cat other.go
package main

import (
	"fmt"
)

func mainxx() {
	aa := 123
	fmt.Println(aa, Aa)
}

在命令行下运行go run .

输出很正常 

1
2
3
4
0
789
1 2 8 16
123 0

变量定义

var

var比较直接, 使用没有限制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
  "fmt"
)

var aa = 100
func fu() {
	var aa = 200
  fmt.Println(aa)
}

func main() {
  aa := 300
  fmt.Println(aa)
}

####:=

:=个人觉得是个比较好的设计, 干练简短, 虽然在开开始学的时候常常会用错

:=用于声明变量并初始化, 且只能用在函数中, 如果你在函数外使用:=会提示

non-declaration statement outside function body

1
2
3
4
5
6
7
func main() {
	var xx int
	fmt.Println(xx)
  xx := 100  // 会提示错误: no new variables on left side of :
  // xx = 100
	fmt.Println(xx)
}

上面的错误提示，说没有一个新的变量, 原因就在于xx之前已经被定义了, 不能重复定义. 所以这里只能使用赋值

a := 100这句话是声明了变量a, 且给a赋值100

make

1
2
3
4
5
6
// make slice、map和channel，并且返回一个有初始值(非零)的类型
// 声明一个slice
aSlice := make([]string, 10, 20)
// 声明一个map
aMap := make(map[string]string)
// ...

new

1
2
3
4
5
6
7
// new 用于分配了零值填充的T类型的内存空间, 它返回了一个指针，指向新分配的类型T的零值
// 申明一个整体,并返回一个指向整型的指针
aInt := new(int)
fmt.Println(*aInt) // 0
*aInt = 2
fmt.Println(*aInt) // 2
// ...

make跟new是两个用的比较多, 在这里只是简单介绍下, 后面会单独学习它们的区别

常量的定义

const

const跟其它语言的用法一样, 都是声明常量, 常量就是不能被改变的变量(当然通过常量指针还是可以修改的)

const 可以在任何地方使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import (
	"fmt"
)

const (
  aa = 100  //这里不能使用:=
  bb = 200
)

const (
	a = 1 << iota
	b
	_
	d
	e
)

func main() {
  const main_a = 100
  main_a = 200 // 如果试图修改const常量会提示: cannot assign to main_a
  fmt.Println(aa, bb, a, b, d, e, main_a)
}

iota

iota在const中比较特别, 因此特意提出来说一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const (
	mutexLocked = 1 << iota
	mutexWoken
	mutexStarving
  _
  
  // 这是一行注释
	mutexWaiterShift = iota
  xzy
)

fmt.Println(mutexLocked, mutexWoken, mutexStarving, mutexWaiterShift, xyz)
//输出
1 2 4 4 5

首先，iota是可以参与运算的， iota带表达式的都将应用到下面的常量

比如上面的1<< iota，此时等于0, 整个表达式的值为1

每二行, iota的值等于1了, 1 << 1, 整个表达式的值2

以此类推.

iota在const关键字出现时将被重置为0(const内部的第一行之前)，从第一行开始, 每新增一行常量声明(不包括空行及注释)将使iota计数一次(iota可理解为const语句块中的行索引)。使用iota能简化定义，主要用于定义枚举，而且很有用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const ( // iota在const内部的第一行之前就被初始化为0
	mutexLocked = 0 // iota=0
	mutexWoken = 2 // iota=1
	mutexStarving = 3 // iota=2
	_  // iota=3
	
  // 这是一行注释
	mutexWaiterShift = iota   // 所以当到这一行时，共增加了5行，索引从0开始，所以iota为4
	xyz
)

func main() {
  iota := 33  //iota不是关键字， 因此也可以被当成一个普通的变量对待，跟其它变量没有区别
	fmt.Println(mutexLocked, mutexWoken, mutexStarving, mutexWaiterShift, xyz)
  fmt.Println(iota)
}
//输出
0 2 3 4 5
33

const及iota可参考这里

常见基本类型零值

1
2
3
4
5
6
7
8
9
10
11
12
// 常见的基本类型零值
int     0
int8    0
int32   0
int64   0
uint    0x0
rune    0 //rune的实际类型是 int32
byte    0x0 // byte的实际类型是 uint8
float32 0 //长度为 4 byte
float64 0 //长度为 8 byte
bool    false
string  ""

有个比较特殊的零值nil, 这个必须要单独说.

问题

如果把一个包分成多个文件，在IDE如vscode中run时，可提示如下错误

最开始的时候一脸茫然, 很明显是因为在ide运行的时候，执行的命令是go run main.go, 只传入了一个main.go,而没有传递others.go, 因此找不到mainxx(), 在命令行下执行也会报同样的错误. 需要运行go run .或者go run *.go,另外, 最好不要形成循环引用, 如果两个文件需要相互引用的话, 引用第三方是个推荐的办法.

参考文章:

0%