Run,You Clever Boy!

1.结构体struct

1
2
3
4
5
6
7
8
9
10

type Vertex struct {
  X int
  Y int
}
func main(){
  v := Vertex{1,2}
  v.X = 4
  fmt.Println(v.X) // 4
}

2.结构体指针

1
2
3
4

v := Vertex{1,2}
p := &v
p.X = 1e9
fmt.Println(p.X) //1000000000

3.结构体语法，可以仅列出部分字段；&可以指向结构体的指针

1
2
3
4
5
6
7

var (
  v1 = Vertex{1, 2}
  v2 = Vertex{X: 1}
  v3 = Vertex{}
  p = *Vertex{1, 2}
)
fmt.Println(v1, v2, v3, p)//{1 2} {1 0} {0 0} *{1 2}

1.指针：指针保存了变量的内存地址。

*T是指向类型T的值指针，其零值是nil

&符号会生成一个其作用对象的指针

1
2
3
4
5
6
7
8

var p *int
fmt.Println(p)
i := 42
p = &i
fmt.Println(p)

输出结果为

*表示指针指向底层的值

1

fmt.Println(*p)

并且可以通过修改指针修改底层的值

1

*p = 21

这就是常说的”间接引用”。与C语言不同，go语言的指针没有运算。

Dockerhub可以根据github工程中Dockerfile自动生成镜像，一般情况下，我们需要google下gcr的镜像，因为网络原因连接不上，我们可以将Dockerfile文件提交到github,然后生成我们自己的镜像，如：

前提是已经注册自己的Dockerhub帐号，登录https://hub.docker.com

点击右上角Create -> Create Automated Build

后登录自己的github帐号

从自己的github工程中选择要创建镜像的工程

后输入要生成的镜像名称

在Build Setting的Tab页中输入Dockerfile的位置以及tag

/目录为相对于github中工程的位置，如github中Dockerfile在/centos下

则输入/centos，再点击save changes后，点击Trigger后就可以构建镜像了，后续如果github中代码有更改，构建动作会自动触发。点击build details可以查看每次构建日志

1.for循环

go语言只有一个循环语句，即for.

1
2
3
4

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

• 不像java,python等，条件表达式不需要()小括号，循环体需要{}
• 初始化条件和后置判断条件不是必须的，如for ; i<10; {}
• 在java等语言中while循环在go语言中写法

1
2
3

for i < 10 {
  sum += i
}

• 死循环

1
2
3

for {
  sum += i
}

2.if语句

• 同for循环一样,if语句的判断条件语句也不需要()

1
2

if i<10 {
}

• 同for循环一样，条件之前也可以是一个简单的语句

1
2
3
4
5
6
7

i := 10
if j := 10; i<j {
  return j
} else {
  return i
}

3.switch语句

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

package main
import (
  "fmt"
  "runtime"
)
func main() {
  fmt.Print("Go runs on ")
  switch os := runtime.GOOS; os {
  case "darwin":
    fmt.Println("OS X.")
  case "linux":
    fmt.Println("Linux.")
  default:
    fmt.Printf("%s.", os)
  }
}

• 按照条件从上到下执行，直到匹配到成功为止，执行成功后，后边的条件不再执行
• 没有条件的switch，如switch {},同switch true {}一样

4.defer语句

• defer 语句会延迟函数的执行直到上层函数返回。

  延迟调用的参数会立刻生成，但是在上层函数返回前函数都不会被调用

1
2
3
4
5
6
7
8

package main
import "fmt";
func main(){
  defer fmt.Println("world")
  fmt.Print("hello")
}

• defer栈，延迟的函数调用会被压入一个栈中。

1
2
3
4
5
6
7
8
9
10
11

package main
import "fmt"
func main() {
  fmt.Println("counting")
  for i := 0; i < 10; i++ {
    defer fmt.Println(i)
  }
  fmt.Println("done")
}

输出结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

[Running] go run "/Users/badwolf/Documents/go/hello/defer.go"
counting
done
9
8
7
6
5
4
3
2
1
0

有三台机器172.21.3.124/125/126，需要在这三台机器配置免密码登陆能够互相访问

1.在一台机器上执行命令，如172.21.3.124，期间会输入三次回车

ssh-keygen -t rsa

2.命令会在当前用户的家目录的.ssh的目录下生成id_rsa和id_rsa.pub文件，将id_rsa.pub文件copy到其他主机(172.21.3.125)的.ssh/authorized_keys目录下

因为我的是root用户，所以copy到/root/.ssh目录下。

3.这样再登陆172.21.3.125就可以不用输入密码了。需要注意的是

authorized_keys的权限需要是600。(chmod 600 .ssh/authorized_keys)

将id_rsa.pub文件Copy到172.21.3.126上就可以免密码登陆到172.21.3.126了。

将以上的命令和步骤重复在172.21.3.125/126分别执行，

注意已经存在authorized_keys文件不能覆盖，需要在文件内容后追加其他主机的id_rsa.pub的内容。

这样就可以三台机器 间互相免密码访问了。

1. *args表示任意多个无名参数，是个tuple（元组）

2. **kwargs表示关键字参数，是个dict（字典）

这两个是python中的可变参数

注意：同时使用args和**kwargs时，args参数必须在**kwargs前边

1
2
3
4
5
6
7
8
9

def foo(*args, **kwargs):
	print 'args = ', args
	print 'kwargs = ', kwargs
    
if name == '__main__':
	foo(1,2,3,4)
	foo(a=1, b=2, c=3, d=4)
	foo(1,2,3,4,a=1, b=2, c=3, b=4)
	foo('a', 1, None, a=1, b='2', c=3)

1. Golang提供了官方的学习手册，tour地址：https://tour.go-zh.org
   同时，鉴于国内的网络环境，可以自己安装进行离线访问Go指南

1

go get github.com/Go-zh/tour/gotour

然后就可以得到go tour了

1
2

cd $GOPATH/bin
./gotour

2.包

每个 Go 程序都是由包组成的。

程序运行的入口是包 main 。

一般情况下，包名与导入路径的最后一个目录一致。

3.包的导入

1
2

import "fmt"
import "math"

或者更多时候是下面的导入形式

1
2
3
4

import (
	"fmt"
	"math"
)

4.大小写

首字母大写的名字是被导出的，可以被其他包引用，名称为小写的名称不会被导出

如：

可以引用fmt.Println()，而不能是fmt.println()

5.函数定义

1
2
3

func add(x int, y int) int{
	return x + y
}

Golang和其他语言不同，变量名在类型之前,函数返回值再最后。

如果参数类型相同，则可以合并，如上可以写成 x, y int 。

函数返回值可以返回多个，形式为(int, int)

6.变量定义

var x ,y

可以定义在包级别或者函数级别。

函数赋值var x int = 1,可以省略类型，如var x = 1。

更可以简写成x :=1,这种情况下不能在函数外使用。

变量在没有初始化为默认为零值：

• 数值类型为 0 ，
• 布尔类型为 false ，
• 字符串为 "" （空字符串）
  不同类型之间的转换需要显示转换,如 int(i)

7.常量

常量定义与变量类似，不同的是不能使用:=定义

Ubuntu下安装
1.安装openvpn客户端

sudo apt-get install openvpn

2.配置文件

复制认证所需要的文件(ca.crt xxxxx_client_vpn.ovpn xxxxx.crt xxxxx.key ta.key)到/etc/openvpn目录下

3.启动openvpn客户端

sudo openvpn /etc/openvpn/xxxxx_client_vpn.ovpn

注意：命令需要在/etc/openvpn目录下执行，否则可能出现No such file or directory错误

MAC下安装

MAC有tunnelblick软件进行图形化安装，下边主要是通过命令行安装

1.安装brew
2.通过brew进行安装

brew install openvpn

To have launchd start openvpn now and restart at startup（如果想要启动openvpn或者在启动时重启可以执行命令）:

sudo brew services start openvpn

3.安装目录

/usr/local/Cellar/openvpn/2.4.3/

4.在xxxxx_client_vpn.ovpn所在目录执行命令

sudo /usr/local/Cellar/openvpn/2.4.3/sbin/openvpn ./xxxxx_client_vpn.ovpn

CentOS7上通过yum的方式安装nginx:

1.增加CentOS 7 EPEL repository

sudo yum install -y epel-release

2.安装nginx

sudo yum install -y nginx

3.启动nginx服务

sudo systemctl start nginx

4.如果在docker中安装nginx，Dockerfile如下：

1
2
3
4
5
6
7

FROM cenos:7
CMD yum install -y epel-release
CMD yum install -y nginx
ENTRYPOINT ["nginx", "-g", "daemon off;"]

在docker中不能使用systemctl start nginx命令启动nginx

1.官网开发指南

https://wiki.jenkins.io/display/JENKINS/Plugin+tutorial

2.修改Maven的settting.xml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<settings>
  <pluginGroups>
    <pluginGroup>org.jenkins-ci.tools</pluginGroup>
  </pluginGroups>
 
  <profiles>
    <!-- Give access to Jenkins plugins -->
    <profile>
      <id>jenkins</id>
      <activation>
        <activeByDefault>true</activeByDefault> <!-- change this to false, if you don't like to have it on per default -->
      </activation>
      <repositories>
        <repository>
          <id>repo.jenkins-ci.org</id>
          <url>https://repo.jenkins-ci.org/public/</url>
        </repository>
      </repositories>
      <pluginRepositories>
        <pluginRepository>
          <id>repo.jenkins-ci.org</id>
          <url>https://repo.jenkins-ci.org/public/</url>
        </pluginRepository>
      </pluginRepositories>
    </profile>
  </profiles>
  <mirrors>
    <mirror>
      <id>repo.jenkins-ci.org</id>
      <url>https://repo.jenkins-ci.org/public/</url>
      <mirrorOf>m.g.o-public</mirrorOf>
    </mirror>
  </mirrors>
</settings>

3.创建新的插件，在命令行执行

mvn -U org.jenkins-ci.tools:maven-hpi-plugin:create

过程中要求输入插件的groupId和artifactId

编译新建的插件

mvn install

4.本地调试：

set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,address=8000,suspend=n

mvn hpi:run